Rust 学习笔记：闭包

Rust 学习笔记：闭包

Rust 的闭包是匿名函数，可以保存在变量中，也可以作为参数传递给其他函数。

可以在一个地方创建闭包，然后在其他地方调用闭包，以便在不同的上下文中对其进行计算。

与函数不同，闭包可以从定义它们的作用域捕获值。

用闭包捕获环境

实现一个赠送衬衫的程序。如果选择免费衬衫的人有他们最喜欢的颜色，他们就会得到那种颜色的衬衫。如果这个人没有指定最喜欢的颜色，他们就会得到公司目前最常用的颜色。

示例：

#[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}}
}fn main() {let store = Inventory {shirts: vec![ShirtColor::Blue, ShirtColor::Red, ShirtColor::Blue],};let user_pref1 = Some(ShirtColor::Red);let giveaway1 = store.giveaway(user_pref1);println!("The user with preference {:?} gets {:?}",user_pref1, giveaway1);let user_pref2 = None;let giveaway2 = store.giveaway(user_pref2);println!("The user with preference {:?} gets {:?}",user_pref2, giveaway2);
}

在 giveaway 方法中，我们将用户偏好作为 Option<ShirtColor> 类型的参数获取，并在 user_preference 上调用 unwrap_or_else 方法。Option<T> 上的 unwrap_or_else 方法由标准库定义。它接受一个参数：一个没有任何参数的闭包，返回一个值T（与存储在 Option<T> 的 Some 变体中的类型相同，在本例中为 ShirtColor）。如果 Option<T> 是 Some 变量，则 unwrap_or_else 返回 Some 中的值。如果 Option<T> 是 None 变量，则 unwrap_or_else 调用闭包并返回闭包返回的值。

我们指定闭包表达式 || self.most_stocked() 作为 unwrap_or_else 的参数。这是一个本身不接受参数的闭包（如果闭包有参数，它们将出现在两个竖条之间）。闭包的主体调用 self.most_stocked()。

闭包捕获对 self Inventory 实例的不可变引用，并将其与我们指定的代码一起传递给 unwrap_or_else 方法。一般函数是做不到这一点的。

闭包类型推断和注释

闭包通常不需要像 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  ;

对于闭包定义，编译器将为它们的每个形参及其返回值推断出一个具体类型。因为没有类型注解，我们可以用任何类型调用闭包。

示例：

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

程序报错：

当我们第一次用 String 值调用 example_closure 时，编译器推断出 x 的类型和闭包的返回类型为 String。然后，这些类型被锁定在 example_closure 中的闭包中，当我们下一次尝试对相同的闭包使用不同的类型时，我们会得到一个类型错误。

捕获引用或移动所有权

闭包可以通过三种方式从其环境中获取值：不可变借用、可变借用和获取所有权。闭包将根据函数体如何处理捕获的值来决定使用哪一个。

示例 1：

fn main() {let list = vec![1, 2, 3];println!("Before defining closure: {list:?}");let only_borrows = || println!("From closure: {list:?}");println!("Before calling closure: {list:?}");only_borrows();println!("After calling closure: {list:?}");
}

定义了一个闭包 only_borrows，它捕获了一个指向名为 list 的 vector 的不可变引用，因为它只需要一个不可变引用就可以输出值。

这个例子还说明了变量可以绑定到闭包定义，稍后我们可以通过使用变量名和括号调用闭包，就好像变量名是函数名一样。

因为我们可以同时对 list 有多个不可变引用，所以在闭包定义之前、在闭包定义之后、在闭包被调用之前和在闭包被调用之后，都可以访问 list。这段代码编译、运行和输出：

示例 2：

fn main() {let mut list = vec![1, 2, 3];println!("Before defining closure: {list:?}");let mut borrows_mutably = || list.push(7);borrows_mutably();println!("After calling closure: {list:?}");
}

我们修改闭包体，使其向列表向量添加一个元素。

当定义 borrows_mutable 时，它捕获一个对 list 的可变引用。在闭包定义和闭包调用之间，不允许使用不可变借用来打印，因为当存在可变借用时不允许使用其他借用。

如果想强制闭包获得它在环境中使用的值的所有权，可以在参数列表之前使用 move 关键字。

当向新线程传递闭包以移动数据以使其归新线程所有时，此技术非常有用。

示例 3：

use std::thread;fn main() {let list = vec![1, 2, 3];println!("Before defining closure: {list:?}");thread::spawn(move || println!("From thread: {list:?}")).join().unwrap();
}

我们生成一个新线程，给线程一个闭包作为参数运行。尽管闭包体只需要一个不可变引用就能完成打印，但我们需要通过在闭包定义的开头放置 move 关键字来指定应该将列表移动到闭包中。

