advance/functional-programing/closure

[sunface]

https://course.rs/advance/functional-programing/closure.html

[jssyzhoulei]

fn main() {
let mut s = String::new();

let update_string =  |str| s.push_str(str);

exec(update_string);

println!("{:?}",s);

}

fn exec<'a, F: FnMut(&'a str)>(mut f: F) {
f("hello")
}
————————————————————————————
这里有一个疑问 update_string声明为不可变闭包
但是exec(mut f: F)函数接收的是可变参数
为什么可以执行呢

[peanutDD]

借用楼下 fn do4(mut c: String) {}：表示实参会将所有权传递给 c，且在函数体内 c 是可读可写的，实参无需 mut 声明，入参是不可变参数

[limon]

因为 Fn 是 FnMut 的子类型： trait Fn : FnMut
另外，函数是随函数参数逆变的

[Zolyn]

update_string所有权转移给exec()函数了，这时和update_string本身是否可变就没有关系了

[karellincoln]

这里有一个疑问 update_string声明为不可变闭包
但是exec(mut f: F)函数接收的是可变参数
为什么可以执行呢

exec的参数f已经获得闭包的所有权了，操作是合法的。
类似：let mut f = update_string;

[xianfuxing]

正解

[zhangdekui]

在 Rust 中，闭包的行为取决于它所捕获的变量。如果闭包捕获的是一个可复制类型（如 String），则它会对其进行复制，而不是移动。因此，在这个例子中，变量 s 会被复制到闭包中，而不是被移动。

这是因为闭包需要对其捕获的变量进行所有权管理，以确保在闭包执行期间它们仍然有效。对于可复制类型，复制是最简单的管理方式。

需要注意的是，如果想要在闭包中移动一个值，可以使用 move 关键字来强制将其移动到闭包中。在这种情况下，闭包将获取变量的所有权，并且该变量将不再可用于闭包之外。

[cyx404]

"在 Rust 中，闭包的行为取决于它所捕获的变量。如果闭包捕获的是一个可复制类型（如 String），则它会对其进行复制，而不是移动。因此，在这个例子中，变量 s 会被复制到闭包中，而不是被移动。"

String不是可复制类型吧，它没有实现copy特征

[ArchLance]

楼上说的对啊，String没有实现copy特征，就是获得了闭包所有权吧

[jockchou]

String实现的是Clone，他说得复制是Clone得意思，不是Copy。

[siu91]

再结合之前的已知信息：query 是一个闭包
哪里已知 query 是一个闭包？🤔

[x931890193]

query: T

[Makonike]

前文提及需要设计一个缓存对象，包含一个闭包用于获取值，一个变量用于存储该值，易知value为存储值的变量，所以另一个query则为闭包。

struct Cacher<T>
where
    T: Fn(u32) -> u32, // 此处为T的特征约束
{
    query: T,
    value: Option<u32>, // 存储值的变量
}

[OTAKU-Wang]

fn exec<'a, F: FnMut(&'a str)>(mut f: F)  {
    f("hello")
}

这里'a的生命周期为什么要添加呢？

[Nanbert]

以下仅代表个人观点（还请大佬出来答疑）：类比函数，函数的参数引用，编译器都会隐式的添加生命周期（生命周期消除三原则），但本书前面又讲到闭包没法应用这个三原则，所以要我们人为添加生命周期，这里'a生命周期无实际意义，仅仅因为参数是引用，所以必须显式添加

[jimbaMe]

fn main(){
    let s = String::from("aaa");
    let y = |x| s + x;
    ex1(y);
}

fn ex1(ex: impl FnOnce(&str) -> String){
    ex("bbb");
}

为什么这样子写编译不通过，而

fn main(){
    let s = String::from("aaa");
    ex1(|x| s + x);
}

fn ex1(ex: impl FnOnce(&str) -> String){
    ex("bbb");
}

这样子写就会通过

[OTAKU-Wang]

应该是生命周期不一样导致的

[OTAKU-Wang]

fn main(){
    let s = String::from("aaa");
    let y = |x| s + x;
    ex1(y);
}

