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

Способ захвата определяется тем, как тело замыкания использует переменную: компилятор выбирает наименее сильный режим, достаточный для этого использования. Чтение обычно приводит к захвату по неизменяемой ссылке, изменение — по изменяемой ссылке, а передача значения наружу или требование владения — к перемещению.

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

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

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

В Rust режим захвата связывает время жизни замыкания с владельцами данных и одновременно сообщает компилятору, какие операции над внешними переменными допустимы. Это позволяет использовать замыкания без сборщика мусора и без ручного управления временем жизни.

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

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

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

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

Rust анализирует операции над каждой захватываемой переменной и выбирает минимальный подходящий режим:

неизменяемый захват — если замыкание только читает значение;
изменяемый захват — если замыкание изменяет значение;
захват по владению — если значение перемещается из замыкания, возвращается из него или замыканию необходимо владеть им.

Ключевое слово move меняет это решение: все используемые внешние переменные захватываются по значению. Для типа, не реализующего Copy, это обычно означает перемещение; для типа Copy в замыкание попадает копия.

fn main() {
    let name = String::from("Rust");
    let print_name = || println!("{name}");

    print_name();
    println!("{name}");
}

В примере замыкание только читает name, поэтому оно может захватить строку по неизменяемой ссылке. Владение остаётся в main, и переменная доступна после вызова.

Если добавить move, строка будет перемещена в замыкание. Это необходимо, например, когда замыкание должно пережить текущую область видимости, но после такого захвата исходная переменная недоступна.

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

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

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

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

Практически выбирают захват по владению, часто с передачей move. Замыкание получает самостоятельное владение данными, исходная функция может завершиться, а компилятор проверяет, что переданные значения допустимо использовать в выбранном контексте. Цена решения — невозможность использовать перемещённое значение прежним владельцем и, при необходимости, необходимость явно применить Arc, Clone или другой способ совместного владения.

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

Всегда ли move означает физическое копирование данных?

Нет. move означает передачу владения, а не обязательное перемещение байтов в памяти. Для значения вроде String в замыкание может перейти его дескриптор, содержащий указатель, длину и ёмкость; сами байты могут остаться на прежнем месте. После передачи прежний владелец теряет право использовать значение, чтобы не возникло двойного освобождения.

Почему замыкание иногда автоматически захватывает только часть структуры?

Современный Rust может захватывать отдельные используемые поля, если это безопасно и позволяет анализ захвата. Тогда обращение к одному полю не обязательно делает недоступной всю структуру. Однако перемещение поля, заимствование всей структуры, особенности представления или явный move могут привести к более широкому захвату.

Следствие важно учитывать при проектировании API: изменение выражения внутри замыкания способно изменить режим и область захвата, а вместе с ними — возможность дальнейшего использования исходной переменной.

Почему move особенно часто встречается при передаче замыкания в поток?

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

move решает именно проблему передачи владения, но не делает произвольные данные потокобезопасными. Если состояние разделяется между потоками, дополнительно требуются подходящие ограничения типов и синхронизация, например Mutex или атомарные типы.