Closures - Anonymous Functions

Advanced ~35 min read

Closures are anonymous functions that can capture variables from their surrounding environment. They're incredibly useful for functional programming patterns, working with iterators, and writing concise, expressive code. Rust's closures are zero-cost abstractions with powerful type inference.

What Are Closures?

A closure is an anonymous function you can save in a variable or pass as an argument to other functions. Unlike regular functions, closures can capture values from the scope in which they're defined.

Key Difference: Functions use fn keyword and can't capture environment. Closures use || syntax and can capture variables from their surrounding scope.

Closure Syntax

fn main() {
    // Basic closure syntax
    let add_one = |x| x + 1;
    println!("5 + 1 = {}", add_one(5));
    
    // Closure with type annotations
    let add_two = |x: i32| -> i32 { x + 2 };
    println!("5 + 2 = {}", add_two(5));
    
    // Closure with multiple parameters
    let multiply = |x, y| x * y;
    println!("3 * 4 = {}", multiply(3, 4));
    
    // Closure with multiple statements
    let complex = |x| {
        let result = x * 2;
        result + 1
    };
    println!("Complex: {}", complex(5));
    
    // Closures can capture environment
    let x = 10;
    let add_x = |y| y + x;  // Captures x from environment
    println!("5 + 10 = {}", add_x(5));
    
    // Using closures with iterators
    let numbers = vec![1, 2, 3, 4, 5];
    
    let doubled: Vec<i32> = numbers.iter()
        .map(|x| x * 2)
        .collect();
    println!("Doubled: {:?}", doubled);
    
    let sum: i32 = numbers.iter()
        .filter(|x| *x % 2 == 0)
        .sum();
    println!("Sum of evens: {}", sum);
    
    // Closure as function parameter
    fn apply_operation<F>(x: i32, f: F) -> i32
    where
        F: Fn(i32) -> i32,
    {
        f(x)
    }
    
    let result = apply_operation(10, |x| x * 3);
    println!("Result: {}", result);
}

// Closures are anonymous functions
// Syntax: |params| expression or |params| { statements }
// Can capture variables from their environment

Output

Click Run to execute your code

Syntax Variations

Syntax	Example	Use Case
Simple	`\|x\| x + 1`	Single expression, type inference
With types	`\|x: i32\| -> i32 { x + 1 }`	Explicit types
Multiple params	`\|x, y\| x + y`	Multiple parameters
Block body	`\|x\| { let y = x * 2; y + 1 }`	Multiple statements

Capturing the Environment

Closures can capture variables from their surrounding scope in three ways:

fn main() {
    // Three ways closures capture variables:
    
    // 1. Fn - Borrows immutably
    let list = vec![1, 2, 3];
    let only_borrows = || println!("List: {:?}", list);
    
    only_borrows();
    println!("Can still use list: {:?}", list);  // list is still valid
    
    // 2. FnMut - Borrows mutably
    let mut list2 = vec![1, 2, 3];
    let mut borrows_mutably = || list2.push(4);
    
    borrows_mutably();
    println!("Modified list: {:?}", list2);
    
    // 3. FnOnce - Takes ownership
    let list3 = vec![1, 2, 3];
    let takes_ownership = || {
        println!("Taking ownership: {:?}", list3);
        drop(list3);  // Consumes list3
    };
    
    takes_ownership();
    // println!("{:?}", list3);  // Error: list3 was moved
    
    // move keyword forces ownership
    let x = vec![1, 2, 3];
    let closure = move || println!("Moved: {:?}", x);
    
    closure();
    // println!("{:?}", x);  // Error: x was moved
    
    // Useful with threads
    use std::thread;
    
    let data = vec![1, 2, 3];
    let handle = thread::spawn(move || {
        println!("Thread data: {:?}", data);
    });
    
    handle.join().unwrap();
    
    // Function traits hierarchy
    fn apply_fn<F>(f: F) where F: Fn() {
        f();
    }
    
    fn apply_fn_mut<F>(mut f: F) where F: FnMut() {
        f();
    }
    
    fn apply_fn_once<F>(f: F) where F: FnOnce() {
        f();
    }
    
    let s = String::from("hello");
    apply_fn(|| println!("{}", s));
    apply_fn_mut(|| println!("{}", s));
    apply_fn_once(|| println!("{}", s));
}

// Fn traits:
// - Fn: can be called multiple times, borrows immutably
// - FnMut: can be called multiple times, borrows mutably
// - FnOnce: can be called once, takes ownership
// move keyword forces closure to take ownership

Output

Click Run to execute your code

The Three Fn Traits

Trait	Capturing	Can Call	Example
`Fn`	Borrows immutably	Multiple times	`\|\| println!("{}", x)`
`FnMut`	Borrows mutably	Multiple times	`\|\| list.push(4)`
`FnOnce`	Takes ownership	Once	`\|\| drop(x)`