fn ex1<'a>(ex: impl FnOnce(&'a str) -> String){
    ex("bbb");
}

[kaixinbaba]

我现在写 Rust 有时候还是会恍惚，在函数签名参数上如果要加 mut 关键字的话，有时候加 冒号: 左边，有时候又是加 冒号: 右边。。

---

// 右边
fn method1(s: &mut String) {}
fn method2(s: mut String) {}

// 左边
fn method3(&mut self) {}
fn method4(mut s: String) {}

这几种写法都是有的吗。。有什么规律吗。。经常搞不清楚

[Rustln]

我来给大家解惑：

• fn do1(c: String) {}：表示实参会将所有权传递给 c
• fn do2(c: &String) {}：表示实参的不可变引用（指针）传递给 c，实参需带 & 声明
• fn do3(c: &mut String) {}：表示实参可变引用（指针）传递给 c，实参需带 let mut 声明，且传入需带 &mut
• fn do4(mut c: String) {}：表示实参会将所有权传递给 c，且在函数体内 c 是可读可写的，实参无需 mut 声明
• fn do5(mut c: &mut String) {}：表示实参可变引用指向的值传递给 c，且 c 在函数体内部是可读可写的，实参需带 let mut 声明，且传入需带 &mut

一句话总结：在函数参数中，冒号左边的部分，如：mut c，这个 mut 是对🪄函数体内部有效🪄；冒号右边的部分，如：&mut String，这个 &mut 是针对🪄外部实参传入时的形式（声明）说明🪄。

---

来看看例子：

fn main() {
    let d1 = "str".to_string();
    do1(d1);

    let d2 = "str".to_string();
    do2(&d2);

    let mut d3 = "str".to_string();
    do3(&mut d3);

    let d4 = "str".to_string();
    do4(d4);

    let mut d5 = "str".to_string();
    do5(&mut d5);
}

fn do1(c: String) {}

fn do2(c: &String) {}

fn do3(c: &mut String) {}

fn do4(mut c: String) {}

fn do5(mut c: &mut String) {}

[sunfu12]

在哪里能招到优秀的rust程序员？

[xianfuxing]

评论也是圣经级别

[showyou2023]

fn do5(mut c: &mut String) {}
+mut 声明C的函数内部可读可写。
内部可读可写是指什么？
实参可变引用指向的值传递给 c，C已经可读可写了

[showyou2023]

我的理解，函数形参+mut，只有形参是不可变引用或传值，而且需要形参在函数内部需要作为可变变量的情况下。

[droog126]

fn fn_once<F>(func: F)
where
    F: FnMut() -> () + Copy, // 改动在这里
{
    func();
}

fn main() {
    let mut x = vec![1, 2, 3];
    fn_once(|| x.push(2));
}

我这个为什么不行

[Frynoodles]

Copy is implemented for &std::vec::Vec<i32>, but not for &mut std::vec::Vec<i32>
报错&mut std::vec::Vec没有实现Copy这个特征，而且你这也没必要用到这个trait。
根据编译器的提示可以这样改

fn main() {
    let mut x = vec![1, 2, 3];
    fn_once(|| x.push(2));
    dbg!(x);
}
fn fn_once<F>(mut func: F /*根据提示，将func改为了mut func(编译器，你好强大)*/)
where
    F: FnMut() -> (),
{
    func();
}

输出结果:
[src\main.rs:4] x = [
1,
2,
3,
2,
]
大概是这样。

[leowei1234567]

这一章学完感觉很混乱

[zssssssk]

emo了

[rtpacks]

emo了

[hzk8000]

emo了

[vince-1998]

emo了

[hamsterjiang23]

emo了

[zhouhaoan]

对于这个代码

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

我尝试在new函数中直接定义闭包函数，报错如下：
代码：

impl<T, E> Cacher<T, E> 
where 
    T: Fn(E) -> E,
    E: Copy
{ 
    fn new() -> Cacher<T, E> {
        let mut c = |a| a; 
        Cacher {
            query: c,
            value: None,
        }
    }
}

报错：

