闭包
闭包
Rust 不仅命名函数,还命名匿名函数。匿名函数有一个关联的环境被称为“闭包”,因为他们关闭了一个环境。如我们将会看到的,Rust 对它们有完美的实现。
语法
闭包看起来是这样的:
let plus_one = |x: i32| x + 1;
assert_eq!(2, plus_one(1));
我们创建一个绑定,plus_one 并将其分配给一个闭包。关闭管道之间的参数(|),并且主体是一个表达式,在本例中是 x + 1。记住{ }也是一个表达式,所以我们可以多行的闭包:
let plus_two = |x| {
let mut result: i32 = x;
result += 1;
result += 1;
result
};
assert_eq!(4, plus_two(2));
你会注意到闭包与用 fn 定义的普通函数略有不同。第一个不同点是,我们不需要对参数的类型和返回值进行注释。我们可以:
let plus_one = |x: i32| -> i32 { x + 1 };
assert_eq!(2, plus_one(1));
但我们并不需要这样做。这是为什么呢?根本上来说,这是出于人体工程学的考虑。对于文档和类型推断而言,指定已命名函数的完整类型命名是有用的,然而闭包的类型很少被记录因为他们是匿名的,而且他们不会引 error-at-a-distance 错误,这种错误能够推断命名函数的类型。
第二,语法是相似的,但有点不同。我在这里添加空格让他们看起来更接近:
ffn plus_one_v1 (x: i32 ) -> i32 { x + 1 }
let plus_one_v2 = |x: i32 | -> i32 { x + 1 };
let plus_one_v3 = |x: i32 | x + 1 ;
差异很小,但它们类似。
闭包和他们的环境
闭包之所以被称为闭包,是因为他们封闭了他们的环境。它看起来像这样:
let num = 5;
let plus_num = |x: i32| x + num;
assert_eq!(10, plus_num(5));
plus_num,这个闭包指的是一个 let 绑定在它的范围 num 内。更具体地说,它借用了绑定。如果我们做与绑定相冲突的事情,就会得到一个错误。像下面这样:
let mut num = 5;
let plus_num = |x: i32| x + num;
let y = &mut num;
错误如下:
error: cannot borrow `num` as mutable because it is also borrowed as immutable
let y = &mut num;
^~~
note: previous borrow of `num` occurs here due to use in closure; the immutable
borrow prevents subsequent moves or mutable borrows of `num` until the borrow
ends
let plus_num = |x| x + num;
^~~~~~~~~~~
note: previous borrow ends here
fn main() {
let mut num = 5;
let plus_num = |x| x + num;
let y = &mut num;
}
^
这里的错误信息虽然冗长却是有用的!比如说,我们不能对 num 进行一个可变的 borrow,因为闭包已经 borrow 过它了。如果我们让闭包超出范围,我们可以:
let mut num = 5;
{
let plus_num = |x: i32| x + num;
} // plus_num goes out of scope, borrow of num ends
let y = &mut num;
如果你的闭包需要它,Rust 将获取所有权并且移动环境:
let nums = vec![1, 2, 3];
let takes_nums = || nums;
println!("{:?}", nums);
这告诉我们:
note: `nums` moved into closure environment here because it has type
`[closure(()) -> collections::vec::Vec<i32>]`, which is non-copyable
let takes_nums = || nums;
^~~~~~~
Vec < T >
对其内容拥有所有权,因此,当我们在闭包的操作涉及到它时,我们将不得不声称对 num 的所有权。同样的,如果我们将 num 传递给一个函数,则这个函数对其拥有所有权。
移动闭包
我们可以强制我们的闭包用 move 关键字获取环境移所有权:
let num = 5;
let owns_num = move |x: i32| x + num;
现在,即使关键字是 move,变量仍然遵循正常 move语义。在这种情况下,5 实现复制,所以 owns_num 持有 num 的副本。然而区别在哪里呢?
let mut num = 5;
{
let mut add_num = |x: i32| num += x;
add_num(5);
}
assert_eq!(10, num);
所以在这种情况下,我们的闭包获得了一个可变 num,我们称为 add_num, 如我们所期望的,它改变了 num 的潜在值。我们还需要将 add_nu m声明为 mut,因为我们正在改变其环境。
如果我们换成一个 move 闭包,就会出现不同:
let mut num = 5;
{
let mut add_num = move |x: i32| num += x;
add_num(5);
}
assert_eq!(5, num);
我们只得到 5。而不是从 num 得到可变的 borrow 我们对副本拥有所有权。
另一种方式思考 mov e闭包:他们分配给闭包一个自己的堆栈帧。没有 move 一个闭包可能与创建它的堆栈帧联系到一起,而且闭包是自包含的。这意味着你不能从函数返回一个 non-move 闭包。
但在我们讨论使用和返回闭包并之前,我们应该更多的讨论闭包的实现方式。作为一种系统语言、Rust 让你能够控制代码所做的事情,而闭包是没有什么不同的。
闭包实现
Rust 的闭包实现有点不同于其他语言。对特征来说他们是非常高效的语言。你要确保阅读这一章之前已经阅读了特征这一章,以及特征对象这一章。
都明白了吗?很棒。
闭包工作的关键点有些奇怪:使用()调用一个函数,就像 foo() 是一种可重载操作符。由此,在其他的任何地方单击鼠标都能进入空间。在 Rust 语言里面,我们使用特征系统重载操作符。调用函数也不例外。我们有三个独立的过载与特征:
pub trait Fn<Args> : FnMut<Args> {
extern "rust-call" fn call(&self, args: Args) -> Self::Output;
}
pub trait FnMut<Args> : FnOnce<Args> {
extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output;
}
pub trait FnOnce<Args> {
type Output;
extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
}
你会注意到这些特征之间的差异,但很大的一个点是 self:Fn 和 &self,FnMut 和 &mut self,FnOnce 和 self。这通过常用的方法调用语法涵盖了所有三种 self。但是我们把他们分成三个特征,而不是一个。这给了我们足够的控制权去决定我们可以采用什么样的闭包。
对闭包的| | { }语法对这三个特征来说是糖衣语法。Rus t将为环境生成一个 struct, impl 适当的特征,然后使用它。
使用闭包作为参数
现在我们知道,闭包特征,我们已经知道如何接受和返回闭包:就像任何其他特征那样!
这也意味着我们可以选择静态与动态调度。首先,让我们写一个可以调用其他函数的函数,调用它,并返回结果:
fn call_with_one<F>(some_closure: F) -> i32
where F : Fn(i32) -> i32 {
some_closure(1)
}
let answer = call_with_one(|x| x + 2);
assert_eq!(3, answer);
我们通过闭包,| | x + 2
去调用 call_with_one。它只是做它所表明的事情:它调用闭包,1 作为参数。
让我们更深入地检查 call_with_one 的签名:
fn call_with_one < F >(some_closure:F)- >i32
我们需要一个参数,它的类型为 F .我们也返回一个 i32。这部分不是很有趣。下一个部分是:
where F : Fn(i32) -> i32 {
因为 Fn 是一个特征,我们可以将我们的泛型和它绑定到一起。在这种情况下,我们的闭包需要把 i32 作为参数,并返回一个 i32 所以我们使用的泛型边界是 Fn(i32) -> i32
。
这里还有一个关键问题:因为我们吧泛型和特征绑定到了一起,这将导致单形态,因此,我们将在闭包里面做静态调度。那是就清晰多了。在许多语言中,闭包本身就是堆分配,总是涉及到动态调度。在 Rust 语言中,我们可以用堆栈分配我们的闭包环境,和静态调度 call 语句。这种情况通常发生于迭代器和适配器,通常采用闭包作为参数。
当然,如果我们想要动态调度,我们也可以那样。特征对象处理这种情况时,像往常一样:
fn call_with_one(some_closure: &Fn(i32) -> i32) -> i32 {
some_closure(1)
}
let answer = call_with_one(&|x| x + 2);
assert_eq!(3, answer);
现在我们把一个特征对象,&Fn
。当我们传递这个特征到 call_with_one 时我们必须参考我们的闭包,所以我们使用 & | |
。
返回闭包
在各种情况下,返回闭包是很常见的函数形式。如果你想返回一个闭包,您可能会遇到一个错误。起初,这看起来可能有些奇怪,但是我们会找到答案。你可以试着从下面的函数返回一个闭包:
fn factory() -> (Fn(i32) -> Vec<i32>) {
let vec = vec![1, 2, 3];
|n| vec.push(n)
}
let f = factory();
let answer = f(4);
assert_eq!(vec![1, 2, 3, 4], answer);
error: the trait `core::marker::Sized` is not implemented for the type
`core::ops::Fn(i32) -> collections::vec::Vec<i32>` [E0277]
f = factory();
^
note: `core::ops::Fn(i32) -> collections::vec::Vec<i32>` does not have a
constant size known at compile-time
f = factory();
^
error: the trait `core::marker::Sized` is not implemented for the type
`core::ops::Fn(i32) -> collections::vec::Vec<i32>` [E0277]
factory() -> (Fn(i32) -> Vec<i32>) {
^~~~~~~~~~~~~~~~~~~~~
note: `core::ops::Fn(i32) -> collections::vec::Vec<i32>` does not have a constant size known at compile-time
fa ctory() -> (Fn(i32) -> Vec<i32>) {
^~~~~~~~~~~~~~~~~~~~~
为了从一个函数返回一些东西,Rust 需要知道返回类型的大小。但由于 Fn 是一个特征,它可能具有是各种不同大小的 size :
许多不同的类型都可以实现 Fn。来给一些事物赋予 siz e的一种简单的方法是参考已知的 size。所以如下面我们写的这样:
fn factory() -> &(Fn(i32) -> Vec<i32>) {
let vec = vec![1, 2, 3];
|n| vec.push(n)
}
let f = factory();
let answer = f(4);
assert_eq!(vec![1, 2, 3, 4], answer);
但我们得到了另一个错误:
error: missing lifetime specifier [E0106]
fn factory() -> &(Fn(i32) -> i32) {
^~~~~~~~~~~~~~~~~
正确的。因为我们有一个参考,我们需要给它指定生命周期。但是我们的 factory() 函数不带参数,所以此处省略不写。我们可以选择什么样的生命周期呢?静态:
fn factory() -> &'static (Fn(i32) -> i32) {
let num = 5;
|x| x + num
}
let f = factory();
let answer = f(1);
assert_eq!(6, answer);
但我们得到另一个错误:
error: mismatched types:
expected `&'static core::ops::Fn(i32) -> i32`,
found `[closure <anon>:7:9: 7:20]`
(expected &-ptr,
found closure) [E0308]
|x| x + num
^~~~~~~~~~~
这个错误是让我们知道,我们没有 &'static Fn(i32) -> i32
但是我们有一个[closure <anon>:7:9: 7:20]
。等等,这是什么?
因为每个闭包生成自己的环境结构和实现 Fn 特征以及 friends 这些都是匿名的。它们的存在只是因为这个闭包。Rust 把他们显示为 closure <anon>
而不是一些自动生成的名字。
但是为什么我们的闭包不实现 &'static Fn
?正如我们之前讨论的,闭包 borrow 了他们的环境。在这种情况下,我们的环境是基于 5 栈分配以及num 变量绑定。因此,borrow 的生命周期为的堆栈帧长度。所以如果我们返回这个闭包,函数调用将结束,堆栈框架将消失,并且我们的闭包将对垃圾内存的环境进行捕获!
那么该怎么办?这就是工作原理:
fn factory() -> Box<Fn(i32) -> i32> {
let num = 5;
Box::new(|x| x + num)
}
let f = factory();
let answer = f(1);
assert_eq!(6, answer);
我们使用一个特征对象,通过建立 Fn。只有最后一个问题:
error: `num` does not live long enough
Box::new(|x| x + num)
^~~~~~~~~~~
我们仍然有一个对父堆栈帧的引用。通过最后一次修复,我们这样做可以做可以行得通:
fn factory() -> Box<Fn(i32) -> i32> {
let num = 5;
Box::new(move |x| x + num)
}
let f = factory();
let answer = f(1);
assert_eq!(6, answer);
通过内部 move Fn,我们可以为我们的闭包创建一个新的堆栈帧。我们给它一个已知大小,并对它进行填充,而且允许他脱离我们的堆栈帧。
更多建议: