rust笔记13 闭包

闭包是一个可捕获周围环境的可执行代码片段，基本的几个定义方式如下：

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  ;

| |内部的是捕获的周围的变量，默认捕获的是不可变借用，先给出一个实际代码片段：

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

fn main() {
    let foo = |num| {  // 定义一个闭包，捕获一个变量
        thread::sleep(Duration::from_millis(num));
        println!("sleep for {} milliseconds", num);
    };

    let num = 200;
    foo(num);
}

注意：闭包一般不必显式声明变量的类型，但是闭包只能推断一种类型的数据，再次出现其它类型的数据时会报错。 给出代码说明：

fn main() {
    let foo = |x| x;

    foo(1.1);
    foo("foo".to_string());  // 这里会报错，第一次推断的时候，就已经明确这是f32的类型看了
}

如果我们想让闭包在第一次调用时就保存好结果，之后返回第一次计算的结果，可以使用缓存的机制，下面代码给出一般的缓存机制。但是，这个机制存在一个问题，如果第一次有了计算结果了，那么再次传入新的值，返回的也是第一次计算的结果。

struct Cache<T>
    where T: Fn(u32) -> u32  // 注意这里闭包声明的方式
{
    calculation: T,
    value: Option<u32>
}

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

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

fn main() {
    let mut res = Cache::new(|num| {
        num * num
    });

    let v1 = res.value(2);
    let v2 = res.value(10);  // 这仍然会返回之前的结果
    println!("v1 = {}, v2 = {}", v1, v2);  // v1 = 4, v2 = 4
}

如果想要根据不同的值计算结果，可以利用HashMap等的思路。

闭包三种捕获方式，附带3种声明方式：

• FnOnce 消费从周围作用域捕获的变量，闭包周围的作用域被称为其 环境，environment。为了消费捕获到的变量，闭包必须获取其所有权并在定义闭包时将其移动进闭包。其名称的 Once 部分代表了闭包不能多次获取相同变量的所有权的事实，所以它只能被调用一次。
• FnMut 获取可变的借用值所以可以改变其环境
• Fn 从其环境获取不可变的借用值