Pro Tip: Rust automatically chooses the most restrictive trait that works. If a closure only reads variables, it implements Fn. If it modifies them, FnMut. If it consumes them, FnOnce.

The move Keyword

Use move to force a closure to take ownership of captured variables:

let x = vec![1, 2, 3];
let closure = move || println!("{:?}", x);

closure();
// println!("{:?}", x);  // Error: x was moved

When to use move: Essential for threads and async code where the closure needs to outlive the current scope.

Closures with Iterators

fn main() {
    // Closures with iterators - functional programming style
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
    // map - transform each element
    let doubled: Vec<i32> = numbers.iter()
        .map(|x| x * 2)
        .collect();
    println!("Doubled: {:?}", doubled);
    
    // filter - keep elements matching condition
    let evens: Vec<&i32> = numbers.iter()
        .filter(|x| *x % 2 == 0)
        .collect();
    println!("Evens: {:?}", evens);
    
    // filter_map - filter and transform in one step
    let results: Vec<i32> = numbers.iter()
        .filter_map(|x| {
            if x % 2 == 0 {
                Some(x * 2)
            } else {
                None
            }
        })
        .collect();
    println!("Even doubled: {:?}", results);
    
    // fold - reduce to single value
    let sum = numbers.iter()
        .fold(0, |acc, x| acc + x);
    println!("Sum: {}", sum);
    
    // Chain multiple operations
    let result: Vec<i32> = numbers.iter()
        .filter(|x| *x % 2 == 0)
        .map(|x| x * x)
        .filter(|x| *x > 10)
        .collect();
    println!("Even squares > 10: {:?}", result);
    
    // find - get first matching element
    let first_even = numbers.iter()
        .find(|x| *x % 2 == 0);
    println!("First even: {:?}", first_even);
    
    // any and all
    let has_even = numbers.iter().any(|x| x % 2 == 0);
    let all_positive = numbers.iter().all(|x| *x > 0);
    println!("Has even: {}, All positive: {}", has_even, all_positive);
    
    // Custom iterator methods
    struct Counter {
        count: u32,
    }
    
    impl Counter {
        fn new() -> Counter {
            Counter { count: 0 }
        }
    }
    
    impl Iterator for Counter {
        type Item = u32;
        
        fn next(&mut self) -> Option<Self::Item> {
            if self.count < 5 {
                self.count += 1;
                Some(self.count)
            } else {
                None
            }
        }
    }
    
    let sum: u32 = Counter::new()
        .map(|x| x * x)
        .sum();
    println!("Sum of squares 1-5: {}", sum);
    
    // Returning closures
    fn make_adder(x: i32) -> impl Fn(i32) -> i32 {
        move |y| x + y
    }
    
    let add_5 = make_adder(5);
    println!("10 + 5 = {}", add_5(10));
}

// Closures enable functional programming patterns
// Lazy evaluation with iterators
// Chain operations for readable, efficient code
// Can return closures using impl Fn

Output

Click Run to execute your code

Common Iterator Methods

Method	Purpose	Example
`map`	Transform each element	`.map(\|x\| x * 2)`
`filter`	Keep matching elements	`.filter(\|x\| *x > 5)`
`fold`	Reduce to single value	`.fold(0, \|acc, x\| acc + x)`
`find`	Find first match	`.find(\|x\| *x == 5)`
`any`	Check if any match	`.any(\|x\| *x > 10)`
`all`	Check if all match	`.all(\|x\| *x > 0)`

Returning Closures

You can return closures using impl Fn:

fn make_adder(x: i32) -> impl Fn(i32) -> i32 {
    move |y| x + y
}

let add_5 = make_adder(5);
println!("{}", add_5(10));  // 15

Type Inference

Closures have powerful type inference:

// Compiler infers types from usage
let add = |x, y| x + y;
let result = add(5, 10);  // Infers i32

// Once used, types are fixed
// let result2 = add(5.0, 10.0);  // Error: expected i32

Best Practices

Use closures for short functions: Especially with iterators
Let type inference work: Only add types when needed
Use move for threads: Ensure closure owns its data
Chain iterator methods: Readable, efficient functional code
Prefer closures over loops: More expressive with iterators
Know your Fn traits: Understand capturing behavior

Common Mistakes

1. Forgetting to dereference in closures

// Wrong - comparing references
let numbers = vec![1, 2, 3];
let evens: Vec<&i32> = numbers.iter()
    .filter(|x| x % 2 == 0)  // Error: can't mod &i32
    .collect();

// Correct - dereference with *
let evens: Vec<&i32> = numbers.iter()
    .filter(|x| *x % 2 == 0)
    .collect();

