• 闭包的语法
    • 基本形式
    • 捕获变量
    • move闭包
      • 这部分引用自 The Rust Programming Language中文版

    闭包的语法

    基本形式

    闭包看起来像这样：

    1. let plus_one = |x: i32| x + 1;
    3. assert_eq!(2, plus_one(1));

    我们创建了一个绑定，plus_one，并把它赋予一个闭包。闭包的参数位于管道（|）之中，而闭包体是一个表达式，在这个例子中，x + 1。记住{}是一个表达式，所以我们也可以拥有包含多行的闭包：

    1. let plus_two = |x| {
    2.     let mut result: i32 = x;
    4.     result += 1;
    5.     result += 1;
    7.     result
    8. };
    10. assert_eq!(4, plus_two(2));

    你会注意到闭包的一些方面与用fn定义的常规函数有点不同。第一个是我们并不需要标明闭包接收和返回参数的类型。我们可以：

    1. let plus_one = |x: i32| -> i32 { x + 1 };
    3. assert_eq!(2, plus_one(1));

    不过我们并不需要这么写。为什么呢？基本上，这是出于“人体工程学”的原因。因为为命名函数指定全部类型有助于像文档和类型推断，而闭包的类型则很少有文档因为它们是匿名的，并且并不会产生像推断一个命名函数的类型这样的“远距离错误”。

    第二个的语法大同小异。我会增加空格来使它们看起来更像一点：

    1. fn  plus_one_v1   (x: i32) -> i32 { x + 1 }
    2. let plus_one_v2 = |x: i32| -> i32 { x + 1 };
    3. let plus_one_v3 = |x: i32|          x + 1  ;

    捕获变量

    之所以把它称为“闭包”是因为它们“包含在环境中”（close over their environment）。这看起来像：

    1. let num = 5;
    2. let plus_num = |x: i32| x + num;
    4. assert_eq!(10, plus_num(5));

    这个闭包，plus_num，引用了它作用域中的let绑定：num。更明确的说，它借用了绑定。如果我们做一些会与这个绑定冲突的事，我们会得到一个错误。比如这个：

    1. let mut num = 5;
    2. let plus_num = |x: i32| x + num;
    4. let y = &mut num;

    错误是：

    1. error: cannot borrow `num` as mutable because it is also borrowed as immutable
    2.     let y = &mut num;
    3.                  ^~~
    4. note: previous borrow of `num` occurs here due to use in closure; the immutable
    5.   borrow prevents subsequent moves or mutable borrows of `num` until the borrow
    6.   ends
    7.     let plus_num = |x| x + num;
    8.                    ^~~~~~~~~~~
    9. note: previous borrow ends here
    10. fn main() {
    11.     let mut num = 5;
    12.     let plus_num = |x| x + num;
    14.     let y = &mut num;
    15. }
    16. ^

    一个啰嗦但有用的错误信息！如它所说，我们不能取得一个num的可变借用因为闭包已经借用了它。如果我们让闭包离开作用域，我们可以：

    1. let mut num = 5;
    2. {
    3.     let plus_num = |x: i32| x + num;
    5. } // plus_num goes out of scope, borrow of num ends
    7. let y = &mut num;

    如果你的闭包需要它，Rust会取得所有权并移动环境：

    1. let nums = vec![1, 2, 3];
    3. let takes_nums = || nums;
    5. println!("{:?}", nums);

    这会给我们：

    1. note: `nums` moved into closure environment here because it has type
    2.   `[closure(()) -> collections::vec::Vec<i32>]`, which is non-copyable
    3. let takes_nums = || nums;
    4.                     ^~~~~~~

    Vec<T>拥有它内容的所有权，而且由于这个原因，当我们在闭包中引用它时，我们必须取得nums的所有权。这与我们传递nums给一个取得它所有权的函数一样。

    move闭包

    我们可以使用move关键字强制使我们的闭包取得它环境的所有权：

    1. let num = 5;
    3. let owns_num = move |x: i32| x + num;

    现在，即便关键字是move，变量遵循正常的移动语义。在这个例子中，5实现了Copy，所以owns_num取得一个5的拷贝的所有权。那么区别是什么呢？

    1. let mut num = 5;
    3. {
    4.     let mut add_num = |x: i32| num += x;
    6.     add_num(5);
    7. }
    9. assert_eq!(10, num);

    那么在这个例子中，我们的闭包取得了一个num的可变引用，然后接着我们调用了add_num，它改变了其中的值，正如我们期望的。我们也需要将add_num声明为mut，因为我们会改变它的环境。

    如果我们加上move修饰闭包，会发生些不同：

    1. let mut num = 5;
    3. {
    4.     let mut add_num = move |x: i32| num += x;
    6.     add_num(5);
    7. }
    9. assert_eq!(5, num);

    我们只会得到5。这次我们没有获取到外部的num的可变借用，我们实际上是把 num move 进了闭包。因为 num 具有 Copy 属性，因此发生 move 之后，以前的变量生命周期并未结束，还可以继续在 assert_eq! 中使用。我们打印的变量和闭包内的变量是独立的两个变量。如果我们捕获的环境变量不是 Copy 的，那么外部环境变量被 move 进闭包后，
    它就不能继续在原先的函数中使用了，只能在闭包内使用。

    不过在我们讨论获取或返回闭包之前，我们应该更多的了解一下闭包实现的方法。作为一个系统语言，Rust给予你了大量的控制你代码的能力，而闭包也是一样。

    这部分引用自The Rust Programming Language中文版