Closures

A closure is a small function with no name that you can store and pass around.

Closure syntax

Put the inputs between bars, then the body.

1let add_one = |x: i32| x + 1;2let both = |a: i32, b: i32| {3    let s = a + b;4    s * 25};6println!("{}", add_one(4)); // 57println!("{}", both(1, 2)); // 6

Types are often left out, and Rust works them out from the first call. After that, the types are fixed.

Capturing variables

A closure can use variables from the place where it was made. A normal fn can't do this.

1let n = 10;2let add_n = |x| x + n; // reads n3println!("{}", add_n(5)); // 15

Rust picks the lightest way to capture:

• read only: a shared borrow
• change it: a mutable borrow (the closure variable must be mut)
• use it up: take ownership

move closures

Write move before the bars to make the closure take ownership of what it uses. Use it when the closure may outlive those variables, like in a thread.

1let v = vec![1, 2];2let f = move || v.len();3println!("{}", f());4// v can't be used here, it moved into f

Copy types like i32 are copied in, so the old variable still works.

A function can return a closure as impl Fn() -> String (inputs in the brackets, output after ->). Add move so the closure owns what it uses.

Fn, FnMut, FnOnce

Every closure has one or more of these traits:

Every closure is at least FnOnce. A function that takes F: Fn() will not accept a closure that changes a capture.

Remember

• A closure that changes a capture must be stored in a mut variable.
• move takes ownership; use it for threads and returned closures.
• Fn reads, FnMut changes, FnOnce uses up.