闭包和迭代器

   考虑一下这个假想的情况：在一个通过 app 生成自定义健身计划的初创企业工作，其后端使用 Rust 编写
   
   生成健身计划的算法需要考虑很多不同的因素，比如用户的年龄、身体质量指数、用户喜好、最近的健身活动和用户指定的强度系数
   
   本例中实际的算法并不重要，重要的是这个计算只花费几秒钟。但希望在需要时调用算法，并且只希望调用一次，这样就不会让用户等得太久

这里将通过调用 simulated_expensive_calculation 函数来模拟调用假象的算法，它会打印出 calculating slowly…，等待两秒，并接着返回传递给它的数字：

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

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

接下来，main 函数中将会包含本例的健身 app 中的重要部分。这代表当用户请求健身计划时 app 会调用的代码。因为与 app 前端的交互与闭包的使用并不相关，所以将硬编码代表程序输入的值并打印输出。所需的输入有这些：

• 一个来自用户的 intensity 数字，请求健身计划时指定，它代表用户喜好低强度还是高强度健身
• 一个随机数，其会在健身计划中生成变化

程序的输出将会是建议的锻炼计划。下面展示了将要使用的 main 函数：

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

    generate_workout(
        simulated_user_specified_value,
        simulated_random_number
    );
}

  出于简单考虑这里硬编码了 simulated_user_specified_value 变量的值为 10 和 simulated_random_number 变量的值为 7

  一个实际的程序会从 app 前端获取强度系数并使用 rand crate 来生成随机数，main 函数使用模拟的输入值调用 generate_workout 函数

现在有了执行上下文，开始编写算法。下面的 generate_workout 函数包含最关心的 app 业务逻辑。本例中余下的代码修改都将在这个函数中进行：

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)
            );
        }
    }
}

generate_workout 函数的期望行为是首先检查用户需要低强度（由小于 25 的系数表示）锻炼还是高强度（25 或以上）锻炼：

• 低强度锻炼计划会根据由 simulated_expensive_calculation 函数所模拟的复杂算法建议一定数量的俯卧撑和仰卧起坐
• 如果用户需要高强度锻炼，这里有一些额外的逻辑：
  • 如果 app 生成的随机数刚好是 3，app 相反会建议用户稍做休息并补充水分
  • 如果不是，则用户会从复杂算法中得到数分钟跑步的高强度锻炼计划

这里有多处调用了慢计算函数 simulated_expensive_calculation ：

• 第一个 if 块调用了 simulated_expensive_calculation 两次，else 中的 if 没有调用它
• 而第二个 else 中的代码调用了它一次

  现在这份代码能够应对需求了，但数据科学部门的同学告知将来会对调用 simulated_expensive_calculation 的方式做出一些改变

  为了在要做这些改动的时候简化更新步骤，将重构代码来让它只调用 simulated_expensive_calculation 一次

  同时还希望去掉目前多余的连续两次函数调用，并不希望在计算过程中增加任何其他此函数的调用

  也就是说，不希望在完全无需其结果的情况调用函数，不过仍然希望只调用函数一次

闭包不要求像 fn 函数那样在 参数 和 返回值 上 注明 类型

   函数中需要类型注解是因为他们是暴露给用户的显式接口的一部分，严格的定义这些接口对于保证所有人都认同函数使用和返回值的类型来说是很重要的
   
   但是闭包并不用于这样暴露在外的接口：他们储存在变量中并被使用，不用命名他们或暴露给库的用户调用
   
   闭包通常很短并只与对应相对任意的场景较小的上下文中。在这些有限制的上下文中，编译器能可靠的推断参数和返回值的类型，类似于它是如何能够推断大部分变量的类型一样
   
   强制在这些小的匿名函数中注明类型是很恼人的，并且与编译器已知的信息存在大量的重复

类似于变量，如果相比严格的必要性更希望增加明确性并变得更啰嗦，可以选择增加类型注解：

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

有了类型注解闭包的语法就更类似函数了。如下是一个对其参数加一的函数的定义与拥有相同行为闭包语法的纵向对比：

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  ;

这展示了闭包语法如何类似于函数语法，除了使用竖线而不是括号以及几个可选的语法之外

1. 第一行展示了一个函数定义
2. 第二行展示了一个完整标注的闭包定义
3. 第三行闭包定义中省略了类型注解
4. 第四行去掉了可选的大括号，因为闭包体只有一行

