Closures in Rust

Closures are a powerful feature in Rust that allow the creation of anonymous functions that can be used just like any other function. They are same as lamda functions in other languages such as C++, Kotlin,etc . Closures can capture variables from their enclosing environment and can be passed as arguments to other functions.

Closures in Rust, like in other programming languages, solve the problem of capturing variables in a way that allows them to be used inside a function that takes a closure as an argument. Before the introduction of closures, the only way to achieve this was by using function pointers, which can be cumbersome and verbose.

The motivation for introducing closures in Rust was to provide a more concise and expressive way of writing higher-order functions that take functions as arguments or return them as results. Closures provide a way to create functions on the fly, with their own scope and state, and pass them as arguments to other functions. This allows for more flexible and powerful abstractions and can simplify the code.

In addition, closures in Rust provide some features that are not available in other programming languages, such as the ability to specify the lifetime of captured variables and to use move semantics to transfer ownership of captured variables into the closure.

In Rust, closures are defined using the | | syntax, similar to how lambda functions are defined in other languages. For example, a closure that takes two integers and returns their sum can be defined as follows:

let add_numbers = |a, b| a + b;         

This closure can be used just like any other function:

let result = add_numbers(2, 3); 
println!("The sum is {}", result); // Output: The sum is 5         

Closures can also capture variables from their enclosing environment. This is done by using the move keyword before the closure definition. For example:

let x = 42; 
let print_x = move || println!("x is {}", x);         

Here, the closure captures the variable x from its enclosing environment. The move keyword indicates that the closure takes ownership of the captured variable. x will be dropped when x closure is finished.

If the move keyword is not used, the closure will borrow the variable instead.

Barrow example :

fn main() {
? ? let mut x = 42;?
? ? let print_x = || println!("x is {}", x);?
? ? print_x();
}         

Closures can also be used with iterators to perform operations on collections of data. For example, the following code uses a closure to filter out even numbers from a vector of integers:

let numbers = vec![1, 2, 3, 4, 5]; 
let even_numbers = numbers.into_iter().filter(|n| n % 2 == 0).collect::<Vec<_>>(); 
println!("Even numbers: {:?}", even_numbers); 
// Output: Even numbers: [2, 4]         

In this example, the filter method takes a closure that tests each element of the iterator and returns only those that match the condition.

Closures in Rust have a few advantages over traditional functions. Firstly, closures can capture variables from their enclosing environment, which allows them to operate on data that is not explicitly passed as arguments. This can make code more concise and easier to read.

Secondly, closures can be defined inline, which can be useful in situations where a function is only needed in one place. This can reduce the amount of boilerplate code needed to define a function and make the code easier to understand.

However, closures also have some disadvantages. Firstly, closures can be more difficult to reason about than traditional functions because they can capture variables from their enclosing environment. This can make it harder to predict how a closure will behave.

Secondly, closures can be less efficient than traditional functions because they may require heap allocation. This is because closures capture variables by value, which means they need to be stored on the heap if they outlive their enclosing scope.

Closure traits:

The traits Fn, FnMut, and FnOnce in Rust are used to represent different levels of "closures" or function-like objects. Each trait corresponds to a different level of mutability and ownership of captured variables.

Here's a high-level overview of how the Rust compiler implements these traits:

1. Fn: The Fn trait represents closures that can be called immutably. These closures can't modify the captured variables. When a closure implements Fn, it means it can be invoked using the () syntax, like a regular function call. The closure takes ownership of captured variables if necessary.
2. FnMut: The FnMut trait represents closures that can be called with mutable access to the captured variables. These closures can modify the captured variables. When a closure implements FnMut, it means it can be invoked using the () syntax, similar to Fn. The closure takes ownership of captured variables if necessary.
3. FnOnce: The FnOnce trait represents closures that consume the captured variables. These closures can only be called once because they take ownership of the captured variables and invalidate the closure afterward. When a closure implements FnOnce, it means it can be invoked using the () syntax, just like Fn and FnMut.

Under the hood, the Rust compiler performs a process called "closure coercion" to convert closures into function pointers or objects that implement the corresponding trait. This process allows the closure to be treated as a regular function with a specific signature.

When you use a closure in Rust, the compiler infers which trait(s) the closure should implement based on how the closure is used. For example, if you try to mutate captured variables inside a closure, the closure will automatically implement FnMut or FnOnce, depending on whether it needs to take ownership of the variables.

Fn

• Fn closures capture the environment by immutable reference. They can access but not modify the captured variables.
• Closures which do not capture any variables at all.
• Fn Closure can be called any number of time
• Fn can be called on multiple times on the different threads.

fn main() {
? ? let x = 5;
? ? let printer = || {
? ? ? ? println!("x is {}", x);
? ? };
? ? printer();
}        

In the above example, we define a closure printer that captures the variable x from its environment by immutable reference. The closure can't modify x, but it can use its value to print a message.

FnMut

FnMut closures capture the environment by mutable reference. They can modify the captured variables.

fn main() {
? ? let mut x = 5;
? ? let mut adder = || {
? ? ? ? x += 1;
? ? ? ? println!("x is now {}", x);
? ? };
? ? adder();
? ? adder();
}
/*
Op => 
x is now 6
x is now 7
*/        

In the above example, we define a closure adder that captures the variable x from its environment by mutable reference. The closure can modify x by incrementing its value and printing a message.

FnOnce

• FnOnce closures capture the environment by taking ownership of the captured variables. They can only be called once since they consume the environment.

fn main() {
? ? let x = String::from("hello");
? ? let printer = move || {
? ? ? ? println!("{}", x);
? ? };
? ? printer();
}        