新线程可能在主线程的其余部分完成之前完成，或者主线程可能先完成。如果主线程保持 list 的所有权，但在新线程结束并删除list之前结束，则线程中的不可变引用将无效。因此，编译器要求将 list 移到给新线程的闭包中，这样引用才有效。

将捕获的值移出闭包和 Fn Traits

一旦闭包从定义闭包的环境中捕获了引用或捕获了值的所有权，闭包体中的代码将定义在稍后求值闭包时对引用或值的处理。

闭包体可以执行以下任何操作：将捕获的值移出闭包，改变捕获的值，既不移动也不改变值，或者从环境开始不捕获任何值。

闭包从环境中捕获和处理值的方式会影响闭包实现的 trait，而 trait 就是函数和结构如何指定它们可以使用的闭包类型。闭包将以一种附加的方式自动实现一个、两个或所有这三个 Fn trait，具体取决于闭包的主体如何处理这些值：

1. FnOnce：应用于可以调用一次的闭包。所有闭包都至少实现了这个特性，因为所有闭包都可以被调用。将捕获值移出其体的闭包只会实现 FnOnce，而不会实现其他 Fn trait，因为它只能被调用一次。
2. FnMut：应用于闭包，闭包不会将捕获的值移出其主体，但可能会改变捕获的值。这些闭包可以被多次调用。
3. Fn：适用于不会将捕获值移出其主体且不会改变捕获值的闭包，以及不从其环境中捕获任何值的闭包。这些闭包可以被多次调用而不会改变它们的环境，这在并发调用闭包多次的情况下非常重要。

让我们看一下 Option<T> 的 unwrap_or_else 方法的定义：

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

T 是泛型类型，表示 Option 的某些变体中的值的类型，也是 unwrap_or_else 函数的返回类型。

unwrap_or_else 函数具有额外的泛型类型参数 F，它是我们在调用 unwrap_or_else 时提供的闭包。

在泛型类型 F 上指定的 trait 绑定是 FnOnce() -> T，这意味着 F 必须能够被调用一次，不接受参数，并返回一个 T。在函数体中，如果 Option 是 Some，则不会调用 f。如果 Option 为 None，则 f 将被调用一次。因为所有闭包都实现了 FnOnce，所以 unwrap_or_else 函数接受所有三种闭包。

注意：如果我们想要做的事情不需要从环境中捕获值，我们可以使用函数名而不是闭包。
例如，如果 Option<Vec<T>> 值为 None，则可以调用 unwrap_or_else(Vec::new) 来获得一个新的空 vector。编译器自动实现任何一个适用于函数定义的 Fn traits。

现在让我们看一下在切片上定义的标准库方法 sort_by_key，看看它与 unwrap_or_else 有什么不同，以及为什么 sort_by_key 使用 FnMut 而不是 FnOnce 作为 trait 绑定。闭包以引用的形式获得一个参数，并返回排序后的结果。

在下面的示例中，我们有一个矩形实例列表，我们使用 sort_by_key 按它们的 width 属性从低到高排序：

#[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:#?}");
}

运行结果：

sort_by_key 被定义为接受 FnMut 闭包的原因是，它多次调用闭包：对片中的每个项调用一次。闭包 |r| r.width 不会捕获、改变或从其环境中移出任何东西。

相反，下面的代码展示了一个闭包示例，它只实现了 FnOnce trait，因为它将一个值移出了环境。编译器不允许我们使用 sort_by_key 闭包。

#[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 },];let mut sort_operations = vec![];let value = String::from("closure called");list.sort_by_key(|r| {sort_operations.push(value);r.width});println!("{list:#?}");
}

这段代码试图通过将一个字符串从闭包的环境压入数组来完成计数。闭包捕获 value，然后通过将 value 的所有权转移给 sort_operations 数组，将 value 移出闭包。这个闭包只可以被调用一次，尝试第二次调用它将不起作用，因为 value 已经没有对字符串的所有权了。因此，这个闭包只实现了 FnOnce。当我们尝试编译这段代码时，会得到这样的错误：不能将值移出闭包，因为闭包必须实现 FnMut。

错误指向闭包体中将值移出环境的行。要解决这个问题，我们需要更改闭包体，使其不会将值移出环境。在环境中保留一个计数器并在闭包体中增加其值是计算闭包调用次数的更直接的方法。

#[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 },];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");
}

修改后的闭包可以与 sort_by_key 一起工作，因为它只捕获对 num_sort_operations 计数器的可变引用，因此可以多次调用。

在定义或使用使用闭包的函数或类型时，Fn Traits 非常重要。在下一节中，我们将讨论迭代器，许多迭代器方法都接受闭包参数。