Rust：更新枚举变体数据时如何避免双重可变引用冲突？

给定以下Rust 1.74.1代码结构：

struct DataA {
    a: i32
}

struct DataB {
    b: i32
}

enum Data {
    TypeA(DataA),
    TypeB(DataB),
    // 其他变体如TypeC等
}

struct Struct {
    field: i32,
    // 其他字段
    data: Data,
}

impl Struct {
    fn foo(&mut self) -> i32 {
        self.field += 5;
        5
    }
}

需求是为Struct实现bar方法：仅当data为TypeA(DataA)变体时，将DataA的a字段设为foo()的返回值；非TypeA时不做任何操作。

最初的错误写法 #

尝试直接匹配可变引用时，会触发可变借用冲突：

fn bar(&mut self) {
    let Data::TypeA(data) = &mut self.data else {
        return;
    };
    data.a = self.foo(); // 报错：cannot borrow `*self` as mutable more than once at a time
}

原因是&mut self.data已经对self进行了可变借用，而调用self.foo()需要再次获取&mut self，违反了Rust的借用规则。

可行但繁琐的写法 #

通过重新构造TypeA变体可以运行，但维护成本高（DataA新增字段时需要同步修改构造代码）：

fn bar(&mut self) {
    let Data::TypeA(..) = self.data else {
        return;
    };
    self.data = Data::TypeA(DataA{ a: self.foo() });
}

更优的实现方式 #

利用std::mem::take（或std::mem::replace）临时取出data，避免同时借用整个self，这是更符合Rust惯用风格的写法：

方案1：为Data实现Default #

use std::mem;

// 为Data枚举实现Default，作为临时占位值
impl Default for Data {
    fn default() -> Self {
        Data::TypeB(DataB { b: 0 })
    }
}

impl Struct {
    fn bar(&mut self) {
        // 临时取出self.data，此时self的data字段被替换为Default值
        let mut data = mem::take(&mut self.data);
        if let Data::TypeA(ref mut inner) = data {
            // 此时调用self.foo()仅借用self的其他字段，与data无冲突
            inner.a = self.foo();
        }
        // 将修改后的data放回self
        self.data = data;
    }
}

方案2：用mem::replace指定临时占位变体 #

如果不想为Data实现Default，可以直接指定一个临时变体作为占位：

use std::mem;

impl Struct {
    fn bar(&mut self) {
        // 用TypeB临时替换self.data，后续会放回原data
        let mut data = mem::replace(&mut self.data, Data::TypeB(DataB { b: 0 }));
        if let Data::TypeA(ref mut inner) = data {
            inner.a = self.foo();
        }
        self.data = data;
    }
}

这种写法既避免了借用冲突，又无需在DataA字段变更时修改bar方法，维护成本低且符合Rust的内存安全设计思路。

备选思路：拆分借用（仅适合简单场景） #

如果不想使用内存操作，可手动拆分foo的逻辑，避免借用整个self，但会增加代码耦合性：

impl Struct {
    fn bar(&mut self) {
        if let Data::TypeA(inner) = &mut self.data {
            // 内联foo的逻辑，直接修改field并赋值给a
            self.field += 5;
            inner.a = 5;
        }
    }
}

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