这些都是有效的闭包定义，并在调用时产生相同的行为

这里增加了一些空格来对齐相应部分

闭包定义会为每个参数和返回值推断一个具体类型。例如，下面展示了仅仅将参数作为返回值的简短的闭包定义

let example_closure = |x| x;

let s = example_closure(String::from("hello"));
let n = example_closure(5);

如果尝试调用闭包两次，第一次使用 String 类型作为参数而第二次使用 u32，则会得到一个错误：

error[E0308]: mismatched types
 --> src/main.rs
  |
  | let n = example_closure(5);
  |                         ^ expected struct `std::string::String`, found
  integer
  |
  = note: expected type `std::string::String`
             found type `{integer}`

   第一次使用 String 值调用 example_closure 时，编译器推断 x 和此闭包返回值的类型为 String
   
   接着这些类型被锁定进闭包 example_closure 中，如果尝试对同一闭包使用不同类型则会得到类型错误

   回到前面的健身计划生成 app ，使用了闭包后的代码仍然调用了多于需要的慢计算闭包
   
   解决这个问题的一个方法是在全部代码中的每一个需要多个慢计算闭包结果的地方，可以将结果保存进变量以供复用，这样就可以使用变量而不是再次调用闭包
   
   但是这样就会有很多重复的保存结果变量的地方

还有另一个可用的方案。可以创建一个 存放 闭包 和 调用 闭包 结果 的 结构体

   该结构体只会在需要结果时执行闭包，并会缓存结果值，这样余下的代码就不必再负责保存结果并可以复用该值
   
   这种模式被称 memoization 或 lazy evaluation

为了让结构体存放闭包，需要 指定 闭包的 类型 ，因为 结构体定义 需要知道其 每一个字段的类型

   每一个闭包实例有其自己独有的匿名类型：也就是说，即便两个闭包有着相同的签名，他们的类型仍然可以被认为是不同

为了定义使用闭包的结构体、枚举或函数参数，需要使用 泛型 和 trait bound

• Fn 系列 trait 由标准库提供

  所有的闭包都实现了 Fn、FnMut 或 FnOnce Trait中的一个，在 “闭包会捕获其环境” 部分会讨论这些 trait 的区别

  在这个例子中可以使用 Fn trait

• 为了满足 Fn trait bound 增加了代表闭包所必须的 参数 和 返回值类型 的 类型

  在这个例子中，闭包有一个 u32 的参数并返回一个 u32

  这样所指定的 trait bound 就是 Fn(u32) -> u32

下面展示了存放了 闭包 和一个 Option 结果值 的 Cacher 结构体 的定义：

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

结构体 Cacher：

• 一个 泛型 T 的字段 calculation
  • T 的 trait bound 指定了 T 是一个使用 Fn 的闭包
    • 任何希望储存到 Cacher 实例的 calculation 字段的闭包必须有一个 u32 参数（由 Fn 之后的括号的内容指定）
    • 必须返回一个 u32（由 -> 之后的内容）

  注意：函数也都实现了这三个 Fn trait

  如果不需要捕获环境中的值，则可以使用实现了 Fn trait 的函数而不是闭包

• 字段 value 是 Option<u32> 类型的：
  • 在执行闭包之前，value 将是 None
  • 如果使用 Cacher 的代码请求闭包的结果，这时会执行闭包并将结果 储存 在 value 字段的 Some 成员 中
    • 如果代码再次请求闭包的结果，这时不再执行闭包，而是会 返回 存放在 Some 成员 中的 结果

实现Cacher的逻辑如下：

impl<T> Cacher<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 = Some(v);
                v
            },
        }
    }
}

1. Cacher 结构体的 字段 是 私有 的，因为希望 Cacher 管理这些值而不是任由调用代码潜在的直接改变他们
2. Cacher::new 函数：
   • 获取一个 泛型参数 T ，它定义于 impl 块上下文 中并与 Cacher 结构体有着相同的 trait bound
   • 返回一个在Cacher实例，此时闭包还没有被执行
     • calculation 字段 中 存放 了 指定闭包
     • value 字段 中 存放了 None 值
