Closures

Why closures?

Many functions take "a bit of behaviour" as input: sort these orders by this key, keep only items that pass this test, run this when the button is clicked. Writing a full named function for each tiny rule is noisy. A closure is an anonymous (nameless) function you write right where you need it.

let add_gst = |price: u32| price + price * 18 / 100;
println!("{}", add_gst(100));          // 118

let mut orders = vec![("Asha", 450), ("Ravi", 120), ("Meena", 980)];
orders.sort_by_key(|o| o.1);             // sort by amount
println!("{:?}", orders);                // [("Ravi", 120), ("Asha", 450), ("Meena", 980)]

Capturing the environment

The big difference from a normal fn: a closure can use variables from the surrounding scope. This is called capturing. A normal fn cannot see local variables of other functions.

let min_order = 200;
let big_orders: Vec<_> = orders.iter()
    .filter(|o| o.1 >= min_order)        // uses min_order from outside
    .collect();
println!("{:?}", big_orders);

Three ways to capture

Rust picks the gentlest capture that works, following the ownership rules you already know:

let mut count = 0;
let mut tick = || count += 1;   // FnMut: changes count
tick();
tick();
println!("{count}");            // 2

let name = String::from("Kabir");
let consume = move || name;     // FnOnce: returns (moves out) name
let n = consume();
// consume();                   // error: closure can only be called once

Every closure that implements Fn also counts as FnMut and FnOnce, so a function that asks for FnOnce accepts any closure. A function that asks for Fn is the strictest.

The move keyword

move forces the closure to take ownership of everything it captures, even if it only reads. You need it when the closure must outlive the current scope, such as when you send it to another thread (module 9) or return it from a function.

fn make_multiplier(factor: u32) -> impl Fn(u32) -> u32 {
    move |x| x * factor      // factor is copied into the closure
}

fn main() {
    let triple = make_multiplier(3);
    println!("{}", triple(7));   // 21
}

Taking closures as parameters

fn apply_twice<F: Fn(i32) -> i32>(f: F, x: i32) -> i32 {
    f(f(x))
}

println!("{}", apply_twice(|n| n + 10, 1));   // 21

Common mistakes

• Forgetting mut on a closure that changes captured variables: "cannot borrow as mutable". Write let mut tick = ...
• Returning a closure that borrows a local variable: "may outlive borrowed value". Add move.
• Using a variable after a move closure took it. Clone it before the closure if you need both.
• Asking for Fn when the caller passes a closure that changes state. Use FnMut.