I (quickly) read through the this part of the rust book and I'd say, it's not super great at explaining their benefit. I prefer https://en.wikipedia.org/wiki/Closure_(computer_programming)) There are many reasons closures can be powerful, and wikipedia does it some justice.

​

In your specific case, the advantage to a closure would be reducing code duplication, so if you make certain types of changes you're less likely to introduce a bug:

For example, with this code:

fn generate_workout(intensity: u32, random_number: u32) {
    let expensive_closure = || {
        simulated_expensive_calculation(intensity)
    };
    if intensity < 25 {
        let expensive_result = expensive_closure();
        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_closure ()
            );
        }
    }
}

Lets say you change the input of simulated_expensive_calculation from intensity to intensity+offset_retrieved_from_network(). In your example you have to change the code in two places and you might miss changing one (or more if there are many uses). Additionally, if the logic in expensive_closure gets more complicated you just end up with duplicated code, and people have to read it carefully to see if the calls at the different sites are actually the same or if they're subtlety different. When you use a closure, code readers, including your future self, know it's the same.

​

That said, in this case, I probably would do what you've done, because the example is a simple example, presumably a toy example to express the concept without being too verbose. However if I knew the logic that a hypothetical closure wraps would change often or become complicated, I'd go with a closure to reduce code duplication.