[Rust Guide] 13.1. What Is a Closure and How to Use Closures

13.1.0 Before We Begin

During its design, Rust drew inspiration from many languages, and functional programming had a particularly strong influence on Rust. Functional programming often includes passing functions as values to parameters, returning them from other functions, assigning them to variables for later execution, and so on.

In this chapter, we will discuss some Rust features that are similar to what many languages call functional features:

• Closures (this article)
• Iterators
• Improving the I/O Project with Closures and Iterators
• Performance of Closures and Iterators

If you find this helpful, please like, bookmark, and follow. To keep learning along, follow this series.

13.1.1 What Is a Closure

In one sentence: a closure is an anonymous function that can capture values from its surrounding environment.

A closure has four characteristics:

• A closure is an anonymous function
• This anonymous function can be stored in a variable, passed as an argument to another function, or returned from another function
• You can create a closure in one place and call it in another place to do the work
• A closure can capture values from the scope in which it is defined

13.1.2 An Example of a Closure

To better demonstrate what closures can do, here is an example:

Build a program that generates a personalized workout plan based on factors such as a person's body metrics. The algorithm itself is not the point; the important part is that it takes a few seconds to run. Our goal is to avoid unnecessary waiting for the user. More specifically, we want to call the algorithm only when necessary, and only once.

Take a look at the code:

use std::thread;  
use std::time::Duration;  

fn main() {  
    let simulated_user_specified_value = 10;  
    let simulated_random_number = 7;  

    generate_workout(  
        simulated_user_specified_value,  
        simulated_random_number,  
    );  
}  

fn simulated_expensive_calculation(intensity: u32) -> u32 {  
    println!("calculating slowly...");  
    thread::sleep(Duration::from_secs(2));  
    intensity  
}  

fn generate_workout(intensity: u32, random_number: u32) {  
    if intensity < 25 {  
        println!("Today, do {} pushups!", simulated_expensive_calculation(intensity));  
        println!("Next, do {} situps!", simulated_expensive_calculation(intensity));  
    } else {  
        if random_number == 3 {  
            println!("Take a break today! Remember to stay hydrated!");  
        } else {  
            println!("Today, run for {} minutes!", simulated_expensive_calculation(intensity));  
        }  
    }  
}

• The simulated_expensive_calculation function simulates that expensive algorithm, and thread::sleep simulates the time required for the algorithm to finish. Since this is only a demo, the function simply returns the intensity parameter, which represents the user's requested intensity.

• generate_workout has two parameters: intensity, which represents the user's requested workout intensity, and random_number, which represents a random number. The logic is: if intensity is less than 25, print Today, do {} pushups! and Next, do {} situps!. The problem is that both lines call the relatively expensive simulated_expensive_calculation. If intensity is greater than or equal to 25 and the random number is 3, print Take a break today! Remember to stay hydrated! and do not call the expensive function. If the random number is not 3, print Today, run for {} minutes!, which does call simulated_expensive_calculation.

This function is correct as written, but it is too slow. Our goal is to avoid unnecessary waiting for the user. More specifically, we want to call the algorithm only when necessary, and only once.

First, look at the case in generate_workout where intensity is less than 25:

if intensity < 25 {  
        println!("Today, do {} pushups!", simulated_expensive_calculation(intensity));  
        println!("Next, do {} situps!", simulated_expensive_calculation(intensity));

This prints Today, do {} pushups! and Next, do {} situps!. The problem is that both lines call the slow simulated_expensive_calculation. In fact, we only need to calculate the result once and reuse it in both outputs.

Let’s optimize this part. We only need to run the calculation once, store the result in a variable, and use that variable in the output, which avoids calling simulated_expensive_calculation twice:

fn generate_workout(intensity: u32, random_number: u32) {  
    let expensive_result = simulated_expensive_calculation(intensity);  
    if intensity < 25 {  
        println!("Today, do {} pushups!", expensive_result);  
        println!("Next, do {} situps!", expensive_result);  
    } else {  
        if random_number == 3 {  
            println!("Take a break today! Remember to stay hydrated!");  
        } else {  
            println!("Today, run for {} minutes!", expensive_result);  
        }  
    }  
}

Here I also replaced the intensity > 25 and random_number != 3 case with the variable expensive_result that stores the calculation result.

But this creates another problem:

if random_number == 3 {  
    println!("Take a break today! Remember to stay hydrated!");  
}

Here we do not need to call the expensive function, but because

let expensive_result = simulated_expensive_calculation(intensity);

is executed at the start of the function, the calculation still runs even when the random number is 3. That is an unnecessary call.

This is where closures come in. Let’s rewrite this code with a closure:

fn generate_workout(intensity: u32, random_number: u32) {  
    let expensive_closure = |num| {  
        println!("calculating slowly...");  
        thread::sleep(Duration::from_secs(2));  
        num  
    };  
    if intensity < 25 {  
        println!("Today, do {} pushups!", expensive_closure(intensity));  
        println!("Next, do {} situps!", expensive_closure(intensity));  
    } else {  
        if random_number == 3 {  
            println!("Take a break today! Remember to stay hydrated!");  
        } else {  
            println!("Today, run for {} minutes!", expensive_closure(intensity));  
        }  
    }  
}

The closure is this part:

let expensive_closure = |num| {  
    println!("calculating slowly...");  
    thread::sleep(Duration::from_secs(2));  
    num  
};

• The closure is assigned to the variable expensive_closure.

• The closure needs parameters, and parameters are placed between the two pipe symbols ||. Here there is only one parameter, num, so we write |num|. If there are two parameters, separate them with a comma, such as |num1, num2|. If no parameters are needed, just write ||.

• The parameter num does not need an explicit type annotation because the argument passed in the later call is intensity, whose type is u32, so Rust infers that num is also u32.

• The closure body is written inside {}, just like any other function. Here we want this closure to do the same work as the expensive calculation function, so the body can be the same. At that point, the simulated_expensive_calculation function can be removed.

• This closure definition only defines a function; it does not execute it. A function only runs when it sees (), such as expensive_closure(intensity).

With this version, when intensity is greater than 25 and random_number is not 3, the expensive calculation will not be called, so there is no unnecessary work. However, this still does not solve the problem of repeated closure calls. We will address that in the next article.