Rust Programming Language Book Club – 13. Functional Language Features: Iterators and Closures

Closures in general

Example in R:

example_closure <- function(x) {
    y <- 10
    function() {
        x + y
    }
}

closure_instance <- example_closure(5)
closure_instance()  # Returns 15

Closures are functions that can capture variables from surrounding environment.
One of the key tools for functional programming.
These variables are stored alongside the closure for later use.
In R, every regular function is a closure, there is no special syntax.

Rust closures

In Rust, closures can capture their environment as well.
Ordinary functions are not closures, and do not capture anything.
Only anonymous functions can be closures.
Closure (and function pointers) can be used as first-class citizens:
- Stored in variables
- Passed as arguments
- Returned from other functions.

Closure syntax

fn   add_one_v1   (num : u32) -> u32 {num + 1}
let  add_one_v2 = |num : u32| -> u32 {num + 1};
let  add_one_v3 = |num|               num + 1 ;

println!("{}",add_one_v3(3)) // 4

Arguments inclosed in ||instead of ()
Type annotations are optional, rust will generally infer the types.
Curly brackets also optional for one liner.
Closure is called just like any other function

Inner function vs Closure

fn outer_function() {
    let outer_variable = 10;

    // Define an inner function
    fn inner_function() {
        // Attempt to access outer_variable
        //println!("{}", outer_variable); // Error: can't capture dynamic environment in a fn item
    }
    
        //  Captures `outer_variable` from the environment
    let inner_closure = || {
        println!("{}", outer_variable); 
    };

    inner_function();
    inner_closure();
}

fn main(){
    outer_function();
}

Rust Playground

Example use

#[derive(Debug, PartialEq, Copy, Clone)]
enum ShirtColor {
    Red,
    Blue,
}

struct Inventory {
    shirts: Vec<ShirtColor>,
}

impl Inventory {
    fn giveaway(&self, user_preference: Option<ShirtColor>) -> ShirtColor {
        user_preference.unwrap_or_else(|| self.most_stocked())
    }

    fn most_stocked(&self) -> ShirtColor {
        let mut num_red = 0;
        let mut num_blue = 0;

        for color in &self.shirts {
            match color {
                ShirtColor::Red => num_red += 1,
                ShirtColor::Blue => num_blue += 1,
            }
        }
        if num_red > num_blue {
            ShirtColor::Red
        } else {
            ShirtColor::Blue
        }
    }
}

Example continued

Illustrates use of closure in unwrap_or_else.
Calls the closure || self.most_stocked() if user_preference is None variant.
Closure captures self (immutable reference to Inventory)

Capturing Modes

Closure can capture values in the same three ways that functions can take parameters

Immutable Reference

let list = vec![1, 2, 3];
let print_closure = || println!("{:?}", list);
print_closure();

Mutable reference

let mut list = vec![1, 2, 3];
let mut add_to_list = || list.push(4);
add_to_list();
println!("{:?}", list); // [1, 2, 3, 4]

Capture modes (cont)

Moving ownership

let list = vec![1, 2, 3];
let moved = || drop(list);
moved();
// println!("{:?}", list); // Error: list has been moved

Can also explicitly move ownership:

let list = vec![1, 2, 3];
let moved = move || println!("{:?}", list);
moved();
// println!("{:?}", list); // Error: list has been moved

Rust will use the highest on the list possible: Immutable reference, then mutable if needed, and then move it if needed or requested.

Moving captured values out

Closure body can do any of the following:
1. Move a captured value out
2. Mutate a captured value
3. Neither move nor mutate captured values
4. Capture nothing
This determines which traits are implemented
- FnOnce : Can be called at least once. All closures implement this.
- FnMut : Can be called multiple times. Implemented by 2-4.
- Fn : Can be called multiple times safely. Implemented by 3-4.

FnOnce example

impl<T> Option<T> {
    pub fn unwrap_or_else<F>(self, f: F) -> T
    where
        F: FnOnce() -> T
    {
        match self {
            Some(x) => x,
            None => f(),
        }
    }
}

F is the generic type, with trait bound FnOnce() -> T
This means F can be any closure, since we only call it once.

FnMut example

impl<T> [T] {
pub fn sort_by_key<K, F>(&mut self, f: F)
where
    F: FnMut(&T) -> K,
    K: Ord,
// snip

Standard library function on slices that takes a function that produces the sort key K.
Ord is a trait for ordering, requires cmp function, implemented by orderable types (e.g. all numbers)
Takes a FnMut instead of FnOnce because it must be called multiple times to do the sort.

`sort_by_key` usage example

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let mut list = [
        Rectangle { width: 10, height: 1 },
        Rectangle { width: 3, height: 5 },
        Rectangle { width: 7, height: 12 },
    ];

    list.sort_by_key(|r| r.width);
    println!("{list:#?}");
}

Closure implements all the traits, including FnMut so OK.

Broken example

// snip
fn main() {
    let mut list = [
     // snip
    ];

    let mut sort_operations = vec![];
    let value = String::from("closure called");

    list.sort_by_key(|r| {
        sort_operations.push(value); // Moves capture value out
        r.width
    });
    println!("{list:#?}");
}

Closure moves the captured value value out.
Implements only FnOnce, not FnMut.
Compiler error. Rust Playground

Fixed example


fn main() {
    let mut list = [
      // snip
    ];

    let mut num_sort_operations = 0;
    list.sort_by_key(|r| {
        num_sort_operations += 1;
        r.width
    });
    println!("{list:#?}, sorted in {num_sort_operations} operations");
}

Counts number of calls without moving
This time the closure implements FnMut (in addition to FnOnce)