Замыкания: Fn / FnMut / FnOnceClosures: Fn / FnMut / FnOnce

Замыкание записывается как |параметры| тело (например, |x, y| x + y, или move |x| x + captured_var). Каждое замыкание реализует один, два или все три трейта: Fn (можно вызывать многократно, нужен только &self — захватывает по ссылке и не изменяет захваченное), FnMut (можно вызывать многократно, нужен &mut self — захватывает по изменяемой ссылке либо мутирует окружение), FnOnce (можно вызвать только один раз, нужен self по значению — захватывает/потребляет переменную, которую не может вернуть обратно). Какой именно трейт(ы) реализует конкретное замыкание, компилятор выводит автоматически из того, что тело замыкания реально делает со своими захватами.A closure is written |params| body (e.g. |x, y| x + y, or move |x| x + captured_var). Every closure implements one, two, or all three traits: Fn (callable multiple times, only needs &self — captures by reference and doesn't mutate them), FnMut (callable multiple times, needs &mut self — captures by mutable reference or mutates its environment), FnOnce (callable only once, needs self by value — captures/consumes a variable it can't give back). Which trait(s) a given closure implements is inferred automatically by the compiler from what the closure's body actually does with its captures.

let numbers = vec![1, 2, 3, 4, 5];
let threshold = 2;

let above: Vec<&i32> = numbers.iter()
    .filter(|&&x| x > threshold)  // Fn: читает threshold по ссылке, вызывается на каждый элемент// Fn: reads threshold by reference, called once per element
    .collect();

Три трейта кодируют ownership/borrowing напрямую в типе замыкания:The three traits encode ownership/borrowing directly in the closure's own type:

Замыкание, мутирующее захваченный счётчик, реализует FnMut. Замыкание с move, передаваемое в thread::spawn, забирает владение захваченным значением — spawn требует как минимум FnOnce (гарантированно вызывается ровно один раз, поэтому более сильный Fn/FnMut не нужен).A closure mutating a captured counter implements FnMut. A move closure passed to thread::spawn takes ownership of the captured value — spawn's actual bound is FnOnce (it's guaranteed to run exactly once, so the stronger Fn/FnMut isn't required).

let mut count = 0;
let mut increment = || count += 1;  // FnMut: мутирует захваченный count// FnMut: mutates the captured count
increment();
increment();
println!("{}", count);  // 2// 2

let data = vec![1, 2, 3];
let handle = std::thread::spawn(move || {
    println!("{:?}", data);  // FnOnce: spawn требует не больше FnOnce, потому что вызов гарантированно один// FnOnce: spawn requires no more than FnOnce, since the call is guaranteed to run once
});
handle.join().unwrap();

Функция, принимающая замыкание, объявляет требуемый трейт явно в границах дженерика: fn apply<F: Fn(i32) -> i32>(f: F, x: i32) -> i32.A function accepting a closure declares the required trait explicitly as a generic bound: fn apply<F: Fn(i32) -> i32>(f: F, x: i32) -> i32.

• The Rust Book — Closures
• Rust by Example — Closures