为何Rust为闭包推断FnMut而非FnOnce，进而引发编译错误？

问题复现 #

尝试编译以下Rust代码：

fn main() {
    fn id(x: &mut u8) -> &mut u8 { x }
    let x = &mut 0_u8;
    let f = move || id(x);
}

会触发编译错误：

error: captured variable cannot escape `FnMut` closure body
 --> main.rs:4:21
  |
4 |     let f = move || id(x);
  |                   - ^^^^^ returns a reference to a captured variable which escapes the closure body
  |                   |
  |                   inferred to be a `FnMut` closure
  |
  = note: `FnMut` closures only have access to their captured variables while they are executing...
  = note: ...therefore, they cannot allow references to captured variables to escape

但如果强制将闭包f推断为FnOnce而非FnMut，代码即可正常编译：

fn main() {
    fn id(x: &mut u8) -> &mut u8 { x }
    let x = &mut 0_u8;
    fn force_fn_once<F: FnOnce() -> R, R>(f: F) -> F { f }
    let f = force_fn_once(move || id(x));
}

核心问题 #

• 为何Rust编译器会为f推断FnMut（引发错误），而非自动推断FnOnce以避免错误？
• 有没有更优的方法强制编译器推断FnOnce？

问题解答 #

1. 编译器默认推断FnMut的原因 #

Rust闭包的 trait 推断遵循最大化可用性原则：编译器会优先尝试为闭包实现最通用的 trait，优先级顺序为 Fn > FnMut > FnOnce。这是因为：

• Fn最灵活，允许闭包被多次调用且仅不可变访问捕获变量；
• FnMut允许可变访问捕获变量，同样支持多次调用；
• FnOnce只能被调用一次，调用时会消耗捕获的变量，灵活性最低。

在第一个示例中，编译器首先尝试推断Fn，但闭包返回了对捕获可变变量的引用，不符合Fn的约束；接着尝试FnMut，此时发现闭包返回的引用会逃逸出闭包的执行周期——FnMut闭包的捕获变量仅在闭包执行期间可被安全访问，返回引用会导致变量在闭包外部被引用，违反内存安全规则，因此报错。

编译器不会自动降级到FnOnce，因为这违背了"最大化可用性"的设计逻辑：如果直接推断FnOnce，虽然能编译，但会强制限制闭包的使用场景（只能调用一次），而编译器默认会优先尝试更通用的实现，只有当更通用的实现完全不可行时才会考虑降级。

2. 更优的强制FnOnce的方法 #

除了自定义force_fn_once函数，还有两种更简洁的方案：

方案一：显式标注闭包类型

直接为变量f指定impl FnOnce() -> &mut u8类型，明确告诉编译器闭包的 trait 约束：

fn main() {
    fn id(x: &mut u8) -> &mut u8 { x }
    let x = &mut 0_u8;
    let f: impl FnOnce() -> &mut u8 = move || id(x);
}

方案二：使用 trait 对象（需要动态分发时）

如果需要动态分发，可以将闭包包装为Box<dyn FnOnce() -> &mut u8>：

use std::ops::FnOnce;

fn main() {
    fn id(x: &mut u8) -> &mut u8 { x }
    let x = &mut 0_u8;
    let f: Box<dyn FnOnce() -> &mut u8> = Box::new(move || id(x));
}

其中，显式标注impl FnOnce()是最推荐的方案，既清晰直观，又不会带来额外的性能开销。

内容的提问来源于stack exchange，提问作者pycache