Rust学习笔记1：闭包
Rust学习笔记1：闭包
什么是闭包？
闭包是一种可以捕获调用者作用域变量的匿名函数。它既可以作为值赋值给变量，又可以作为实参传递给函数，它让函数变成了一种数据类型存在。还有，由于闭包不需要进行参数和返回值的类型标注，这可以省却我们不少事情。
下面这是一个好例子，cat的值是一个闭包，它捕捉了变量x。它的参数和返回值都没有类型标注，又没有fn、花括号，代码显得十分简洁。
fn main() {
let x = 100;
let cat = |y| x + y;
assert_eq!(101, cat(1));
}闭包的语法
这是闭包的正统语法：
|param1, param2...| {
语句1;
语句2;
返回表达式
}如果只有一行代码，花括号按约定也可以省去：
|param1,param2...| 返回表达式当把一个闭包赋值给一个变量时，例如下面这个骚气的闭包：
let action = || 3;此时是闭包赋值给了action，并不是把闭包的执行结果赋值给了它。这一点非常浅显易知，有经验的程序员一定不会犯这样的判断错误。
谨以此例为例，action在执行之后结果仍然为3，它和let action = 3区别并不大，即使新学者判断失误也没有问题。
类型推导：先入为主
闭包不用标注参数和返回值的类型，编译器会自己推导，但是它的推导有时候会因先入为主而产生“错误”：
fn main() {
let fn1 = |x| x;
let s = fn1(String::from("hi"));
let n = fn1(5);
}第3行和第4行代码，谁放在后面，谁在编译时报错。**此时决定它们正确与否的关键，只是它们所站的位置不同。**闭包中的参数类型和返回值类型被推导为一种可能后，就会被一直保持为这种可能。后来的会被排斥。
怎么破解？如果我们在下面需要有不同类型参数的调用呢？
解决方法也极其简单：
fn main() {
let s = (|x| x)(String::from("hi"));
let n = (|x| x)(5);
println!("s: {}", s);
println!("n: {}", n);
}闭包可以现写现用，相同的闭包代码拷贝一份即可。代码虽然还是那个代码，但闭包已经不是那个闭包。
闭包的所有权⭐
现在我们设想这样一个问题：如果我们在结构中使用了闭包，那么Rust对该闭包的所有权是如何规定的呢？
先看一则非常有Rust意味的代码示例：
struct Cache<T,E>
where
T: Fn(E) -> E,
E: Copy
{
query: T,
value: Option<E>,
}
impl<T,E> Cache<T,E>
where
T: Fn(E) -> E,
E: Copy
{
fn new(query: T) -> Self {
Cache {
query,
value: None
}
}
fn value(&mut self, arg: E) -> E {
match self.value {
Some(v) => v,
None => {
let v = (self.query)(arg);
self.value = Some(v);
v
}
}
}
}在结构体Cache中，query是一个闭包，它的类型是T，约束T的特征是Fn(E) -> E。
代码很简单，不细讲了，下面开始实践。如果我们在两个结构中实例中引用同一个闭包，会发生什么呢？程序会报错吗？
fn main() {
let a = 1;
let fn1 = |x| x + a;
let mut c = Cache::new(fn1);
println!("{}", c.value(10)); // 11
println!("{}", c.value(11)); // 仍然是 11
let mut d = Cache::new(fn1);
println!("{}", d.value(10)); // 1
println!("{}", d.value(11)); // 仍然是 10
}c与d是两个Cache实例，它俩同时使用了fn1赋值query，但是程序并没有因为所有权冲突而报错。
Rust中的闭包在所有权这个议题上稍微有点复杂，究竟有没有发生所有权转移，要看闭包捕获的变量是什么情况。没有捕获或捕获的只是栈上的变量，即实现了Copy的变量，那么闭包也在栈上，并没有所有权转移，而是产生了复制（Copy），跟重写一遍闭包代码没有区别。
如何判断闭包是不是实现了Copy特征呢？和其它复杂的类型一样，看闭包捕获的变量是不是都实现了Copy特征，如果是，则闭包也实现了Copy特征；如果否，则不是。
对于否的这种情况，即捕猎的变量是分配在堆上的，大小是动态的，例如String，那么闭包也分配在堆上，这时候对闭包没有实现Copy特征，对它的使用就涉及到所有权转移了。
下面我们做另外一个实验，我们让闭包捕获一个String类型的变量：
#[test]
fn test() {
let a = String::from("LY");
// L的ascii码是76
let fn1 = |x| x + a.chars().next().unwrap() as u8 as i32-75;
println!("a={}", a); // 这行代码会报错
let mut c = Cache::new(fn1);
assert_eq!(c.value(10), 11);
assert_eq!(c.value(11), 11);
println!("a={}", a); // LY
let mut d = Cache::new(fn1);
assert_eq!(d.value(10), 11);
assert_eq!(d.value(11), 11);
println!("a={}", a); // LY
}这个测试通过了，它没有报错。并且a一直都能打钱。为什么？
这是因为闭包fn1对a的使用，仅是引用，并没有夺取它的所有权。我们如果在闭包前面加上一个move，情况就不一样了。
let fn1 = move |x| x + a.chars().next().unwrap() as u8 as i32-75;程序不能编译能过了，为什么？因为发生了所有权转移，当a被闭包占有后，后面的代码就不能再使用它了。
move的含义是：不管原来有没有发生所有权转移，加上move一定会发生所有权转移。
三种Fn特征⭐
闭包会捕获调用者作用域中的变量，按照捕获方式不同，及闭包可以执行一次或多次，Rust给闭包分配了三种特征，涵盖所有情况。
1，FnOnce，对待捕获变量的方式是转移所有权，仅能执行一次。如果所有权仅可转移一次，所以闭包也仅能执行一次。
FnOnce特征示例：
fn fn_once<F>(f: F)
where
F: FnOnce(usize) -> bool,
{
println!("{}", f(3));
// println!("{}", f(4));
}
fn main() {
let x = String::from("123");
fn_once(|z| {
let y = x;
z == y.len()
});
// println!("{}", x); // 这里不可用，x已经被move了
}第6行代码不可执行，因为f作为传递进来的闭包仅可执行一次。第15行代码也不可执行，因为x的所有权已经在第12行被闭包转移给了y。
对于被FnOnce特征约束的闭包，有没有办法执行两次甚至多次呢？
当然有。
当我们给闭包实现Copy特征后，它就可以多次调用了：
fn fn_once<F>(f: F)
where
F: Copy + FnOnce(usize) -> bool,
{
println!("{}", f(3));
println!("{}", f(4));
}
fn main() {
let x = String::from("123");
fn_once(|z| {
let y = x.clone();
z == y.len()
});
println!("{}", x); // 这里的x可以使用了
}第6行与第15行的代码都可以正常运行了。第6行可以运行，是因为闭包f实现了Copy特征。第15行可以运行，是因为在第12行，y是对x的克隆，x的所有权并没有被转移进来。
在这个示例中，我们虽然对闭包使用了FnOnce特征，但同时还有其他特征加在它的身上，它已经不纯粹了，自然也不能单纯地继续恪守“只能执行一次”的规则了。
2，FnMut，对待捕获变量的方式是可变借用，可执行多次。但这种方式在多线程中不具有安全性。
FnMut示例：
fn main() {
let mut s = String::from("123");
let mut update = |str| s.push_str(str);
update("45");
exec(update, "67");
println!("{:?}", s); // 1234567
}
fn exec<'a, F: FnMut(&'a str)>(mut f: F, s: &'a str) {
f(s)
}第3行是一个闭包，并且赋值给了变量update。该闭包捕获了变量s，并且是以可变借用的方式捕获并使用的。我们单独执行第4行代码，编译器要求在update前面加上mut修饰符。当闭包要修改其捕获的变量时，在闭包变量前面必须加上mut修饰符。
但是，如果我们单执行第5行代码，第3行中的mut修饰符又可以去掉，为什么？
对闭包使用mut修饰符和应用FnMut特征是两套体系，对于后面，第9行的特征约束已经保证闭包对捕获的变量应用可变借用的方式。这一块实现拿捏不准，可依编译器为准，Rust编译器是Rust程序员的vb
3，Fn，对待捕获变量的方式是不可变借用，可执行多次。这种方式在多线程中具有安全性。
Fn特征示例：
fn main() {
let s = String::from("123");
let update = |str| format!("{}{}", str, s);
update("45".to_string());
exec(update, "67".to_string());
println!("{:?}", s); // 123
}
fn exec<'a, F: Fn(String) -> String>(f: F, s: String) -> String {
f(s)
}第3行，update闭包对参数str拥有所有权，对捕获的变量s只是不可变借用，无论是独立调用，还是通过exec调用，都没有问题。第6行，s没有变化，输出仍然是“123”。
三种Fn特征之间的继承关系⭐
这是它们的简化版源码：
pub trait Fn<Args> : FnMut<Args> {
...
}
pub trait FnMut<Args> : FnOnce<Args> {
...
}
pub trait FnOnce<Args> {
...
}从源码可以看出来，三种Fn特征存在继承关系：Fn继承于FnMut，FnMut又继承于FnOnce。如果画一张图，该关系应该是这样的：
Fn → FnMut → FnOnce
从继承关系看，Fn对函数的约束最大，FnOnce最小，从描述上看，确实也是如此：
- FnOnce：转移所有权，调用一次，线程不安全
- FnMut：可变借用，可调用多次，线程不安全
- Fn：不可变借用，可调用多次，线程安全
从上往上看，对闭包的约束越来越强了。转移所有权是Rust的默认执行方式。
三种Fn特征是一种对函数的约束特征，并且这种约束是通过函数本身的代码决定的，Rust编译器也是通过代码进行的类型推断。下面是一种示例，展示了如果是我们人为对函数施加约束，则可能对同一个函数，三种约束都是ok的：
fn main() {
let s = String::from("1234567890");
let update = || println!("{}",s);
exec1(update); // 1234567890
exec2(update); // 1234567890
exec3(update); // 1234567890
}
fn exec1<F: FnOnce()>(f: F) {
f()
}
fn exec2<F: FnMut()>(mut f: F) {
f()
}
fn exec3<F: Fn()>(f: F) {
f()
}但是，如果我将update的代码修改一下：
let update = || {
let x = s;
println!("{}",x);
};update转移了变量s的所有权，此时exec2、exec3的调用都不再合适，只有exec1的调用无误，因为exec1的特征约束是FnOnce，与update的代码呈现出来的对变量的使用方式是相同的。一个闭包实现的是三类中的哪种特征，取决于它如何使用捕获的变量。
move与mut
move与mut是语法层面的修饰符，move代表强制转移所有权，作用与FnOnce相当，mut代表闭包对捕获的变量将有修改，是可变借用，作用与FnMut相当。我们不使用Fn特征，使用这两个修饰符有时也能达到类似的语法效果。
mut示例：
fn main() {
let mut s = String::from("123");
let mut update = |str| s.push_str(str);
update("456");
println!("{}", s); // 123456
}变量s被捕获，在第2行要被修改，所以第2行变量前要加上mut。在第3行，因为闭包对捕获的变量要进行修改，所以在update变量前也要加上mut修饰符。Rust注重内存安全，凡是涉及到内存变动的地方，
move示例：
fn main() {
let s = String::from("123");
let update = move |str| println!("{}{}", s, str);
update("456"); // 123456
// println!("{}", s); // 这里不可运行
}因为变量s的所有权被消耗了，所以第5行不能运行。
函数如何返回闭包？⭐
Rust是静态语言，函数的参数和返回值必须是固定大小，但是闭包并不是固定大小的。举个例子说明一下，对于下面的闭包：
let s = String::from("hello");
let closure2 = |x| x + s.len(); // 捕获一个 String在编译器编译后，会生成一个结构体，并实现一个方法：
fn main() {
let c1 = Closure2 { s: String::from("hello") };
let result = c1.call(1); // 调用 call 方法
println!("{}", result); // 输出 6
}
// 手动实现的结构体
struct Closure2 {
s: String, // 捕获的环境变量
}
// 为结构体实现一个普通的 call 方法
impl Closure2 {
fn call(&self, x: i32) -> i32 {
x + self.s.len() as i32
}
}我们对闭包的调用，相当于第3行对编译后call方法的调用。
由于Closure2中s是一个动态变量，它的大小是不固定的，所以闭包的大小也是不固定的。
有人说，如果闭包捕获的是一个固定大小的变量呢，例如let x = 1？
即使如此，闭包的大小也是按照“不确定的大小”对待的，至少目前Rust编译器目前是这样做的。
好，我们已经明确，闭包大小不是确定的，那么在函数中返回闭包，我们怎么做呢？
下面是一个函数返回闭包的示例：
fn main() {
let f = factory();
let answer = f(1);
assert_eq!(6, answer); // 通过
}
fn factory() -> Box<dyn Fn(i32) -> i32> {
let num = 5;
Box::new(move |x| x + num)
}第9行返回了一个使用Box包装的闭包。Box是智能指针，它的大小是固定的，通常需要解引用（*）访问其内容，在第3行并没有解引用直接调用了，这是因为Rust对Box有自动解引用的语法机制。在第3行，(*f)(1)与f(1)是相同的。
最后再总结一下，为什么函数直接返回一个闭包不可以，返回使用Box包装的闭包就可以呢？闭包的大小是不固定的，不能作为函数的返回值返回，把它分配在堆上，让Box的指针指向它，Box作为智能指针它的大小是固定的，这样就可以满足Rust编译器的要求了。在许多地方，当Rust编译器要求固定大小，而代码实际情况不满足的时候，Rust都是这样解决的。
2025年3月8日