3. 当调用代码需要闭包的执行结果时，不同于直接调用闭包，它会调用 value 方法： 检查 self.value 是否 已经有 了一个 Some 的结果值；
   • 如果有：返回 Some 中的值并不会再次执行闭包
   • 如果 self.value 是 None：会调用 self.calculation 中储存的闭包，将结果保存到 self.value 以便将来使用，并同时返回结果值

下面代码展示了如何在 generate_workout 函数中利用 Cacher 结构体：

fn generate_workout(intensity: u32, random_number: u32) {
    let mut expensive_result = Cacher::new(|num| {
        println!("calculating slowly...");
        thread::sleep(Duration::from_secs(2));
        num
    });

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

1. 不同于直接将闭包保存进一个变量，保存一个新的 Cacher 实例来存放闭包
2. 在每一个需要结果的地方，调用 Cacher 实例的 value 方法
3. 可以调用 value 方法任意多次，或者一次也不调用，而慢计算最多只会运行一次。

改变 simulated_user_specified_value 和 simulated_random_number 变量中的值来验证在所有情况下在多个 if 和 else 块中，闭包打印的 calculating slowly... 只会在需要时出现并只会出现一次

Cacher 负责确保不会调用超过所需的慢计算所需的逻辑，这样 generate_workout 就可以专注业务逻辑了

   在健身计划生成器的例子中，我们只将闭包作为内联匿名函数来使用

闭包还有另一个函数所没有的功能：他们可以 捕获 其 环境 并访问其被 定义的作用域 的 变量 。比如：有一个储存在 equal_to_x 变量中闭包的例子，它使用了闭包环境中的变量 x：

fn main() {
    let x = 4;

    let equal_to_x = |z| z == x;

    let y = 4;

    assert!(equal_to_x(y));
}

   这里，即便 x 并不是 equal_to_x 的一个参数，equal_to_x 闭包也被允许使用变量 x，因为它与 equal_to_x 定义于相同的作用域

函数则不能做到同样的事，如果尝试如下例子，它并不能编译：

fn main() {
    let x = 4;

    fn equal_to_x(z: i32) -> bool { z == x }

    let y = 4;

    assert!(equal_to_x(y));
}

这会得到一个编译错误：

error[E0434]: can't capture dynamic environment in a fn item; use the || { ...
} closure form instead
 --> src/main.rs
  |
4 |     fn equal_to_x(z: i32) -> bool { z == x }

当闭包从环境中捕获一个值，闭包会在闭包体中储存这个值以供使用。这会使用内存并产生额外的开销

迭代器都实现了一个叫做 Iterator 的定义于 标准库 的 trait。这个 trait 的定义看起来像这样：

pub trait Iterator {
    type Item;

    fn next(&mut self) -> Option<Self::Item>;

    // 此处省略了方法的默认实现
}

   注意这里有一下还未讲到的新语法：type Item 和 Self::Item，他们定义了 trait 的 关联类型
   
   现在只需知道这段代码表明实现 Iterator trait 要求同时定义一个 Item 类型，这个 Item 类型被用作 next 方法的返回值类型
   
   换句话说，Item 类型将是迭代器返回元素的类型

next 是 Iterator 实现者被要求定义的唯一方法：

• next 一次 返回迭代器中的一个项，封装在 Some 中
• 当迭代器 结束 时，它返回 None

可以直接调用迭代器的 next 方法；

#[test]
fn iterator_demonstration() {
    let v1 = vec![1, 2, 3];

    let mut v1_iter = v1.iter();

    assert_eq!(v1_iter.next(), Some(&1));
    assert_eq!(v1_iter.next(), Some(&2));
    assert_eq!(v1_iter.next(), Some(&3));
    assert_eq!(v1_iter.next(), None);
}

注意：v1_iter 必须是 可变 的：在迭代器上调用 next 方法 改变 了迭代器中用来记录 序列位置 的状态。换句话说，每一个 next 调用都会从迭代器中消费一个项

  使用 for 循环时无需使 v1_iter 可变因为 for 循环会获取 v1_iter 的所有权并在后台使 v1_iter 可变

另外从 next 调用中得到的值 是 vector 的 不可变引用

iter 方法生成一个不可变引用的迭代器

如果需要一个获取 v1 所有权并返回拥有所有权的迭代器，则可以调用 into_iter 而不是 iter

类似的，如果希望迭代可变引用，则可以调用 iter_mut 而不是 iter