error[E0308]: mismatched types
  --> src/main.rs:18:20
   |
10 | impl<T, E> Cacher<T, E>
   |      - this type parameter
...
16 |         let mut c = |a| a;
   |                     ----- the found closure
17 |         Cacher {
18 |             query: c,
   |                    ^ expected type parameter `T`, found closure
   |
   = note: expected type parameter `T`
                     found closure `[closure@src/main.rs:16:21: 16:26]`
   = help: every closure has a distinct type and so could not always match the caller-chosen type of parameter `T`
help: use parentheses to call this closure
   |
18 |             query: c(a),
   |                     +++

For more information about this error, try `rustc --explain E0308`.

想不明白同样的闭包函数，为什么通过参数传入就是正确的，在构造函数里面写就是类型不匹配

[Aresona]

every closure has a distinct type

[xianfuxing]

其实和闭包没什么关系，例如：

fn main() {
    foo(33);
}

fn foo<T: Copy>(t: T)  -> T {
    let a = 33;
    a
}

error[E0308]: mismatched types
  --> src\main.rs:10:5
   |
8  | fn foo<T: Copy>(t: T)  -> T {
   |        -                  - expected `T` because of return type
   |        |
   |        this type parameter
9  |     let a = 33;
10 |     a
   |     ^ expected type parameter `T`, found integer
   |
   = note: expected type parameter `T`
                        found type `{integer}`

foo(33)没有报错，但是 let a = 33; 就报错。因为 let a = 33; 返回a，其实就隐含 let a: T = 33; 自然会报错。类型不匹配。
为何 foo(33)就没有报错，因为 33在这里是 i32 类型（数字默认i32），实现了 Copy trait。
也就是只要在入参、返回值的时候，只要该值实现了约束的Trait，就不会报错。但是在方法、函数内部，通过变量绑定该Trait （let x: T = xx)就一定会报类型不匹配错误。那怕x确实是实现了 T。

[sunwu51]

前面说FnOnce，该类型的闭包会拿走被捕获变量的所有权。后面又说，如果你想强制闭包取得捕获变量的所有权，可以在参数列表前添加 move 关键字。所以到底FnOnce能没拿走捕捉变量的所有权

[jssyzhoulei]

1 所有的闭包都实现了FnOnce 比如Fn、FnMut 都可以当做FnOnce用
2 其次如文中所述【一个闭包实现了哪种 Fn 特征取决于该闭包如何使用被捕获的变量，而不是取决于闭包如何捕获它们】叠加第一条 所以FnOnce 闭包也可以不获取捕获变量所有权
3 加上move之后的闭包只能是FnOnce不可能再当做Fn、FnMut使用 所捕获的变量所有权已经move闭包中了

[chenyinheng30]

String没有实现Copy，参考中的代码依旧无法缓存String

[showyou2023]

fn main() {
let s = String::new();
let update_string = move || println!("{}",s); exec(update_string);
}
fn exec<F: FnOnce()>(f: F) { f() }

书中的例子。
我的问题是:
既然闭包实现了FnOnce，也就是被捕捉变量回发生所有权转移，那有什么必要再加move.

[sunwu51]

闭包具体实现了FnOnce但是并不代表就会转移所有权，因为所有闭包都实现了他。决定闭包到底是实现了FnOnce FnMut还是Fn的关键是在于，闭包内的逻辑，变量是必须拿到所有权才行，还是拿到可变的引用就行，还是拿到引用就行。

s是上下文的String变量，||return s;就是必须拿到所有权，所以只实现了FnOnce。||s.push_str("xx")就可以不拿所有权，只用可变引用就能实现功能，那默认就不会move进来，这里的s也只是上下文中s的可变引用，闭包实现了FnMut；||println!("{}",s)同理只拿不可变引用就实现功能了，那s是上下文s的引用，闭包实现Fn。

上面的具体实现哪个trait(哪些)，是隐式的，move则是对于实现了Fn FnMut的闭包想要强制拿所有权的时候就可以派上用场了

[showyou2023]

"1. FnOnce，该类型的闭包会拿走被捕获变量的所有权。Once 顾名思义，说明该闭包只能运行一次。"

那上面译文中的反应不准确。
FnOnce强调的是只能允许一次，所有权的解释是错误的。

[showyou2023]

感觉FnOnce是多余的😀
可变闭包实现FnMut
不可变闭包实现Fn
如果需要所有权，+Move
FnMut &Fn 默认不转移所有权。

[showyou2023]

fn main() {
let mut s = String::new();
let update_string = |str| -> String {s.push_str(str); s };
exec(update_string);
}
fn exec<'a, F: FnMut(&'a str) -> String>(mut f: F) { f("hello"); }
书中的例子
为什么闭包只实现了FnOnce?
环境变量S，既被修改，又被做为返回值从闭包中返回。

