Rust for C-Programmers

12.1 Introduction to Closures

12.1.1 What Are Closures?

A closure in Rust is an anonymous function that can capture variables from its enclosing scope. Closures are sometimes referred to as lambda expressions or lambda functions in other programming languages. They allow you to write concise code by capturing variables from the environment without explicitly passing them as parameters.

Key Characteristics of Closures:

• Anonymous Functions: Closures do not have a name. While you can assign them to variables, the closure itself remains unnamed.
• Capture Environment: They can access variables from the scope in which they're defined.
• Type Inference: Rust can often infer the types of closure parameters and return values.
• Flexible Syntax: Closures have a concise syntax that can omit parameter and return types, and even braces {} for single-expression bodies.
• Traits: Closures implement one or more of the Fn, FnMut, or FnOnce traits.

12.1.2 Syntax of Closures vs. Functions

Closures and functions in Rust share similarities but also have distinct differences in syntax and capabilities.

Function Syntax:

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

• Functions require explicit type annotations for parameters and return types.
• Functions cannot capture variables from their environment.

Closure Syntax:

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

• Closures use vertical pipes || to enclose the parameter list.
• Type annotations for parameters and return types are optional if they can be inferred.
• For single-expression closures, you can omit the braces {}.

Examples:

1. Closure Without Type Annotations:

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

   • The closure add_one takes one parameter x.
   • Rust infers the type of x and the return type based on usage.
   • Although add_one is assigned to a variable, the closure itself remains anonymous.

2. Closure With Type Annotations:

   #![allow(unused)]
   fn main() {
   let add_one = |x: i32| -> i32 { x + 1 };
   }

   • Explicitly specifies the parameter type i32 and return type i32.
   • Useful when type inference is insufficient or for clarity.

Why Can Closures Omit Type Annotations?

• Closures are often used in contexts where the types can be inferred from the surrounding code, such as iterator methods.
• Functions, on the other hand, are standalone and require explicit type annotations to ensure type safety.

Using || for Parameter List:

• The vertical pipes || enclose the closure's parameter list.

• If the closure takes no parameters, you still use ||.

  #![allow(unused)]
  fn main() {
  let say_hello = || println!("Hello!");
  say_hello();
  }

12.1.3 Capturing Variables from the Environment

Closures can capture variables from their enclosing scope, allowing them to use values without explicitly passing them as parameters.

Example:

#![allow(unused)]
fn main() {
let offset = 5;
let add_offset = |x| x + offset;
let result = add_offset(10);
println!("Result: {}", result); // Output: Result: 15
}

• The closure add_offset captures offset from the environment.
• This feature makes closures highly flexible and powerful.

Why Do Closures Have Parameter Lists?

• While closures can capture variables from the environment, they often need to accept additional input when called.
• The parameter list specifies what arguments the closure expects when invoked.

12.1.4 Assigning Closures to Variables

Closures can be assigned to variables, allowing you to store and reuse them.

Example:

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

• The closure multiply is assigned to a variable.
• You can call the closure using the variable name followed by ().

Can You Assign Functions to Variables?

• In Rust, you can assign function pointers to variables using the function's name without parentheses.

  #![allow(unused)]
  fn main() {
  fn add(x: i32, y: i32) -> i32 {
      x + y
  }
  let add_function = add; // Assigning function to variable
  let result = add_function(2, 3);
  println!("Result: {}", result); // Output: Result: 5
  }

• However, functions cannot capture variables from the environment.

• Functions and closures are different types in Rust.

12.1.5 Why Use Closures?

Closures are particularly useful in scenarios where you need to pass behavior as an argument to other functions or methods. Common use cases include:

• Iterator Adaptors: Methods like map, filter, and for_each accept closures to process elements.
• Callbacks: Registering a closure to be called later, such as in event handling.
• Custom Comparisons: Using closures to define custom sorting behavior.
• Lazy Evaluation: Deferring computation until necessary.
• Concurrency: Passing closures to threads for execution.

12.1.6 Closures in Other Languages

In C, functions cannot capture variables from their environment unless you use function pointers with additional context, which can be cumbersome. In C++, lambdas provide similar functionality to Rust's closures, including the ability to capture variables by value or reference.

C++ Lambda Example:

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