Closures: Capturing Environment and Function Traits

Snippet

Closures: Capturing Environment and Function Traits

Rust closures capture variables from their environment. FnMut allows mutation of captured variables, Fn consumes them, and FnOnce takes ownership. Generic bounds let you write functions that accept different closure types.

snippet.rs
rust
fn apply_with_log<F, T>(mut f: F, value: T) -> T
where
    F: FnMut(T) -> T,
{
    println!("Before: {:?}", value);
    let result = f(value);
    println!("After: {:?}", result);
    result
}
 
fn main() {
    let multiplier = 3i32;
    let increment = 10i32;
    
    let mut combined = |x: i32| -> i32 {
        x * multiplier + increment
    };
    
    let result = apply_with_log(combined, 5);
    println!("Final result: {}", result);
    
    let numbers = vec![1, 2, 3, 4, 5];
    let sum: i32 = numbers.iter().map(|x| x * multiplier).sum();
    println!("Sum: {}", sum);
}

Breakdown

FnMut(T) -> T

FnMut can mutate captured environment, returns transformed value

let multiplier = 3i32;

Variable captured by closure, lives in closure's environment

let mut combined = |x: i32| -> i32 { ... }

Closure captures both multiplier and increment from scope

numbers.iter().map(|x| x * multiplier)

Closure passed to iterator, captured multiplier used inline

Previous snippet Next snippet

More Intermediate Rust exercises →

From your library

Closures: Capturing Environment and Function Traits

Related