Rust学习笔记-5-基础篇：闭包
背景
本文主要是在阅读《Rust编程之道》的闭包章节后，对知识点做的相关梳理。目前接触Rust还不久，感觉《Rust编程之道》相对官方教程而言写的更深更细。但看完该书闭包这一章节后，感觉有必要梳理一下，以加深理解。
示例之疑1
fn main(){
let mut s="rush".to_string();
{
let mut c=||{s+=" rust"};
c();
c();
println!("{:?}",s);
}
println!("{:?}",s);
}这个示例是书中6-38的代码。书中提到：1，第1个println那一行会报错；2，第2个println能正确运行，是因为s的所有权被归还。
这个示例代码很短。来验证一下，在Rust的playground中执行
https://play.rust-lang.org/?version=stable&mode=debug&edition=2018
结果发现：
1，能正常执行，并没有报错。即书中关于第1点的阐述不成立。
2，去掉那一对大括号（如下代码），也不会报错。即书中关于第2点的阐述恐难成立。
fn main(){
let mut s="rush".to_string();
let mut c=||{s+=" rust"};
c();
c();
println!("{:?}",s);
println!("{:?}",s);
}所以书中关于这一示例引申出的解释和结论，需要重新推敲一下。
示例之疑2
示例6-33 移动语义类型自动实现FnOnce
fn main(){
let s = "hello".to_string();
let c = || s;
c();//"hello"
//c();//use of moved value: `c`
//println!("{:?}",s);//borrow of moved value: `s`
}示例6-36 环境变量为移动语义类型时使用move关键字
fn main(){
let s = "hello".to_string();
let c = move || {println!("{:?}",s)};
c();//"hello"
c();//"hello"
//println!("{:?}",s);//borrow of moved value: `s`
}单独看这两个例子，运行符合预期，似乎没毛病。然则仔细一想，此两个示例有点问题。哪里有问题？这两个示例中闭包的写法不同。先这两个示例的闭包写法“对调”一下。
示例6-33 的改写版
fn main(){
let s = "hello".to_string();
let c = || {println!("{:?}",s)};
c();//"hello"
c();//"hello"
println!("{:?}",s);//"hello"
}示例6-36 的改写版
fn main(){
let s = "hello".to_string();
let c = move || s;
c();//"hello"
//c();//use of moved value: `c`
//println!("{:?}",s);//borrow of moved value: `s`
}看出奥秘了吗？那就是，影响闭包函数实现哪个trait，除了与这3个因素：环境变量的语义（复制语义或移动语义）、环境变量是否在闭包中是否修改、是否有move关键字相关，还与闭包中对所捕获的环境变量的”用法“相关。（这里之所以”用法“打引号，是因为到写此文时，自己还没彻底理解，这些用法最终会影响闭包实现trait的根因。）。
上面的两个改写版，在维持以上3因素不变的前提下，仅仅是改写了闭包内部的代码（对环境变量的使用，也就是第4个因素），就得到截然不同的结果。所以，书中关于这两个示例所延申出来的解释和结论，感觉不太可靠。
比如，书中6-36 示例据此推出来的结论：“……可以进行多次调用。同理，该闭包实现的一定是Fn”。实际上，按照上面6-36的改写版，是无法得出这样的结论的。
从这个现象看，似乎闭包中对环境变量的用法不同，会导致其所有权可能转移，也可能不转移。再看下面的测试代码：
fn main(){
println!("ownership of String is not moved by closure.");
let s1 = "hello".to_string();
println!("{:?},{:p}",s1,&s1);//"hello",0x7fff5803b578
let c = || {println!("{:?},{:p}",s1,&s1);};
c();//"hello",0x7fff5803b578
c();//"hello",0x7fff5803b578
println!("{:?},{:p}",s1,&s1);//"hello",0x7fff5803b578 注意地址均相同。
println!("ownership of String is moved by closure.");
let s2 = "hello".to_string();
println!("{:?},{:p}",s2,&s2);//"hello",0x7ffe3c53efd0
let c = || {println!("{:?},{:p}",s2,&s2);s2;};//注意这里多了一个s2;
c();//"hello",0x7ffe3c53f070，注意地址不同。
//c();//use of moved value: `c`
//println!("{:?},{:p}",s2,&s2);//borrow of moved value: `s2`
}从中可以发现，虽然s1是移动语义，且被闭包捕获，但是从实际表现看，并没有发生所有权的转移（这点和书中总结的“对于移动语义类型，执行移动语义，转移所有权来进行捕获”，就有点对不上了）。s1的引用地址在闭包调用前后都没有发生变化。
如果在闭包中再添加一点代码（这里添加：s2;），就会导致s2的所有权被移动：s2的引用地址也发生了变化；闭包不能多次调用；s2在闭包调用后也不能再使用。
根据这种现象，暂且先猜测如下推论：
1，闭包若捕获移动语义的环境变量，且该变量在闭包中未修改，（暂且不考虑move关键字，下面测试再考虑），那么闭包中存在一些对此变量的用法，这些用法使得该环境变量的所有权，并不会发生转移。这种情况占少数。如下示例：
let c = || {println!("{:?}",s)};2，除了上述的用法外，其他大部分的用法，均能使得此变量的所有权发生转移。如下示例：
let c = || {s};
let c = || {s;};
let c = || {println!("{:?}",s);s};
let c = || {println!("{:?}",s);s;};
let c = || {let s1=s;};注：
1，要解释这种现象，可以猜测一些可能性。例如，编译器对闭包是不是存在一些特殊的处理规则。这个疑点先留下来。后续弄明白后再更新此文。
动手验证
正是因为上述的一些疑问或问题，决定自己动手，写点测试代码，试着摸索总结一下闭包的这两个规律：闭包实现哪个trait；是否转移环境变量的所有权；如何影响环境变量。
影响闭包行为的因素：有无环境变量，环境变量的语义（复制还是移动），闭包中有无修改环境变量，有无move关键字，闭包中对环境变量的用法（为便于描述，姑且称之特殊情况和非特殊情况。测试代码中的“特殊情况”仅有println!，“非特殊情况"则除了println!之外还加一点其他代码）。
闭包表现出来的行为：实现了哪个trait(Fn/FnMut/FnOnce）、环境变量是否转移所有权、如何影响环境变量。
测试结果：
| 有无 环境变量 |
环境变量的语义（复制还是移动） |
环境变量在闭包中有无修改 | 有无使用move关键字 | 闭包中对环境变量的用法 | 闭包实现的是哪个trait | 环境变量的所有权是否转移 | 环境变量的捕获方式 |
| 没有 | / | / | / | / | Fn | / | / |
| 有 | 复制语义 | 不修改 | 无 | 仅有println! | Fn | 不转移 | &T |
| 不只有println! | Fn | 不转移 | &T |
||||
| 有 | 仅有println! | Fn | 不转移 | &T |
|||
| 不只有println! | Fn | 不转移 | &T |
||||
| 修改 | 无 | /（既然有修改，肯定不会只有println!) |
FnMut | 不转移 | &mut T （原变量会受影响） |
||
| 有 | FnMut | 不转移 | copy后的新变量 （原变量不受影响） |
||||
| 引用语义 | 不修改 | 无 | 仅有println! | Fn | 转移 | / | |
| 不只有println! | FnOnce | 转移 | / | ||||
| 有 | 仅有println! | Fn | 转移 | / | |||
| 不只有println! | FnOnce | 转移 | / | ||||
| 修改 | 无 | /（既然有修改，肯定不会只有println!) | FnMut | 不转移 | &mut T （原变量会受影响） |
||
| 有 | FnMut | 转移 | mut T（个人猜测） |
观察测试结果，简化一下：
| 有无 环境变量 |
环境变量的语义（复制还是移动） |
环境变量在闭包中有无修改 | 有无使用move关键字 | 闭包中对环境变量的用法 | 闭包实现的是哪个trait | 环境变量的所有权是否转移 | 环境变量的捕获方式 |
| 没有 | / | / | / | / | Fn | / | / |
| 有 | 复制语义 | 不修改 | /（不影响） | /（不影响) | Fn | 不转移 | &T |
| 修改 | 无 | / |
FnMut | 不转移 | &mut T （原变量会受影响） |
||
| 有 | copy后的新变量 （原变量不受影响） |
||||||
| 移动语义 | 不修改 | 无 | 仅有println! | Fn | 转移 | / | |
| 不只有println! | FnOnce | ||||||
| 有 | 仅有println! | Fn | |||||
| 不只有println! | FnOnce | ||||||
| 修改 | 无 | / | FnMut | 不转移 | &mut T （原变量会受影响） |
||
| 有 | 转移 | / |
用文字概括一下：
1，对于复制语义的环境变量：
- 所有权不会转移到闭包。变量的捕获方式和对原变量的影响：无修改->&T（无影响）；有修改+无move->&mut T（有影响）；有修改+有move->copy（无影响）。（看来move对于复制语义，又不能真的移动，只好复制。）
- 闭包实现哪个trait：无修改->Fn；有修改->FnMut；
2，对于移动语义的环境变量：
- 所有权的转移、变量的捕获方式和对原变量的影响：无修改，或者有修改+有move->转移所有权（原变量的所有权已转移到闭包，闭包外已不能访问）；有修改+无move->&mut T（有影响）.
- 闭包实现哪个trait：有修改->FnMut；无修改+非特殊情况->FnOnce；无修改+特殊情况->Fn。这里的特殊情况，指的是类似仅调用println!的方法。
和书中的规则对照
判断闭包实现是哪个trait（Fn,FnMut,Fnonce）的规则
· 如果闭包中没有捕获任何环境变量，则默认自动实现Fn 。
· 如果闭包中捕获了复制语义类型的环境变量，则：
➢ 如果不需要修改环境变量，无论是否使用move关键字，均会自动实现Fn。
➢ 如果需要修改环境变量，则自动实现FnMut。
· 如果闭包中捕获了移动语义类型的环境变量，则：
➢ 如果不需要修改环境变量，且没有使用move关键字，则自动实现FnOnce。
➢ 如果不需要修改环境变量，且使用了move关键字，则自动实现Fn。
➢ 如果需要修改环境变量，则自动实现FnMut。
和书中规则对照，除下划线的两行外，其他是一致的。
书中规则认为：不修改+有move->Fn。反证举例：示例代码中的条件9和条件10，符合”不修改+有move“的情况，但并非二者都实现Fn，而是分别实现了Fn和FnOnce。同理，书中规则认为：”不修改+无move"->FnOnce。反证举例：示例代码中的7和8。
从验证代码看，在移动语义+不修改时，是实现Fn还是FnOnce，跟move没关系。看起来跟闭包内使用变量的方式有关。
闭包自动实现Copy/Clone的规则
·使用 move 关键字，如果捕获的变量是复制语义类型的，则闭包会自动实现Copy/Clone，否则不会自动实现Copy/Clone
此为书中规则，和验证结果一致。
闭包捕获环境变量的规则
对不同环境变量类型介绍过闭包捕获其环境变量的方式：
· 对于复制语义类型，以不可变引用（&T）来进行捕获。
· 对于移动语义类型，执行移动语义，转移所有权来进行捕获。
· 对于可变绑定，并且在闭包中包含对其进行修改的操作，则以可变引用（&mut T）来进行捕获。
这段文字在书中第2章和第6章分别出现一次。当时在第2章初次看到时，感觉有点纳闷：对于可变绑定的复制语义类型，是遵循第1条还是第3条规则？对于可变绑定的移动语义类型，是遵循第2条还是第3条规则？
结合验证结果，以自己的理解，解读一下上述规则。
- ·对于复制语义类型：无修改->&T；有修改+无move->&mut T；有修改+有move->copy
- ·对于移动语义类型：无修改，或者有修改+有move->转移所有权；有修改+无move->&mut T
注：
1，因个人碰rust的时间不长。若理解若有偏差，还请留言批评指正。
测试代码如下
#![feature(fn_traits)]
fn main(){
println!("条件1:环境变量为复制语义+闭包内无修改+无move+闭包中仅有println!使用环境变量");
let v1=1i32;
let c1= || {println!("{:?}",v1);};
c1.call(());//1
//c1.call_mut(()); //cannot borrow `c1` as mutable, as it is not declared as mutable
c1.call_once(());//1
println!("{:?}",v1);//1
println!("条件2:环境变量为复制语义+闭包内无修改+无move+闭包中不只有println!使用环境变量");
let v2=1i32;
let c2= || {println!("{:?}",v2);v2};
c2.call(());//1
//c2.call_mut(()); //cannot borrow `c2` as mutable, as it is not declared as mutable
c2.call_once(());//1
println!("{:?}",v2);//1
println!("条件3:环境变量为复制语义+闭包内无修改+有move+闭包中仅有println!使用环境变量");
let v3=1i32;
let c3= move ||{println!("{:?}",v3);};
c3.call(());//1
//c3.call_mut(());//cannot borrow `c3` as mutable, as it is not declared as mutable
c3.call_once(());//1
println!("{:?}",v3);//1
println!("条件4:环境变量为复制语义+闭包内无修改+有move+闭包中不只有println!使用环境变量");
let v4=1i32;
let c4= move ||{println!("{:?}",v4);v4};
c4.call(());//1
//c4.call_mut(());//cannot borrow `c4` as mutable, as it is not declared as mutable
c4.call_once(());//1
println!("{:?}",v4);//1
println!("条件5:环境变量为复制语义+闭包内有修改+无move");
let mut v5=1i32;
let mut c5= || {v5+=1;println!("{:?}",v5);};
//c5.call(()); //expected a closure that implements the `Fn` trait, but this closure only implements `FnMut`
c5.call_mut(()); //2
c5.call_once(()); //3
println!("{:?}",v5);//3
println!("条件6:环境变量为复制语义+闭包内有修改+有move");
let mut v6=1i32;
let mut c6= move ||{v6+=1;println!("{:?}",v6);};
//c6.call(());//expected a closure that implements the `Fn` trait, but this closure only implements `FnMut`
c6.call_mut(());//2
c6.call_once(());//3
println!("{:?}",v6);//1
println!("条件7:环境变量为移动语义+闭包内无修改+无move+闭包中仅有println!使用环境变量");
let v7="a".to_string();
let c7= || {println!("{:?}",v7);};
c7.call(()); //"a"
//c7.call_mut(()); //expected a closure that implements the `FnMut` trait, but this closure only implements `FnOnce`
c7.call_once(()); //"a"
//println!("{:?}",v7);//borrow of moved value: `v7`
println!("条件8:环境变量为移动语义+闭包内无修改+无move+闭包中不只有println!使用环境变量");
let v8="a".to_string();
let c8= || {println!("{:?}",v8);v8};
//c8.call(()); //expected a closure that implements the `FnMut` trait, but this closure only implements `FnOnce`
//c8.call_mut(()); //expected a closure that implements the `FnMut` trait, but this closure only implements `FnOnce`
c8.call_once(()); //"a"
//println!("{:?}",v8);//borrow of moved value: `v8`
println!("条件9:环境变量为移动语义+闭包内无修改+有move+闭包中仅有println!使用环境变量");
let v9="a".to_string();
let c9= move || {println!("{:?}",v9);};
c9.call(()); //"a"
//c9.call_mut(()); //cannot borrow `c9` as mutable, as it is not declared as mutable
c9.call_once(()); //"a"
//println!("{:?}",v9);//borrow of moved value: `v9`
println!("条件10:环境变量为移动语义+闭包内无修改+有move+闭包中不只有println!使用环境变量");
let v10="a".to_string();
let c10= move || {println!("{:?}",v10);v10};
//c10.call(()); //expected a closure that implements the `FnMut` trait, but this closure only implements `FnOnce`
//c10.call_mut(()); //expected a closure that implements the `FnMut` trait, but this closure only implements `FnOnce`
c10.call_once(()); //"a"
//println!("{:?}",v10);//borrow of moved value: `v10`
println!("条件11:环境变量为移动语义+闭包内有修改+无move");
let mut v11="a".to_string();
let mut c11= || {v11+="a";println!("{:?}",v11);};
//c11.call(()); //expected a closure that implements the `Fn` trait, but this closure only implements `FnMut`
c11.call_mut(()); //"aa"
c11.call_once(()); //"aaa"
println!("{:?}",v11);//"aaa"
println!("条件12:环境变量为移动语义+闭包内有修改+有move");
let mut v12="a".to_string();
let mut c12= move || {v12+="a";println!("{:?}",v12);};
//c12.call(()); //expected a closure that implements the `Fn` trait, but this closure only implements `FnMut`
c12.call_mut(()); //"aa"
c12.call_once(()); //"aaa"
//println!("{:?}",v12);//borrow of moved value: `v12`
}