[showyou2023]

let sum = |x, y| x + y;
let v = sum(1, 2);
书中的例子，我的问题是
x,y都可以推导出类型为i32，但是返回值是->{unknown}，为什么推导不出来呢？

[zhenyuy]

fn main() {
let mut s = String::from("name ");

let update_string = |str|{s.push_str(str);};

exec(update_string);
exec(update_string); < -- **use of moved value: `update_string` value used here after move**
println!("{s}");

}

fn exec<'a, F: FnMut(&'a str)>(mut f: F) {
f("hello");
}

我的问题是，如果我希望实现的closure是能够被use as parameters for more than one time(即便这个closure捕获了一个mutable的variable，这里了就是 s), 我应该怎么做？

[Zolyn]

传可变引用（编译器已经提示了）

[qianyiwangmeng]

fn factory(x:i32) -> impl Fn(i32) -> i32 {

let num = 5;

if x > 1{
    move |x| x + num
} else {
    move |x| x - num
}

}

就算签名一样吧闭包类型也是不同的。。。
我寻思着 着两个返回值 move |x| x + num和move |x| x - num 类型哪里不同？

[0xDamn]

fn fn_once<F>(func: F)
where
    F: FnOnce(usize) -> bool,
{
    println!("{}", func(3));
    println!("{}", func(4));
}

fn main() {
    let x = vec![1, 2, 3];
    fn_once(|z|{z == x.len()})
}

------- func moved due to this call // 转移在这

• 这里有个问题func作为变量发生了转移那么它转移到了哪里？或者说发生转移后这个闭包所有权归谁所有？
• 还有就是上面所说的Fn特征判定是与被捕获的环境变量相关的，我理解着这个例子里x是被捕获变量吧，为什么要关注闭包变量func本身呢？

[Hoteryoung]

说下我的理解哈，不一定对

1. 因为是FnOnce 然后没有实现copy 那就是第一次打印之后 就被释放了
2. 我理解，“Fn特征判定是与被捕获的环境变量相关的”这个不太严谨 FnOnce 和 Fn 都可以move 也可以不move。还是三种Fn关系那三条比较靠谱 捂脸.gif

[Endermanbugzjfc]

转移到首次执行该闭包的地方吧？

[iCoobin]

函数式编程：函数或匿名函数同变量一样享有一等公民待遇

[apodemakeles]

被Cacher的思考题难住了，如果是其他语言这将是一个很好实现的功能。我不想将E的类型限定在Copy或者Clone，有办法么？

[Endermanbugzjfc]

应该只得改成 FnMut
或者使用 RefCell 运行时可修改性检查
不过会造成堆分配

[csjgg]

Too young too naive😭😭😭

[laindream]

习题没了..自己写了个cacher的case,有问题欢迎吐槽...

use std::collections::HashMap;
use std::hash::Hash;

struct Cacher<T, K, V>
    where
        K: Copy,
        T: Fn(K) -> Option<V>, {
    query: T,
    data: Option<HashMap<K, V>>,
}

