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

[1654364091]

可能是编译器不够智能，你这么写就能通过编译：
fn main(){
let s = String::from("aaa");
let y = |x :&str| s + x;
ex1(y);
}

fn ex1(ex: impl FnOnce(&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]

这一章学完感觉很混乱

[hamsterjiang23]

emo了

[chenjjiaa]

emo了

[wwc0915]

emo了

[hongwanwei]

emo了

[OstrichZkh]

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 类型哪里不同？

[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进行捕获的时光，根据其函数体内部的使用，自动推断为不可变引用捕获，即& 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

[1654364091]

实现Fn特征的闭包，可以复制给要求FnOnce特征的变量，就和生命周期static可以满足生命周期a的要求一样。
有隐含的“协变”机制

[1654364091]

“赋值给”，我上面打错字了

[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 的时候才会拿走变量的所有权。

[woxin123]

这里的 Fn 很想 Java 中的接口吗，更有点像是 Kotlin 里面的 Function。Kotlin 为了实现函数类型，搞了一个 Function0 ~ Function22，还有一个 FunctionN

[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

[wingmanjzx]

这里捕获的变量是a，并且要给a赋值，可能需要考虑&mut i32有没有copy。

[ThenMorning]

factory的参数x 和 闭包的x 不是一个x，这样写有点误导了，可以把闭包的改成y

[ThenMorning]

或者直接删除，让闭包捕获外部的x 和 num

[W2Q3Q1]

有无朋友解释一下为啥会有“闭包”这种打破封装的功能？换句话说为啥要让闭包可以捕获和操作外部变量呀？

[woxin123]

讲的不清不楚的，Fn(i32) -> i32 这个没解释清楚，这里的 Fn 是一个 trait，但是写法就是语法糖，试了一下，解糖后不给调用，说不稳定。

// 这里说 Tuple 不稳定
pub trait MyFn<Args: std::marker::Tuple> {
    type Output;
}

fn get_add_fun(x: i32) -> Box<dyn MyFn<(i32), Output=i32>> {
    Box::new(move |y| x + y)
}

这样写在 RustRover get_add_fun 没有提示错误。

如果把 MyFn trait 改成下面这样不使用 Tuple：

pub trait MyFn<Args> {
    type Output;
}

编译后会说 MyFn 没有使用 closure。

error[E0277]: the trait bound `{closure@src/main.rs:16:14: 16:22}: MyFn<i32>` is not satisfied
  --> src/main.rs:16:5
   |
16 |     Box::new(move |y| x + y)
   |     ^^^^^^^^^^^^^^^^^^^^^^^^ the trait `MyFn<i32>` is not implemented for closure `{closure@src/main.rs:16:14: 16:22}`
   |
help: this trait has no implementations, consider adding one
  --> src/main.rs:2:1
   |
2  | pub trait MyFn<Args> {
   | ^^^^^^^^^^^^^^^^^^^^
   = note: required for the cast from `Box<{closure@src/main.rs:16:14: 16:22}>` to `Box<(dyn MyFn<i32, Output = i32> + 'static)>`

把 get_add_fun 用解糖后的 Fn 去写

//fn get_add_fun(x: i32) -> Box<dyn Fn(i32) -> i32> {
//    Box::new(move |y| x + y)
//}

fn get_add_fun(x: i32) -> Box<dyn Fn<(i32), Output=i32>> {
    Box::new(move |y| x + y)
}

编译后直接告诉你，不能这么写。

error[E0658]: the precise format of `Fn`-family traits' type parameters is subject to change
  --> src/main.rs:11:35
   |
11 | fn get_add_fun(x: i32) -> Box<dyn Fn<(i32), Output=i32>> {
   |                                   ^^^^^^^^^^^^^^^^^^^^^ help: use parenthetical notation instead: `Fn(i32) -> i32`
   |
   = note: see issue #29625 <https://github.com/rust-lang/rust/issues/29625> for more information

如果解糖去调用，编译失败，然后给了一个 issue 地址。

fn main() {
    let add_one = get_add_fun(1);
    println!("1 + 2 = {}", add_one.call(2));
}

error[E0658]: use of unstable library feature 'fn_traits'
  --> src/main.rs:23:36
   |
23 |     println!("1 + 2 = {}", add_one.call(2));
   |                                    ^^^^
   |
   = note: see issue #29625 <https://github.com/rust-lang/rust/issues/29625> for more information

[TableBear]

你要定义闭包应该是要实现std里面的Fn、FnOnce、FnMut这三个Trait的吧，不是自己定义的Trait

[woxin123]

其实，可以看得出这一长串是 T 的特征约束，再结合之前的已知信息：query 是一个闭包，大概可以推测出，Fn(u32) -> u32 是一个特征，用来表示 T 是一个闭包类型？Bingo，恭喜你，答对了！

我想说的是可以对这块多做一些解释，Fn、FnOnce、FnMut 是 Trait 没错，但是是一个特殊的 Trait，不是普通的 Trait，不然会一脸懵，就会有疑问，既然 Fn 是 Trait，为什么不是标准的写法，为什么 Fn 可以这样写。对于一个初学者，对于上面这段话是不理解的。这里的推测也很牵强，都不是 trait 的语法怎么推测。

[TableBear]

其实，可以看得出这一长串是 T 的特征约束，再结合之前的已知信息：query 是一个闭包，大概可以推测出，Fn(u32) -> u32 是一个特征，用来表示 T 是一个闭包类型？Bingo，恭喜你，答对了！

我想说的是可以对这块多做一些解释，Fn、FnOnce、FnMut 是 Trait 没错，但是是一个特殊的 Trait，不是普通的 Trait，不然会一脸懵，就会有疑问，既然 Fn 是 Trait，为什么不是标准的写法，为什么 Fn 可以这样写。对于一个初学者，对于上面这段话是不理解的。这里的推测也很牵强，都不是 trait 的语法怎么推测。

还好吧，作者只是根据Rust的where后面跟着的是Trait限定的一般化特征，告诉我们Fn(u32)->u32是一个Trait。可以看着一个承接吧。不然一上来就介绍Fn也会懵。不过，作者要是能总结一下闭包其实是一个Rust编译自己生成的结构体自动实现Fn、FnOnce或者FnMut效果会更好

[woxin123]

还好吧，作者只是根据Rust的where后面跟着的是Trait限定的一般化特征，告诉我们Fn(u32)->u32是一个Trait。可以看着一个承接吧。不然一上来就介绍Fn也会懵。不过，作者要是能总结一下闭包其实是一个Rust编译自己生成的结构体自动实现Fn、FnOnce或者FnMut效果会更好

个人习惯吧，遇到新事物又不解释为什么是这样，总感觉很难受，特别是扯到了 Trait，然后又没讲清楚。但凡这里说一下 Fn(u32) -> u32 是一个 Trait，并且是一个语法糖，并且规定就是要这么写，我也不会去研究这些。

[beyondlex]

记录一下对于FnOnce, FnMut和Fn的理解：

判断closure实现了哪种Fn trait, 需要看这个closure body中的代码:

• 如果一个closure有move out captured value的行为, 它只能是FnOnce, 成为不了FnMut, 更成为不了Fn.
• 如果一个closure没有move out captured value, 但它改变了captured value, 那它只能是FnOnce和FnMut, 成为不了Fn.
• 如果一个closure没有move out captured value, 也没改变captured value, 那它可以是Fn, 当然也肯定是FnOnce, FnMut.

关于closure在使用时的约束:

• 如果某个地方要求closure是一个Fn, 则表明这里需要一个严格自律的closure, 不会mutate captured value, 更不会move out captured value.
• 如果某个地方要求closure是一个FnMut, 则表明这里需要一个稍微自律的closure, 可以mutate captured value, 但不能move out captured value, 因为我需要多次调用closure, 你不能有move out的行为导致只能被调用一次, 这样满足不了我的要求, 但你可以mutate captured value, 这个我倒是不太关心.
• 如果某个地方要求closure是一个FnOnce, 则表明这里不挑剔, 给我的是一个closure能执行一次就可以, 我不管你有没有move out, 有没有mutate, 因为我只要调用一次closure就行, 所以move没move out, mutate没mutate都不是我关心的.

[KyonQi]

这章很有意思，收获颇丰

[KyonQi]

但是文章有部分转移所有权感觉有点含糊，如果是i32这种copy类型，move的意义在哪呢

[ytianxia6]

实现了copy的，不move。大概就像 c#的值类型和引用类型。

[ytianxia6]

rust 很有意思的一个点，好像故意把 c++ 里的很多东西给反过来了。
c++ 里要类型安全，需要特意使用智能指针，要不然默认都是裸指针。。rust 默认都是智能指针，要使用裸指针，你得特意去操作。
c++ 里默认是对象，所有=操作都默认是复制操作，要内存拷贝得定义指针。 rust 里默认都是指针操作，要定义复制操作，需要定义 copy 。