2. Using closure after move

// Wrong - using moved value
let x = vec![1, 2, 3];
let closure = move || println!("{:?}", x);
closure();
println!("{:?}", x);  // Error: x was moved

// Correct - clone if you need both
let x = vec![1, 2, 3];
let x_clone = x.clone();
let closure = move || println!("{:?}", x_clone);
closure();
println!("{:?}", x);  // OK!

3. Trying to return closure without impl Fn

// Wrong - can't return closure type directly
fn make_adder(x: i32) -> ??? {  // What type?
    |y| x + y
}

// Correct - use impl Fn
fn make_adder(x: i32) -> impl Fn(i32) -> i32 {
    move |y| x + y
}

Exercise: Closures Practice

Task: Practice closures with temperature conversion, filtering, and functional patterns.

// Exercise: Closures Practice

fn main() {
    // TODO: Create a closure that squares a number
    // let square = |x| { ... };
    // println!("5 squared: {}", square(5));
    
    // TODO: Create a closure that captures a variable and adds it
    let base = 10;
    // let add_base = |x| { ... };
    // println!("5 + 10 = {}", add_base(5));
    
    // TODO: Use map to convert temperatures from Celsius to Fahrenheit
    // Formula: F = C * 9/5 + 32
    let celsius = vec![0, 10, 20, 30, 40];
    // let fahrenheit: Vec<i32> = celsius.iter()
    //     .map(|c| { ... })
    //     .collect();
    // println!("Fahrenheit: {:?}", fahrenheit);
    
    // TODO: Filter numbers greater than 5 and square them
    let numbers = vec![1, 3, 5, 7, 9, 11];
    // let result: Vec<i32> = numbers.iter()
    //     .filter(|x| { ... })
    //     .map(|x| { ... })
    //     .collect();
    // println!("Filtered and squared: {:?}", result);
    
    // TODO: Calculate sum of even numbers
    let nums = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    // let sum: i32 = nums.iter()
    //     .filter(|x| { ... })
    //     .sum();
    // println!("Sum of evens: {}", sum);
    
    // TODO: Create a function that returns a closure
    // The closure should multiply by the given factor
    // fn make_multiplier(factor: i32) -> impl Fn(i32) -> i32 {
    //     move |x| { ... }
    // }
    
    // let times_3 = make_multiplier(3);
    // println!("5 * 3 = {}", times_3(5));
    
    // TODO: Use fold to find the maximum value
    let values = vec![3, 7, 2, 9, 1, 5];
    // let max = values.iter()
    //     .fold(0, |acc, x| { ... });
    // println!("Max: {}", max);
}

// Hints:
// 1. Closure syntax: |params| expression or |params| { body }
// 2. Closures capture variables from environment
// 3. Use * to dereference in closures: *x
// 4. filter keeps elements where closure returns true
// 5. map transforms each element
// 6. fold accumulates values: fold(initial, |accumulator, item| ...)

Output

Click Run to execute your code

Show Solution

let square = |x| x * x;

let base = 10;
let add_base = |x| x + base;

let fahrenheit: Vec = celsius.iter()
    .map(|c| c * 9 / 5 + 32)
    .collect();

let result: Vec = numbers.iter()
    .filter(|x| *x > 5)
    .map(|x| x * x)
    .collect();

let sum: i32 = nums.iter()
    .filter(|x| *x % 2 == 0)
    .sum();

fn make_multiplier(factor: i32) -> impl Fn(i32) -> i32 {
    move |x| x * factor
}

let max = values.iter()
    .fold(0, |acc, x| if x > &acc { *x } else { acc });

Summary

Closures are anonymous functions that capture environment
Syntax: |params| expression or |params| { body }
Three Fn traits: Fn, FnMut, FnOnce
Fn borrows immutably, can call multiple times
FnMut borrows mutably, can call multiple times
FnOnce takes ownership, can call once
move keyword forces ownership transfer
Work seamlessly with iterators
Type inference makes closures concise
Zero-cost abstraction - no runtime overhead

What's Next?

Now that you understand closures, you're ready to explore Iterators in depth - how to create custom iterators, use iterator adapters, and write efficient, functional code. Closures and iterators work together to enable powerful functional programming patterns in Rust.

Previous Iterators

Next Smart Pointers

What Are Closures?

Closure Syntax

Syntax Variations

Capturing the Environment

The Three Fn Traits

The move Keyword

Closures with Iterators

Common Iterator Methods

Returning Closures

Type Inference

Best Practices

Common Mistakes

1. Forgetting to dereference in closures

2. Using closure after move

3. Trying to return closure without impl Fn

Exercise: Closures Practice

Summary

What's Next?

Enjoying these tutorials?