impl<T, K, V> Cacher<T, K, V>
    where
        K: Copy + Eq + Hash,
        V: Copy + Eq + Hash,
        T: Fn(K) -> Option<V>, {
    fn new(query: T) -> Cacher<T, K, V> {
        Cacher {
            query,
            data: None,
        }
    }
    
    fn value(&mut self, k: K) -> Option<V> {
        match self.data {
            Some(ref mut data) => {
                match data.get(&k) {
                    Some(v) => Some(v.clone()),
                    None => {
                        let v = (self.query)(k);
                        match v {
                            Some(v) => {
                                data.insert(k, v);
                                Some(v)
                            }
                            None => None,
                        }
                    }
                }
            }
            None => {
                let mut data = HashMap::new();
                let v = (self.query)(k);
                match v {
                    Some(v) => {
                        data.insert(k, v);
                        self.data = Some(data);
                        Some(v.clone())
                    }
                    None => None,
                }
            }
        }
    }
}

#[derive(PartialEq)]
struct Point<T>
    where T: Copy + Eq + Hash {
    x: T,
    y: T,
}

impl<T> Point<T>
    where T: Copy + Eq + Hash
{
    fn new(x: T, y: T) -> Point<T> {
        Point { x, y }
    }
}

impl<T: Copy> Clone for Point<T>
    where T: Copy + Eq + Hash {
    fn clone(&self) -> Self {
        Point::new(self.x, self.y)
    }
}

impl<T: Copy> Copy for Point<T>
    where T: Copy + Eq + Hash {}

impl<T: Eq> Eq for Point<T>
    where T: Copy + Eq + Hash {}

impl<T: Hash> Hash for Point<T>
    where T: Copy + Eq + Hash {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        self.x.hash(state);
        self.y.hash(state);
    }
}

impl<T: std::fmt::Display> std::fmt::Display for Point<T>
    where T: Copy + Eq + Hash {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "Point({}, {})", self.x, self.y)
    }
}


fn main() {
    let mut map = HashMap::new();
    map.insert("apple", Point::new(1, 2));
    map.insert("alice", Point::new(3, 4));
    map.insert("guild", Point::new(5, 6));
    //query will get the value from map
    let query = |key| {
        //get clone value from map
        match map.get(key) {
            Some(v) => Some(v.clone()),
            None => None,
        }
    };
    let mut cacher = Cacher::new(query);
    let mut get_point = |key| {
        match cacher.value(key) {
            Some(v) => v,
            None => Point::new(0, 0),
        }
    };
    let v1 = get_point("apple");
    let v2 = get_point("alice");
    let v3 = get_point("guild");
    let v4 = get_point("orange");
    println!("v1: {} \nv2: {} \nv3: {} \nv4: {}", v1, v2, v3, v4);
}

[tjw123hh]

https://github.com/sunface/rust-by-practice/blob/master/zh-CN/src/functional-programing/closure.md

[tjw123hh]

找到张图

[tjw123hh]

来自 https://zhuanlan.zhihu.com/p/64417628

[TURING132]

为什么这单代码可以正常运行呢？闭包拿走了x的所有权，通过原来的x还可以进行调用？

fn fn_once<F>(func: F)
where
    F: FnOnce(usize) -> bool,
{
    println!("{}", func(3));
}

fn main() {
    let x = vec![1, 2, 3];
    fn_once(|z|{z == x.len()});
    println!("{}",x[0]);
}

[Biubiubiubiujiu]

并没有拿走x的所有权，FnOnce只是对参数func进行特征约束。编译器在对x

[Biubiubiubiujiu]

编译器在对x进行捕获的时光，根据其函数体内部的使用，自动推断为不可变引用捕获，即& x

[hamsterjiang23]

fn fn_once<F>(func: F)
        where
            F: FnOnce(usize) -> bool,
        {
            println!("{}", func(3));
        }

        fn main() {
            let x = vec![1, 2, 3];
            let y = |z| z == x.len();
            fn_once(y);
            println!("{}",x[0]);
        }

编译器给的标注y是fn特征

[hamsterjiang23]

fn特征默认实现了fnonce

[yuliang0225]

转角都能遇到爱

[TableBear]

这节课是没有练习题吗？

[Endermanbugzjfc]

Catcher 的部分算一个

[ytianxia6]

大概看了下，这章不太感兴趣，用到了再来看吧

[lgln0]

