Rust for C-Programmers

12.1 Introduction to Closures

A closure (sometimes called a lambda expression in other languages) is a small, inline function that can capture variables from the surrounding environment. By capturing these variables automatically, closures let you write more expressive code without needing to pass every variable as a separate argument.

Key Closure Characteristics

• Anonymous: Closures do not require a declared name, although you can store them in a variable.
• Environment Capture: Depending on usage, closures automatically capture variables by reference, mutable reference, or by taking ownership.
• Concise Syntax: Closures can omit parameter types and return types if the compiler can infer them.
• Closure Traits: Each closure implements at least one of Fn, FnMut, or FnOnce, which reflect how the closure captures and uses its environment.

12.1.1 Comparing Closure Syntax to Functions

Rust functions and closures look superficially similar but have important differences.

Function Syntax (Rust)

fn function_name(param1: Type1, param2: Type2) -> ReturnType {
    // Function body
}

• Parameter and return types must be explicitly declared.
• Functions cannot capture variables from their environment—every piece of data must be passed in.

Closure Syntax (Rust)

let closure_name = |param1, param2| {
    // Closure body
};

• Parameters go inside vertical pipes (||).
• Parameter and return types can often be inferred by the compiler.
• The closure automatically captures any needed variables from the environment.

Example: Closure Without Type Annotations

fn main() {
    let add_one = |x| x + 1;
    let result = add_one(5);
    println!("Result: {}", result); // 6
}

The type of x is inferred from usage (e.g., i32), and the return type is also inferred.

Example: Closure With Type Annotations

fn main() {
    let add_one_explicit = |x: i32| -> i32 {
        x + 1
    };
    let result = add_one_explicit(5);
    println!("Result: {}", result); // 6
}

Closures typically omit types to reduce boilerplate. Functions, by contrast, must specify all types explicitly because functions are used more flexibly throughout a program.

12.1.2 Capturing Variables from the Environment

One of the most powerful aspects of closures is that they can seamlessly use variables defined in the enclosing scope:

fn main() {
    let offset = 5;
    let add_offset = |x| x + offset;
    println!("Result: {}", add_offset(10)); // 15
}

Here, add_offset implicitly borrows offset from its environment—no explicit parameter for offset is necessary.

12.1.3 Assigning Closures to Variables

Closures are first-class citizens in Rust, so you can assign them to variables, store them in data structures, or pass them to (and return them from) functions:

fn main() {
    let multiply = |x, y| x * y;
    let result = multiply(3, 4);
    println!("Result: {}", result); // 12
}

Assigning Functions to Variables

fn add(x: i32, y: i32) -> i32 {
    x + y
}

fn main() {
    let add_function = add;
    println!("Result: {}", add_function(2, 3)); // 5
}

Named functions can also be assigned to variables, but they cannot capture environment variables—their parameters must be passed in explicitly.

12.1.4 Why Use Closures?

Closures excel at passing around bits of behavior. Common scenarios include:

• Iterator adapters (map, filter, etc.).
• Callbacks for event-driven programming, threading, or asynchronous operations.
• Custom sorting or grouping logic in standard library algorithms.
• Lazy evaluation (compute values on demand).
• Concurrency (especially with threads or async tasks).

12.1.5 Closures in Other Languages

In C, you would generally pass a function pointer along with a void* for context. C++ offers lambda expressions with flexible capture modes, which resemble Rust closures:

int offset = 5;
auto add_offset = [offset](int x) {
    return x + offset;
};
int result = add_offset(10); // 15

Rust closures provide a similar convenience but also integrate seamlessly with the ownership and borrowing rules of the language.