如何修复Rust中`previous closure requires unique access`错误

方案1：重构资源管理逻辑（推荐，符合Rust idiomatic） #

核心思路是放弃给每个单独资源绑定携带s可变借用的守卫，改为统一收集所有已创建的待清理资源，最后根据操作结果决定是保留资源还是批量清理，完全避免借用重叠。
代码示例：

use scopeguard::{guard, ScopeGuard};

struct S; // 来自第三方crate，不可克隆

impl S {
    fn free(&mut self, _: u32) {}
}

fn bar(_: &mut S) -> Result<(), ()> {
    Err(())
}

fn test(s: &mut S) -> Result<u32, ()> {
    // 用闭包封装所有可能失败的业务逻辑
    let op_result = (|| -> Result<u32, Vec<u32>> {
        let mut created_resources = Vec::new();

        // 业务步骤1：创建对象
        let i = 10u32;
        created_resources.push(i);

        // 业务步骤2：调用可能失败的接口
        bar(s).map_err(|_| created_resources)?;

        // 后续同类业务流程直接复用这个模式：
        // 1. 创建新对象，push到created_resources
        // 2. 调用可能失败的接口，出错时返回created_resources
        // 所有步骤失败都会把已经创建的资源带回外层处理

        // 全部操作成功，返回最终需要的对象
        Ok(i)
    })();

    match op_result {
        Ok(res) => Ok(res),
        Err(to_free) => {
            // 批量清理所有已创建的资源
            for i in to_free {
                s.free(i);
            }
            Err(())
        }
    }
}

fn main() {
    let mut s = S {};
    let _ = test(&mut s);
}

这个方案无额外运行时开销、无unsafe、逻辑清晰，所有资源的生命周期和清理规则都显式可控。

方案2：用内部可变性绕开编译期借用检查（低改造成本） #

如果业务流程已经很复杂，重构成本过高，可以通过RefCell把对s的可变借用检查从编译期推迟到运行期，你的场景下守卫的闭包仅在失败返回/函数结束时才会执行，此时中间操作对s的借用已经释放，不会出现运行时借用冲突。
代码示例：

use std::cell::RefCell;
use scopeguard::{guard, ScopeGuard};

struct S; // 来自第三方crate，不可克隆

impl S {
    fn free(&mut self, _: u32) {}
}

fn bar(_: &mut S) -> Result<(), ()> {
    Err(())
}

// 入参改为RefCell包裹的S
fn test(s: &RefCell<S>) -> Result<u32, ()> {
    let i = 10u32;

    // 守卫闭包仅捕获RefCell的不可变引用，不会产生编译期借用冲突
    let sg = guard(i, |i| {
        s.borrow_mut().free(i);
    });
    
    // 调用bar时临时获取S的可变借用，调用完成后立即释放
    let _ = bar(&mut s.borrow_mut())?;

    Ok(ScopeGuard::into_inner(sg))
}

fn main() {
    let s = RefCell::new(S {});
    let _ = test(&s);
}

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