疑问：mut仅作用于编译器的语法分析中？

fn main() {
    let mut s = String::new();

    let update_string = |str| -> String {s.push_str(str); println!("{}", s); s };

    exec(update_string);
}

fn exec<'a, F: FnOnce(&'a str) -> String>(f: F) {
    f("hello");
}

以上代码可以运行，结果正确输出“hello”。但在exec函数申明中，没有申明mut f: F。
从语法上没问题，是否说明了mut仅仅作用于编译器的语法分析中，实际运行中并不看mut

[h2222]

我谈一下我的理解
闭包 update_string 捕获 s, 但因为 s 为String, 没有实现 Copy 特征, 因此根据规则: 只要闭包捕获的类型都实现了Copy特征的话，这个闭包就会默认实现Copy特征
因此, 闭包 update_string 也没有实现 Copy 特征. 因此 函数 exec 直接捕获闭包 update_string 的所有权, 那所有权都捕获了, 那 mut 还是 不mut 那不是由 exec 定嘛, exec 想怎么搞就怎么搞, 举个例子来说:

let x = String::from("hello"); 
let mut xx = x; // x 的所有权被 xx 捕获, xx 想mut就mut 不想mut就不mut
let xxx = xx;  // xx 的所有权被 xxx 捕获, xxx 不想 mut 就不mut了

另外关于 FnOnce 的问题, 如果你把 FnOnce 换成 FnMut, Fn 程序都会报错, 因为 闭包实现了那种Fn trait (Fn, FnMut, FnOnce) 取决于该闭包函数捕获了那种变量, 因此, update_string 只实现了 FnOnce 是因为:

let update_string = |str| -> String {s.push_str(str); println!("{}", s); s }; // 这里直接把环境捕获变量给返回了 ....

这样返回之后, 整条链路就变成了:闭包 update_string 捕获 s

[h2222]

这样返回之后, 整条链路就变成了:

1. 闭包 update_string 捕获 String s ---> update_string 有 s 的所有权
2. 函数 exec 捕获 update_string ---> exec 有 update_string 的所有权
3. 在 exec 函数中执行 f ---> 执行结束后, f 被 drop 掉
4. f 被drop 掉 ---> 字符串 s 被drop 掉
   因此 你只能使用 FnOnce.

[lgln0]

我的意思是，f对闭包中的s字符串进行了可变引用，可f本身并不是可变的。事实上，在exec函数外直接调用update_string的话，必须声明update_string是可变的

[h2222]

我这边测试了一下, 不声明 update_string 是可变的, 直接调用也能跑的通

let mut s: String = String::new();
let update_string = |str| {s.push_str(str); println!("{}", s); s};
let x = update_string("hello");
println!("x: {}", x);

[lgln0]

那我记错了，看来update_string仅实现FnOnce特征时，可以不声明mut，也能改变捕获的值。
因为字符串s已经被move到闭包内了，闭包内的变化和闭包外无关，所以闭包是否可变无关紧要。

[Alkaidd]

在js里闭包是如此的自然一度让我以为所有语言的闭包都是这样的...

[UVUUUVUU]

闭包中的参数可以是泛型参数吗

[Endermanbugzjfc]

不可以
因为闭包的类型在定义时会被固定

[dwangxxx]

