Краткий ответ

Два замыкания с одинаковыми параметрами и возвращаемым типом всё равно имеют разные анонимные типы: каждый литерал замыкания создаёт собственный тип. Они совместимы не напрямую, а через вызов, обобщённые границы Fn, FnMut или FnOnce, либо через приведение к указателю на функцию, если замыкание не захватывает окружение.

Исторический контекст

Замыкания нужны для передачи поведения без объявления отдельного именованного типа или функции. В Rust они спроектированы как эффективная абстракция: компилятор создаёт скрытый тип, который хранит захваченные значения и реализует подходящие трейты семейства Fn.

Такой подход позволяет проверять захваты, владение и время жизни статически, не требуя обязательного выделения памяти в куче или динамической диспетчеризации.

Постановка проблемы

Одинаковая сигнатура описывает только способ вызова, но не идентичность замыкания. Если считать любые замыкания с одинаковой сигнатурой взаимозаменяемыми типами, можно ошибочно ожидать присваивания одного замыкания другому или хранения их в одной переменной без дополнительного типа-обёртки.

На практике важно также учитывать захваты. Замыкание без захватов может быть приведено к типу указателя на функцию, а замыкание, захватывающее состояние, таким способом представить нельзя без потери этого состояния.

Подробное решение

Каждое выражение-замыкание порождает уникальный анонимный тип. Этот тип содержит захваченное окружение и автоматически реализует один или несколько трейтов: Fn — если вызов не изменяет состояние и не потребляет его, FnMut — если состояние изменяется, FnOnce — если вызов может потребить захват.

Поэтому два замыкания могут иметь одинаковую сигнатуру вызова, но несовместимые конкретные типы. Обобщённая функция принимает их благодаря трейтовой границе, а не потому, что типы замыканий совпадают.

fn apply<F: Fn(i32) -> i32>(value: i32, f: F) -> i32 {
    f(value)
}

fn main() {
    let first = |x: i32| x + 1;
    let second = |x: i32| x + 1;

    println!("{}", apply(10, first));
    println!("{}", apply(10, second));
}

Здесь first и second имеют разные скрытые типы, но оба удовлетворяют границе Fn(i32) -> i32. Нельзя объявить переменную одного конкретного типа замыкания и затем присвоить ей другое замыкание, даже если их тела и сигнатуры совпадают.

Для хранения разных замыканий в одной коллекции обычно используют Box<dyn Fn(...) -> ...>: это стирает конкретный тип и добавляет динамическую диспетчеризацию. Компромисс — потенциальное выделение памяти и вызов через таблицу виртуальных методов; обобщённый параметр сохраняет статическую диспетчеризацию, но каждый конкретный тип обычно порождает отдельную специализацию кода.

Замыкание без захватов может быть приведено к указателю на функцию, поскольку ему не требуется хранить окружение. Такое приведение подходит только когда нужна именно обычная функция, а не состояние замыкания или произвольный тип, реализующий Fn.

Ситуация из практики

В обработчике событий нужно зарегистрировать несколько функций обратного вызова в одном списке. Вариант с обобщённым параметром эффективен, но один контейнер не может содержать элементы разных конкретных типов замыканий.

Можно объявить отдельные именованные функции, но это неудобно для локального состояния и увеличивает объём кода. Можно хранить указатели на функции, однако этот вариант исключает замыкания с захваченным состоянием.

Выбранное решение — хранить обработчики как Box<dyn Fn(Event)>. Оно поддерживает разные замыкания и их окружения; цена решения — динамическая диспетчеризация и обычно размещение объектов в куче. Если набор обработчиков известен заранее и производительность критична, предпочтительнее статическая диспетчеризация или перечисление с отдельными вариантами для разных обработчиков.

Что кандидаты часто упускают

Вопрос: Реализуют ли все замыкания трейт Fn?

Ответ: Нет. Замыкание реализует как минимум FnOnce, потому что его всегда можно вызвать один раз. Если оно изменяет захваченное состояние, но не потребляет его, оно также реализует FnMut; если не изменяет и не потребляет захваты, обычно реализует Fn. Иерархия требований такова: Fn подходит там, где требуется FnMut или FnOnce, а FnMut — там, где требуется FnOnce.
Вопрос: Почему замыкание без захватов можно передать туда, где ожидается указатель на функцию?

Ответ: У такого замыкания нет окружения, которое нужно хранить. Поэтому Rust может безопасно преобразовать его в обычный указатель на функцию с соответствующей сигнатурой. Замыкание, захватывающее переменную, содержит состояние и не может быть преобразовано в указатель, который это состояние не представляет.
Вопрос: Что выбрать для хранения разных замыканий: impl Fn или dyn Fn?

Ответ: impl Fn скрывает один конкретный тип, выбранный функцией, поэтому значение подходит для возврата одного типа замыкания и сохраняет статическую диспетчеризацию. dyn Fn обозначает объект трейта и позволяет работать с разными конкретными типами через единый интерфейс, но использует динамическую диспетчеризацию и требует подходящего размещения, часто Box. Выбор определяется тем, нужна ли однородность типов и приоритетна ли гибкость контейнера или максимальная статическая оптимизация.