Rust 闭包的三张面孔:Fn、FnMut 与 FnOnce
同一个闭包,有时可以连续调用两次,有时第二次就编译失败;有时加个 move 就能塞进线程,有时加了仍然报错。问题不在 move 本身,而在于闭包如何使用外部变量,这决定了它最终实现 Fn、FnMut 还是 FnOnce。
先看捕获,再谈 trait
闭包不会先声明“我是 Fn”,编译器先看它如何使用外部变量,再倒推它实现了哪些 trait。默认情况下,能借就借:
1fn main() {
2 let mut v = vec![1, 2, 3];
3 let show = || println!("{v:?}");
4
5 v.push(4);
6 show();
7}这段代码编译失败:
1error[E0502]: cannot borrow `v` as mutable because it is also borrowed as immutableshow 持有 v 的不可变借用,而借用要持续到 show 最后一次被使用,也就是 show() 那一行。v.push(4) 在中间要求可变借用,冲突就发生了。非 Lexical Lifetime 会把借用缩短到最后一次使用,但不会短到“闭包定义完就结束”。
闭包捕获外部变量有三种方式:不可变借用、可变借用、按值获取。前两种由闭包体里的用法推断;当闭包需要拿走所有权时,也会按值捕获,move 的作用是强制所有用到的变量都按值捕获。
三个 trait,是三种调用权限
| Trait | 调用时需要的接收者 | 对捕获变量做了什么 | 结果 |
|---|---|---|---|
Fn | &self | 只读 | 可以反复调用 |
FnMut | &mut self | 可以修改,但不搬走 | 可以反复调用,调用者需要可变权限 |
FnOnce | self | 可能把值搬走 | 只能调用一次,调用会消耗闭包 |
三者是包含关系:Fn 是 FnMut 的子 trait,FnMut 又是 FnOnce 的子 trait。所以一个只读闭包既能传给要求 Fn 的参数,也能传给要求 FnMut 或 FnOnce 的参数;反过来不行。
move 改变的是捕获方式
很多人以为加了 move,闭包就变成 FnOnce。其实不是:
1let s = String::from("hello");
2let f = move || println!("{s}");
3
4f();
5f(); // 可以调用多次
6println!("{s}"); // error[E0382]: borrow of moved value: `s`闭包按值拿走了 s,所以外部不能再使用它。但闭包体里只是借用 s 来打印,调用时不需要修改或消耗它,因此这个闭包仍然实现 Fn。
如果捕获的是 Copy 类型,move 甚至只是复制:
1let n = 1;
2let f = move || n + 1;
3
4f();
5f();
6println!("{n}"); // 仍然可用记住一句话:move 决定变量怎么进闭包,不决定闭包能被调用几次。
什么时候真的变成 FnOnce
当闭包体把捕获的值搬出去时,它就只能实现 FnOnce:
1let s = String::from("hello");
2let take = move || s;
3
4let a = take();
5let b = take(); // error[E0382]: use of moved value: `take`第一次调用 take() 时,闭包本身被消耗,s 被移出;第二次调用时闭包已经没了。drop(s) 写在闭包里也是同样的效果,因为 drop 按值接收参数。
这也是 Iterator::map 常见的报错来源:
1let s = String::from("x");
2let out: Vec<String> = vec![1, 2]
3 .into_iter()
4 .map(move |_| s)
5 .collect();map 要求 FnMut,但这里的闭包第一次调用就把 s 移走了,只能实现 FnOnce,编译器会明确提示:
1expected a closure that implements the `FnMut` trait,
2but this closure only implements `FnOnce`修法不是去掉 move,而是让每次调用都产生一个新值,比如 move |_| s.clone()。
FnMut:能改,但调用者要先有 mut
1let mut count = 0;
2let mut next = || {
3 count += 1;
4 count
5};
6
7assert_eq!(next(), 1);
8assert_eq!(next(), 2);闭包持有 count 的可变借用,所以 next 绑定本身必须是 mut,否则报 cannot borrow next as mutable。在 next 还被使用期间,也不能从外部读写 count,否则又是一次借用冲突。
泛型函数里同样要注意:
1fn call_twice<F: FnMut() -> i32>(mut f: F) -> (i32, i32) {
2 (f(), f())
3}参数 f 若不加 mut,函数体里无法调用 FnMut 闭包。
返回闭包、开线程:move 出现的真正原因
返回一个捕获局部变量的闭包时,借用无法活过函数体,必须把值搬进闭包:
1fn make_adder(n: i32) -> impl Fn(i32) -> i32 {
2 move |x| x + n
3}线程也是同理。thread::spawn 要求闭包满足 FnOnce + Send + 'static:
1let s = String::from("hi");
2let handle = std::thread::spawn(move || println!("{s}"));
3
4handle.join().unwrap();不加 move,闭包借用局部变量 s,无法满足 'static。但要小心:move 只搬走变量本身,不延长变量内部引用的生命周期。下面这样仍然不行:
1let s = String::from("hi");
2let r = &s;
3
4std::thread::spawn(move || println!("{r}")); // 仍然报错搬进闭包的是 &s,它依旧指向当前栈帧。想让线程借用局部变量,应使用作用域线程:
1let s = String::from("hi");
2
3std::thread::scope(|scope| {
4 scope.spawn(|| println!("{s}"));
5});scope 会保证所有线程在离开作用域前结束,因此借用是安全的。
存进结构体:泛型还是 trait object
闭包的类型是编译器生成的匿名类型,写不出来,所以结构体字段通常有两种写法。
泛型写法没有额外分配,但每个闭包类型都会单态化出一份代码:
1struct Handler<F: FnMut(i32) -> i32> {
2 f: F,
3}
4
5impl<F: FnMut(i32) -> i32> Handler<F> {
6 fn run(&mut self, x: i32) -> i32 {
7 (self.f)(x)
8 }
9}需要在一个容器里放不同闭包时,用 trait object:
1struct Handler {
2 f: Box<dyn FnMut(i32) -> i32>,
3}调用 Box<dyn FnMut> 时仍然需要可变借用,所以方法接收者要写成 &mut self。
一张排查清单
- 报
expected FnMut, but this closure only implements FnOnce:闭包把捕获值移走了,改成借用、克隆,或调整调用模型。 - 报
closure may outlive the current function:闭包借用了局部变量,加move;如果捕获的是引用,考虑作用域线程或调整所有权。 - 报
cannot borrow ... as mutable:调用FnMut闭包需要mut绑定,或者闭包与外部访问发生了借用冲突。 - 报
use of moved value:调用了一个FnOnce闭包两次,闭包第一次调用后已经被消耗。 - 不确定闭包实现了什么:先看它是否修改捕获值,再看它是否把捕获值移出闭包体。只读是
Fn,修改是FnMut,移出是FnOnce。
闭包的 trait 并不神秘,它只是编译器对“你打算怎么使用捕获变量”给出的精确回答。
本文由 AI 辅助生成并经人工校验,如有疏漏欢迎指正。