理解 Rust 中不同类型的闭包
不同于其他语言，Rust 对self参数的使用是显式的。当我们实现结构体时，必须把self作为函数签名的第一个参数：
struct MyStruct {
text: &'static str,
number: u32,
}
impl MyStruct {
fn new (text: &'static str, number: u32) -> MyStruct {
MyStruct {
text: text,
number: number,
}
}
// We have to specify that 'self' is an argument.
fn get_number (&self) -> u32 {
self.number
}
// We can specify different kinds of ownership and mutability of self.
fn inc_number (&mut self) {
self.number += 1;
}
// There are three different types of 'self'
fn destructor (self) {
println!("Destructing {}", self.text);
}
}
因此，下面这两种风格是一样的：
obj.get_number();
MyStruct::get_number(&obj);
这和那些把self（或this）隐藏起来的语言不同。在那些语言中，只要将一个函数和一个对象或结构关联起来，就隐含着第一个参数是self。在上面的代码中，我们有四个self选项：一个不可变引用，一个可变引用，一个被拥有的值，或者压根就没有使用self作为参数。
因此，self表示函数执行的某一类上下文。它在 Rust 中是显式的，但是在其他语言中经常是隐含的。
此外，在本文中，我们将会使用下面的函数：
fn is_fn <A, R>(_x: fn(A) -> R) {}
fn is_Fn <A, R, F: Fn(A) -> R> (_x: &F) {}
fn is_FnMut <A, R, F: FnMut(A) -> R> (_x: &F) {}
fn is_FnOnce <A, R, F: FnOnce(A) -> R> (_x: &F) {}
这些函数的唯一作用是类型检查。例如，如果is_FnMut(&func)能够编译，那么我们就可以知道那个func属于FnMut trait。
无上下文和fn（小写的 f）类型
鉴于上述内容，考虑几个使用（上面定义的）MyStruct的闭包的例子：
let obj1 = MyStruct::new("Hello", 15);
let obj2 = MyStruct::new("More Text", 10);
let closure1 = |x: &MyStruct| x.get_number() + 3;
assert_eq!(closure1(&obj1), 18);
assert_eq!(closure1(&obj2), 13);
这是我们可以得到的最简单的（代码示例）。这个闭包为类型MyStruct的任意对象中的已有数字加上三。它可以在任意位置被执行，不会有任何问题，并且编译器不会给你带来任何麻烦。我们可以很简单地写出下面这样的代码替代closure1:
// It doesn't matter what code appears here, the function will behave
// exactly the same.
fn func1 (x: &MyStruct) -> u32 {
x.get_number() + 3
}
assert_eq!(func1(&obj1), 18);
assert_eq!(func1(&obj2), 13);
这个函数不依赖于它的上下文。无论它之前和之后发生了什么，它的行为都是一致的。我们（几乎）可以互换着使用func1和closure1。
当一个闭包完全不依赖上下文时，我们的闭包的类型就是fn：
// compiles successfully.
is_fn(closure1);
is_Fn(&closure1);
is_FnMut(&closure1);
is_FnOnce(&closure1);
可变上下文和Fn（大写的 F）trait
相较于上面，我们可以为闭包添加一个上下文。
let obj1 = MyStruct::new("Hello", 15);
let obj2 = MyStruct::new("More Text", 10);
// obj1 is borrowed by the closure immutably.
let closure2 = |x: &MyStruct| x.get_number() + obj1.get_number();
assert_eq!(closure2(&obj2), 25);
// We can borrow obj1 again immutably...
assert_eq!(obj1.get_number(), 15);
// But we can't borrow it mutably.
// obj1.inc_number(); // ERROR
closure2依赖于obj1的值，并且包含周围作用域的信息。在这段代码中，closure2将会借用obj1从而使得它可以在函数体中使用obj1。我们还可以对obj1进行不可变借用，但是如果我们试图在后面修改obj1，我们将会得到一个借用错误。
如果我们尝试使用fn语法来重写我们的闭包，我们在函数内部需要知道的一切都必须作为参数传递给函数，所以我们添加了一个额外的参数来表示函数的上下文：
struct Context<'a>(&'a MyStruct);
let obj1 = MyStruct::new("Hello", 15);
let obj2 = MyStruct::new("More Text", 10);
let ctx = Context(&obj1);
fn func2 (context: &Context, x: &MyStruct) -> u32 {
x.get_number() + context.0.get_number()
}
其行为和我们的闭包基本一致：
assert_eq!(func2(&ctx, &obj2), 25);
// We can borrow obj1 again immutably...
assert_eq!(obj1.get_number(), 15);
// But we can't borrow it mutably.
// obj1.inc_number(); // ERROR
注意，Context结构体包含一个对MyStruct结构体的不可变引用，这表明我们将无法在函数内部修改它。
当我们调用closure1时，也意味着我们我们把周围的上下文作为参数传递给了closure1，正如我们在使用fn时必须要做的那样。在一些其他的语言中，我们不必指定将self作为参数传递，与之类似，Rust 也不需要我们显式地指定将上下文作为参数传递。
当一个闭包以不可变引用的方式捕获上下文，我们称它实现了Fn trait。这表明我们可以不必修改上下文而多次调用我们的函数。
// Does not compile:
// is_fn(closure2);
// Compiles successfully:
is_Fn(&closure2);
is_FnMut(&closure2);
is_FnOnce(&closure2);
可变上下文和FnMut trait
如果我们在闭包内部修改obj1，我们会得到不同的结果：
let mut obj1 = MyStruct::new("Hello", 15);
let obj2 = MyStruct::new("More Text", 10);
// obj1 is borrowed by the closure mutably.
let mut closure3 = |x: &MyStruct| {
obj1.inc_number();
x.get_number() + obj1.get_number()
};
assert_eq!(closure3(&obj2), 26);
assert_eq!(closure3(&obj2), 27);
assert_eq!(closure3(&obj2), 28);
// We can't borrow obj1 mutably or immutably
// assert_eq!(obj1.get_number(), 18); // ERROR
// obj1.inc_number(); // ERROR
这一次我们不能对obj1进行可变借用和不可变借用了。我们还必须得把闭包标注为mut。如果我们希望使用fn语法重写这个函数，将会得到下面的代码：
struct Context<'a>(&'a mut MyStruct);
let mut obj1 = MyStruct::new("Hello", 15);
let obj2 = MyStruct::new("More Text", 10);
let mut ctx = Context(&mut obj1);
// obj1 is borrowed by the closure mutably.
fn func3 (context: &mut Context, x: &MyStruct) -> u32 {
context.0.inc_number();
x.get_number() + context.0.get_number()
};
其行为与closure3相同：
assert_eq!(func3(&mut ctx, &obj2), 26);
assert_eq!(func3(&mut ctx, &obj2), 27);
assert_eq!(func3(&mut ctx, &obj2), 28);
// We can't borrow obj1 mutably or immutably
// assert_eq!(obj1.get_number(), 18); // ERROR
// obj1.inc_number(); // ERROR
注意，我们必须把我们的上下文以可变引用的方式传递。这表明每次调用我们的函数后，可能会得到不同的结果。
当闭包以可变引用捕获它的上下文时，我们称它属于FnMut trait。
// Does not compile:
// is_fn(closure3);
// is_Fn(&closure3);
// Compiles successfully:
is_FnMut(&closure3);
is_FnOnce(&closure3);
拥有的上下文
在我们的最后一个例子中，我们将会获取obj1的所有权：
let obj1 = MyStruct::new("Hello", 15);
let obj2 = MyStruct::new("More Text", 10);
// obj1 is owned by the closure
let closure4 = |x: &MyStruct| {
obj1.destructor();
x.get_number()
};
我们必须在使用closure4之前检查它的类型：
// Does not compile:
// is_fn(closure4);
// is_Fn(&closure4);
// is_FnMut(&closure4);
// Compiles successfully:
is_FnOnce(&closure4);
现在我们可以检查它的行为：
assert_eq!(closure4(&obj2), 10);
// We can't call closure4 twice...
// assert_eq!(closure4(&obj2), 10); //ERROR
// We can't borrow obj1 mutably or immutably
// assert_eq!(obj1.get_number(), 15); // ERROR
// obj1.inc_number(); // ERROR
在这个例子中，我们只能调用这个函数一次。一旦我们对它进行了第一次调用，obj1就被我们销毁了， 所以它在第二次调用的时候也就不复存在了。Rust 会给我们一个关于使用一个已经被移动的值的错误。这就是为什么我们要事先检查其类型。
使用fn语法来实现，我们可以得到下面的代码：
struct Context(MyStruct);
let obj1 = MyStruct::new("Hello", 15);
let obj2 = MyStruct::new("More Text", 10);
let ctx = Context(obj1);
// obj1 is owned by the closure
fn func4 (context: Context, x: &MyStruct) -> u32 {
context.0.destructor();
x.get_number()
};
这段代码，正如我们所预期的，和我们的闭包行为一致：
assert_eq!(func4(ctx, &obj2), 10);
// We can't call func4 twice...
// assert_eq!(func4(ctx, &obj2), 10); //ERROR
// We can't borrow obj1 mutably or immutably
// assert_eq!(obj1.get_number(), 15); // ERROR
// obj1.inc_number(); // ERROR
当我们使用fn来写我们的闭包时，我们必须使用一个Context结构体并拥有它的值。当一个闭包拥有其上下文的所有权时，我们称它实现了FnOnce。我们只能调用这个函数一次，因为在调用之后，上下文就被销毁了。