在将字段移动到新变体时更改枚举变体

Question

我想更新枚举变体，同时将旧变体的字段移动到新变体而不进行任何克隆：

enum X {
    X1(String),
    X2(String),
}

fn increment_x(x: &mut X) {
    *x = match *x {
        X::X1(s) => X::X2(s),
        X::X2(s) => X::X1(s),
    }
}

这不起作用，因为我们无法将 s 从 &mut X 移动：

error[E0507]: cannot move out of borrowed content
 --> src/lib.rs:7:16
  |
7 |     *x = match *x {
  |                ^^
  |                |
  |                cannot move out of borrowed content
  |                help: consider removing the `*`: `x`
8 |         X::X1(s) => X::X2(s),
  |               - data moved here
9 |         X::X2(s) => X::X1(s),
  |               - ...and here

请不要提出诸如实现enum X { X1, X2 } 和使用struct S { variant: X, str: String } 等的建议。这是一个简化的示例，想象一下变体中有很多其他字段，并且想要将一个字段从一个变体移动到另一个。

Answer 1

在某些特定情况下，你想要的其实是std::rc

enum X {
    X1(Rc<String>),
    X2(Rc<String>),
}

fn increment_x(x: &mut X) -> X {
    match x {
        X::X1(s) => {x = X::X2(s.clone())},
        X::X2(s) => {x = X::X1(s.clone())},
    }
}

Answer 2

这不起作用，因为我们无法将 s 从 &mut X 移动。

那就不要那样做......按值获取结构并返回一个新的：

enum X {
    X1(String),
    X2(String),
}

fn increment_x(x: X) -> X {
    match x {
        X::X1(s) => X::X2(s),
        X::X2(s) => X::X1(s),
    }
}

最终，编译器会保护您，因为如果您可以将字符串移出枚举，那么它将处于某种半构造状态。如果函数在那一刻发生恐慌，谁来负责释放字符串？它应该释放枚举中的字符串还是局部变量中的字符串？不能两者兼得，因为双重释放是内存安全问题。

如果您不得不在可变引用上实现它，您可以在其中临时存储一个虚拟值：

use std::mem;

fn increment_x_inline(x: &mut X) {
    let old = mem::replace(x, X::X1(String::new()));
    *x = increment_x(old);
}

创建一个空的String 并不算太糟糕（它只是几个指针，没有堆分配），但这并不总是可能的。在这种情况下，您可以使用Option：

fn increment_x_inline(x: &mut Option<X>) {
    let old = x.take();
    *x = old.map(increment_x);
}

另见：

• How can I swap in a new value for a field in a mutable reference to a structure?
• Temporarily move out of borrowed content（特别是this answer）
• How do I move out of a struct field that is an Option?

Answer 3

如果您想在不以零成本方式摆脱价值的情况下做到这一点，则必须求助于一些不安全的代码 (AFAIK)：

use std::mem;

#[derive(Debug)]
enum X {
    X1(String),
    X2(String),
}

fn increment_x(x: &mut X) {
    let interim = unsafe { mem::uninitialized() };
    let prev = mem::replace(x, interim);
    let next = match prev {
        X::X1(s) => X::X2(s),
        X::X2(s) => X::X1(s),
    };
    let interim = mem::replace(x, next);
    mem::forget(interim); // Important! interim was never initialized
}