Please enable JavaScript.

Coggle requires JavaScript to display documents.

closure (anonymous function (save in a variable, pass as argument to other…

closure

lazy evaluation
memorization

struct Cacher<T>
    where T: Fn(u32) -> u32
{
    calculation: T,
    value: Option<u32>,
}

impl<T> Chcher<T>
    where T: Fn(u32) -> u32
{
    fn new(calculation: T) -> Cacher<T> {
        Cacher {
            calculation,
            value: None,
        }
    }

    fn value(&mut self, arg: u32) -> u32 {
        match self.value {
            Some(v) => v,
            None => {
                let v = (self.calculation)(arg);
                self.value = v;
                v
            },
        }
    }
}

capture environment

fn main() {
    let x = 4;
    let equal_to_x = |z| z==x;
    let y = 4;
    assert!(equal_to_x(y));
}

create

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

compare with function

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

move keyword

fn main() {
    let x = vec![1, 2, 3];
    let equal_to_x = move |z| z==x;
    let y = vec![1, 2, 3];
    assert!(equal_to_x(y));
}