Iterator trait 有一系列不同的由标准库提供默认实现的方法，可以在 Iterator trait 的标准库 API 文档中找到所有这些方法

一些方法在其定义中调用了 next 方法，这也就是为什么在实现 Iterator trait 时要求实现 next 方法的原因

这些调用 next 方法的方法被称为 消费适配器 ，因为调用他们会消耗迭代器。一个消费适配器的例子是 sum 方法。这个方法获取迭代器的所有权并反复调用 next 来遍历迭代器，因而会消费迭代器。当其遍历每一个项时，它将每一个项加总到一个总和并在迭代完成时返回总和：

#[test]
fn iterator_sum() {
    let v1 = vec![1, 2, 3];

    let v1_iter = v1.iter();

    let total: i32 = v1_iter.sum();

    assert_eq!(total, 6);
}

注意：调用 sum 之后 不再允许使用 v1_iter， 因为调用 sum 时它会 获取 迭代器的所有权

Iterator trait 中定义了另一类方法，被称为 迭代器适配器 ，他们允许将 当前迭代器 变为 不同类型的迭代器 。可以 链式 调用多个迭代器适配器。不过因为所有的迭代器都是惰性的，必须调用一个消费适配器方法以便获取迭代器适配器调用的结果

下面展示了一个调用迭代器适配器方法 map 的例子，该 map 方法使用 闭包 来调用每个元素以生成新的迭代器。 这里的闭包创建了一个新的迭代器，对其中 vector 中的每个元素都被加 1：

let v1: Vec<i32> = vec![1, 2, 3];

v1.iter().map(|x| x + 1);

不过这些代码会产生一个警告：

warning: unused `std::iter::Map` which must be used: iterator adaptors are lazy
and do nothing unless consumed
 --> src/main.rs:4:5
  |
4 |     v1.iter().map(|x| x + 1);
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: #[warn(unused_must_use)] on by default

   上面的代码实际上并没有做任何事；所指定的闭包从未被调用过
   
   警告提醒了：迭代器适配器是惰性的，而这里需要消费迭代器

为了修复这个警告并消费迭代器获取有用的结果，可以使用 collect 方法。这个方法消费迭代器并将结果收集到一个数据结构中：

let v1: Vec<i32> = vec![1, 2, 3];

let v2: Vec<_> = v1.iter().map(|x| x + 1).collect();

assert_eq!(v2, vec![2, 3, 4]);

   因为传递给 map 的是一个闭包，可以指定任何希望在遍历的每个元素上执行的操作
   
   这是一个展示如何使用闭包来自定义行为同时又复用 Iterator trait 提供的迭代行为的绝佳例子

展示一个通过使用 filter 迭代器适配器和捕获环境的闭包的常规用例。迭代器的 filter 方法需要一个使用迭代器的 每一个项 并返回 布尔值 的 闭包 ：

• 如果闭包返回 true：其值将会包含在 filter 提供的新迭代器中
• 如果闭包返回 false：其值不会包含在结果迭代器中

下面展示了使用 filter 和一个捕获环境中变量 shoe_size 的闭包，这样闭包就可以遍历一个 Shoe 结构体集合以便只返回指定大小的鞋子：

#[derive(PartialEq, Debug)]
struct Shoe {
    size: u32,
    style: String,
}

fn shoes_in_my_size(shoes: Vec<Shoe>, shoe_size: u32) -> Vec<Shoe> {
    shoes.into_iter()
        .filter(|s| s.size == shoe_size)
        .collect()
}

#[test]
fn filters_by_size() {
    let shoes = vec![
        Shoe { size: 10, style: String::from("sneaker") },
        Shoe { size: 13, style: String::from("sandal") },
        Shoe { size: 10, style: String::from("boot") },
    ];

    let in_my_size = shoes_in_my_size(shoes, 10);

    assert_eq!(
        in_my_size,
        vec![
            Shoe { size: 10, style: String::from("sneaker") },
            Shoe { size: 10, style: String::from("boot") },
        ]
    );
}

shoes_in_my_size 函数获取一个鞋子 vector 的所有权和一个鞋子大小作为参数。它返回一个只包含指定大小鞋子的 vector：