感觉这一章写得不太好，有点难以理解，没有说透闭包的本质。实际上闭包可以理解成一个结构体，和 C++ 的 lambda 函数一样，都是用结构体来实现的。闭包捕获变量也就是会在结构体里面添加一个成员变量，这个成员变量根据捕获方式的不同可以是 值、不可变引用和可变引用。
至于 Fn、FnMut 和 FnOnce 具体实现哪一种，也可以从原理上来解释，因为 FnOnce 调用函数的时候是用 self 也就是结构体本身的值，如果闭包结构体本身是不可以 Copy，那么就只能调用一次，如果是可以 Copy 的，那么就可以调用多次。而闭包结构体本身是否是可以 Copy 的就可以按照普通结构体的规则来看，需要结构体里面的所有变量都可以 Copy，这样就很好判断了。
而 FnMut 调用函数的时候使用 &mut self，也就是结构体的可变引用，所以可以改变值。而且用 self 作为参数也是可以改变值的，因此实现了 FnMut 的同时肯定也是实现了 FnOnce 的。但是如果在闭包里面转移了所捕获参数的所有权，那么就只是实现了 Fn，因为不能转移一个结构体的可变引用里面的某个值的所有权。
对于 Fn，调用函数的时候用的是 &self，也就是结构体的不可变引用，所以不可以改变值。而此时如果用 &mut self 或者 self，同样可以实现函数里面的操作，所以实现了 Fn 的同时肯定也是实现了 FnMut 和 FnOnce 的。
用 move 来转移了所捕获的变量（如果被捕获的值是可以 Copy 的，那这个所有权也没有被转移，只是 Copy 了一个新值，比如 i32 等基础类型），只是意味着闭包里面捕获的变量是值的形式，具体实现了 Fn、FnMut 和 FnOnce 的哪一种，还需要具体看闭包函数里面的实现。

[dwangxxx]

感觉这一章写得不太好，有点难以理解，没有说透闭包的本质。实际上闭包可以理解成一个结构体，和 C++ 的 lambda 函数一样，都是用结构体来实现的。闭包捕获变量也就是会在结构体里面添加一个成员变量，这个成员变量根据捕获方式的不同可以是 值、不可变引用和可变引用。
至于 Fn、FnMut 和 FnOnce 具体实现哪一种，也可以从原理上来解释，因为 FnOnce 调用函数的时候是用 self 也就是结构体本身的值，如果闭包结构体本身是不可以 Copy，那么就只能调用一次，如果是可以 Copy 的，那么就可以调用多次。而闭包结构体本身是否是可以 Copy 的就可以按照普通结构体的规则来看，需要结构体里面的所有变量都可以 Copy，这样就很好判断了。
而 FnMut 调用函数的时候使用 &mut self，也就是结构体的可变引用，所以可以改变值。而且用 self 作为参数也是可以改变值的，因此实现了 FnMut 的同时肯定也是实现了 FnOnce 的。但是如果在闭包里面转移了所捕获参数的所有权，那么就只是实现了 Fn，因为不能转移一个结构体的可变引用里面的某个值的所有权。
对于 Fn，调用函数的时候用的是 &self，也就是结构体的不可变引用，所以不可以改变值。而此时如果用 &mut self 或者 self，同样可以实现函数里面的操作，所以实现了 Fn 的同时肯定也是实现了 FnMut 和 FnOnce 的。
用 move 来转移了所捕获的变量（如果被捕获的值是可以 Copy 的，那这个所有权也没有被转移，只是 Copy 了一个新值，比如 i32 等基础类型），只是意味着闭包里面捕获的变量是值的形式，具体实现了 Fn、FnMut 和 FnOnce 的哪一种，还需要具体看闭包函数里面的实现。

[dwangxxx]

文章里面说的 FnOnce 会拿走变量的所有权也不准确，应该说是在变量没有 Copy 特征的时候，并且在闭包内部会转移变量所有权或者使用 move 的时候才会拿走变量的所有权。

[hamsterjiang23]

fn main() {
                let mut s = String::new();
            
                let update_string =  |str| s.push_str(str);
            
                exec(update_string);           
                println!("{:?}",s);

                // 闭包自己的所有权在被exec函数接收后，就转移走了

                // 在这里update_string的所有权被转移给了exec
                // 注意：并不是所有的闭包都不会自动实现Copy特征
                // 主要闭包所捕获的类型实现了Copy也在，闭包会自动默认实现copy
                {
                    let mut a = 222;
                    let mut update_a = |x| -> () { a = x;};
                    fn exec<F: FnMut(i32)>(mut f: F) {
                        f(333);
                    }
                    // 不对啊，这里虽然i32也实现了copy，但是闭包没有实现copy
                    exec(&mut update_a);
                    exec(update_a);
                    println!("{}", a);
                }

            }
            main();

这里有问题吧，i32实现了copy但是这个闭包没有自动实现copy