Rust闭包为何持续持有可变引用？解析其设计逻辑

你遇到的问题本质是Rust闭包的捕获机制和函数参数传递的核心差异。先明确代码编译报错的核心原因：当你定义let mut borrows_mutably_closure = || list.push(5);时，闭包会直接捕获list的可变引用，并且这个引用会被闭包实例一直持有，直到闭包本身被销毁——这就导致后续的println!尝试不可变借用list时，违反了Rust的借用规则（同一时间不能有可变引用和不可变引用共存），更别说第二次调用闭包了。

而函数borrows_mutably_func每次调用时，都是临时创建一个&mut list的可变引用，这个引用的生命周期只限于函数执行期间，调用结束后引用就被释放，所以后续可以再次创建新的可变引用，也能执行println!的不可变借用。

为什么Rust要这么设计闭包的捕获逻辑？ #

• 闭包的「状态性」是核心：闭包的本质是带状态的匿名函数，它需要保留捕获的环境变量，以便在任意后续时间被调用。如果让闭包每次调用时才临时获取引用，那两次调用之间，list可能被其他代码修改、移动甚至销毁——比如如果在两次闭包调用之间，你把list移动到另一个作用域，那闭包再次调用时就会引用一个已经失效的变量，这完全违背了Rust的内存安全原则。
• 借用规则的静态验证要求：Rust的借用规则是靠编译器静态验证的，它需要明确知道每个引用的生命周期。如果闭包允许动态释放和重新获取引用，编译器就无法静态跟踪闭包调用的时机，也就无法保证两次调用之间没有其他非法的借用操作。而函数的调用是显式的，每次调用的借用范围清晰，编译器可以轻松验证安全性。
• 简化编译器实现，避免歧义：如果闭包的引用捕获逻辑设计成动态的，会极大增加编译器的复杂度，还可能引入行为歧义——比如闭包是否应该在每次调用前检查环境的可用性？这会带来运行时开销，也不符合Rust零成本抽象的设计目标。

怎么让闭包实现类似函数的重复调用行为？ #

如果你希望闭包能像函数一样，每次调用才临时获取引用，可以把list作为参数传给闭包：

fn borrows_mutably_func(list: &mut Vec<i32>) {
    list.push(4);
}

fn main() {
    let mut list = vec![1, 2, 3];
    println!("Before defining: {:?}", list);

    borrows_mutably_func(&mut list);
    println!("After calling first (func): {:?}", list);
    borrows_mutably_func(&mut list);
    println!("After calling second (func): {:?}", list);

    // 修改闭包，让它接收可变引用参数
    let borrows_mutably_closure = |list: &mut Vec<i32>| list.push(5);
    
    borrows_mutably_closure(&mut list);
    println!("After calling first (closure): {:?}", list);
    borrows_mutably_closure(&mut list);
    println!("After calling second (closure): {:?}", list);
}

或者如果必须让闭包捕获环境而不是传参，可以使用内部可变性（比如RefCell），通过运行时检查来绕过静态借用规则：

use std::cell::RefCell;

fn main() {
    let list = RefCell::new(vec![1, 2, 3]);
    println!("Before defining: {:?}", list.borrow());

    let mut borrows_mutably_closure = || list.borrow_mut().push(5);
    
    borrows_mutably_closure();
    println!("After calling first (closure): {:?}", list.borrow());
    borrows_mutably_closure();
    println!("After calling second (closure): {:?}", list.borrow());
}

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