当旧的枚举被丢弃时，有没有办法从 &mut 枚举中提取值？ [复制]

Question

我想从模式匹配的可变引用中提取一个值并丢弃旧的。

这是我想出的一个最小的例子：

fn main() {
    #[derive(Debug)]
    enum D<A> {
        E1(A),
        E2(A, A),
    };

    trait Zero<A> {
        fn zero() -> A;
    }

    impl<A> D<A> {
        pub fn push2(&mut self, e: A) {
            match self {
                D::E1(e1) => {
                    *self = D::E2(*e1, e);
                }
                _ => unimplemented!(),
            }
        }

        pub fn push(&mut self, e: A)
        where
            A: Zero<A>,
        {
            match self {
                D::E1(e1) => {
                    let mut r = A::zero();
                    std::mem::swap(&mut r, e1);
                    *self = D::E2(e, r);
                }
                _ => unimplemented!(),
            };
        }
    }

    impl Zero<i32> for i32 {
        fn zero() -> i32 {
            0
        }
    }

    let mut d = D::E1(10);
    d.push(11);

    println!("{:?}", d);
}

playground

push2 失败：

error[E0507]: cannot move out of borrowed content
  --> src/main.rs:17:39
   |
17 |                         *self = D::E2(*e1, e);
   |                                       ^^^ cannot move out of borrowed content

我想在不需要 Copy 特征的情况下实现这一点，因为我在里面有一些盒装类型，理想情况下希望消除对虚拟变量 (A::zero()) 的需求。

Answer 1

如果我理解您的代码，A 将是一个数字，因为它实现了Zero。数值在 Rust 中实现 Copy，因此您可以利用它来发挥自己的优势：

pub fn push(&mut self, e: A)
where
    A: Zero<A> + Copy,
{
    match self {
        D::E1(e1) => *self = D::E2(e, *e1),
        _ => unimplemented!(),
    };
}

如果不想绑定Copy，可以按照建议使用std::mem::replace：

pub fn push(&mut self, e: A)
where
    A: Zero<A>,
{
    use std::mem::replace;
    match self {
        D::E1(e1) => *self = D::E2(e, replace(e1, A::zero())),
        _ => unimplemented!(),
    };
}

这是惯用的做法。

你需要虚拟元素，因为你不能这样做：

D::E1(e1) => *self = D::E2(e, *e1),

原因是编译器先对参数求值，*e1 试图取得借用数据的所有权，但这是被禁止的。