In this example, we define a closure printer that captures the variable x from its environment by consuming it. The closure takes ownership of the String and prints its value. Because the closure consumes x, it can only be called once.

The categorization is done automatically by the Rust compiler based on the capture clauses used in the closure definition. If a closure captures variables by immutable reference, it will be of type Fn. If it captures variables by mutable reference, it will be of type FnMut. And if it captures variables by value (i.e., takes ownership), it will be of type FnOnce.

For example, the following closure captures its environment by immutable reference and is therefore of type Fn:

let x = 5; 
let add_five = |y| x + y;         

The following closure captures its environment by mutable reference and is therefore of type FnMut:

let mut x = 5; 
let add_to_x = |y| { x += y; x };         

And the following closure captures its environment by taking ownership and is therefore of type FnOnce:

let x = String::from("Hello"); 
let consume_string = move || { println!("{}", x); }; 
        

Passing the closure to function:

In Rust, closures are functions that can capture values from their surrounding environment. They are defined with the |arg1, arg2, ...| { /* function body */ } syntax. Closures can be used as arguments to functions just like any other value.

Here is an example of passing a closure to a function:

fn apply<F>(f: F)
where
? ? F: Fn(i32) -> i32,
{
? ? let x = 1;
? ? let result = f(x);
? ? println!("Result: {}", result);
}


fn main() {
? ? let closure = |y| y + 1;
? ? apply(closure);
}        

In this example, we define a function apply that takes a closure F as an argument. The closure must take an i32 argument and return an i32. Inside the apply function, we define a local variable x and call the closure with this variable. Finally, we print the result of the closure.

In the main function, we define a closure that adds 1 to its argument, and then pass it as an argument to the apply function.

When we run this program, it will output Result: 2, which is the result of calling the closure with the argument 1.

Note that closures can also capture variables from their environment. For example, if we modify the closure in the above example to capture a variable from its environment, like this:

fn main() {
? ? let x = 1;
? ? let closure = |y| x + y;
? ? apply(closure);
}        

The apply function will still work correctly, even though the closure is capturing the x variable from its surrounding environment.

Closures in Rust can also be classified based on various criteria. Here are some of the common classifications:

1. Function-like closures: These are closures that have a defined input and output, just like regular functions. They can be called using the same syntax as functions. Example:

let add = |x, y| x + y; 
let result = add(2, 3);         

2. Method closures: These are closures that are associated with a particular type, just like methods. They are defined using the impl keyword and can access the self parameter.

Example:

The code below defines a struct Counter with a field count of type u32. The struct also has an implementation block for the Counter struct where a method increment is defined, which takes a mutable reference to self and increments the count field by 1.

In the main function, a mutable variable counter is defined as an instance of the Counter struct with an initial count value of 0. A closure closure is also defined, which captures the counter variable by reference and calls the increment method on it.

struct Counter {
? ? count: u32,
}

impl Counter {
? ? fn increment(&mut self) {
? ? ? ? self.count += 1;
? ? }
}


fn main() {
? ? let mut counter = Counter { count: 0 };
? ? let mut closure = || counter.increment();
? ? closure();
? ? closure();
? ? closure();
? ? println!("{}",counter.count);
? ? //assert_eq!(counter.count, 1);
}
/*
Op -> 3
*/        

3. Move closures: These closures take ownership of the variables they capture. This means that the captured variables can't be used after the closure is called, unless they are moved back out of the closure. Example:

let message = "Hello, world!";
let closure = move || println!("{}", message);
closure();        

4. Iterator closures: These are closures that are used with iterators to perform operations on each element of the iterator. They are defined using the Iterator trait. Example:

let numbers = vec![1, 2, 3];
let closure = |x| x * 2;
let doubled: Vec<_> = numbers.into_iter().map(closure).collect();        

5. Capture by reference closures: These closures borrow the captured variables by reference. They can't modify the captured variables. Example:

let message = "Hello, world!";
let closure = |x: &str| println!("{}", x);
closure(message);        

6. Capture by mutable reference closures: These closures borrow the captured variables by mutable reference. They can modify the captured variables. Example:

let mut message = String::from("Hello, world!");
let closure = |x: &mut String| x.push_str(", Rust!");
closure(&mut message);
println!("{}", message); // prints "Hello, world!, Rust!"        

7. Capture by value closures: These closures take ownership of the captured variables. They can modify the captured variables if the variables implement the Copy trait. Example:

let x = 5;
let closure = |y: i32| x + y;
let result = closure(3);        

Advantages of closures in Rust:

1. Closures allow for a concise and expressive syntax for defining functions and algorithms, making code easier to read and write.
2. Closures can capture and manipulate variables from their enclosing scope, making them a powerful tool for implementing algorithms that require shared state.
3. Closures are efficient, as they can be optimized by the Rust compiler to reduce memory usage and eliminate unnecessary function calls.

Disadvantages of closures in Rust:

1. Closures can be difficult to understand and reason about, especially when they capture variables from their enclosing scope.
2. Closures can introduce additional complexity to a program, which can make it harder to debug and maintain.
3. Closures can sometimes be less performant than equivalent functions defined in a more traditional way, especially if they are used in performance-critical code.

In conclusion, closures are a powerful feature in Rust that can be used to write concise and expressive code. While they have some disadvantages, such as being more difficult to reason about and potentially less efficient, the benefits of using closures often outweigh these drawbacks.

Thanks for reading till end.

Please note that I am not expert in Rust, I am also learning the rust and writing these articles based on my studies, learning and experiments. If you find something need to be corrected, please feel free to comment.

Let's learn together!!

Below is good read:

A guide to closures in Rust (hashrust.com)