1. shoes_in_my_size 函数体中调用了 into_iter 来创建一个获取 vector 所有权 的迭代器
2. 调用 filter 将这个迭代器适配成一个只含有那些闭包返回 true 的元素的新迭代器
   • 闭包从环境中捕获了 shoe_size 变量并使用其值与每一只鞋的大小作比较，只保留指定大小的鞋子
3. 调用 collect 将迭代器适配器返回的值收集进一个 vector 并返回

   已经展示了可以通过在 vector 上调用 iter、into_iter 或 iter_mut 来创建一个迭代器
   
   也可以用标准库中其他的集合类型创建迭代器，比如哈希 map

此外可以 实现 Iterator trait 来创建任何希望的迭代器。只需要 定义 中唯一要求提供的方法就是 next 方法。一旦定义了它，就可以使用所有其他由 Iterator trait 提供的拥有默认实现的方法来创建自定义迭代器了！

   作为展示，创建一个只会从 1 数到 5 的迭代器
   
   首先，创建一个结构体来存放一些值
   
   接着实现 Iterator trait 将这个结构体放入迭代器中并在此实现中使用其值

定义一个 Counter 结构体和创建 Counter 实例的关联函数 new：

struct Counter {
    count: u32,
}

impl Counter {
    fn new() -> Counter {
        Counter { count: 0 }
    }
}

Counter 结构体有一个字段 count。这个字段存放一个 u32 值，它会记录处理 1 到 5 的迭代过程中的位置

count 是私有的因为希望 Counter 的实现来管理这个值

new 函数通过总是从为 0 的 count 字段开始新实例来确保需要的行为

为 Counter 类型实现 Iterator trait，通过定义 next 方法来指定使用迭代器时的行为：

impl Iterator for Counter {
    type Item = u32;

    fn next(&mut self) -> Option<Self::Item> {
        self.count += 1;

        if self.count < 6 {
            Some(self.count)
        } else {
            None
        }
    }
}

   这里将迭代器的关联类型 Item 设置为 u32，意味着迭代器会返回 u32 值集合
   
   再一次，这里仍无需担心关联类型

希望迭代器对其内部状态加一，这也就是为何将 count 初始化为 0：

• 希望迭代器首先返回 1。如果 count 值小于 6，next 会返回封装在 Some 中的当前值
• 如果 count 大于或等于 6，迭代器会返回 None

上一章中 Config::new 的实现：

impl Config {
    pub fn new(args: &[String]) -> Result<Config, &'static str> {
        if args.len() < 3 {
            return Err("not enough arguments");
        }

        let query = args[1].clone();
        let filename = args[2].clone();

        let case_sensitive = env::var("CASE_INSENSITIVE").is_err();

        Ok(Config { query, filename, case_sensitive })
    }
}

   这里需要 clone 的原因是参数 args 中有一个 String 元素的 slice，而 new 函数并不拥有 args
   
   为了能够返回 Config 实例的所有权，需要克隆 Config 中字段 query 和 filename 的值，这样 Config 实例就能拥有这些值

在学习了迭代器之后，可以将 new 函数改为 获取 一个有 所有权 的 迭代器 作为参数而不是 借用 slice

   使用迭代器来检查 slice 长度和索引特定位置的代码，这会明确 Config::new 的工作因为迭代器会负责访问这些值
   
   一旦 Config::new 获取了迭代器的所有权并不再使用借用的索引操作，就可以将迭代器中的 String 值移动到 Config 中，而不是调用 clone 分配新的空间

上一章里search函数的实现如下：

pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
    let mut results = Vec::new();

    for line in contents.lines() {
        if line.contains(query) {
            results.push(line);
        }
    }
    results
}

可以通过使用迭代器适配器方法来编写更简明的代码：

pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
    contents.lines()
        .filter(|line| line.contains(query))
        .collect()
}

接下来的逻辑问题就是在代码中应该选择哪种风格？ 大部分 Rust 程序员倾向于使用迭代器风格：

1. 相比使用不同的循环并创建新 vector，迭代器代码则更关注循环的目的，因为抽象了那些老生常谈的代码，这样就才能更容易看清业务代码，比如迭代器中每个元素必须面对的过滤条件
2. 最小化可变状态的数量可使代码更简洁，比如上面的代码里避免了一个可变的中间 results vector 的使用，这也使得并行更加容易

  不过这两种实现真的完全等同吗？直觉上的假设是更底层的循环会更快一些