Хорошо, я понял, как это сделать с небольшим количеством unsafe ness и std::mem.

Я заменяю self неинициализированным временным значением. Поскольку я теперь «владею» тем, что раньше было self, я могу смело вывести его из него и заменить его:

use std::mem;

enum Foo<T> {
    Bar(T),
    Baz(T),
}

impl<T> Foo<T> {
    fn switch(&mut self) {
        // This is safe since we will overwrite it without ever reading it.
        let tmp = mem::replace(self, unsafe { mem::uninitialized() });
        // We absolutely must **never** panic while the uninitialized value is around!

        let new = match tmp {
            Foo::Bar(val) => Foo::Baz(val),
            Foo::Baz(val) => Foo::Bar(val),
        };

        let uninitialized = mem::replace(self, new);
        mem::forget(uninitialized);
    }
}

fn main() {}

Вышеприведенный код не работает, и понятно, что перемещение значения из self нарушает целостность.

Это не совсем то, что здесь происходит. Например, то же самое с self будет работать красиво:

impl<T> Foo<T> {
    fn switch(self) {
        self = match self {
            Foo::Bar(val) => Foo::Baz(val),
            Foo::Baz(val) => Foo::Bar(val),
        }
    }
}

Ржавчина абсолютно прекрасна с частичным и полным ходом. Проблема здесь в том, что вы не владеете значением, которое вы пытаетесь переместить - у вас есть только изменяемая заимствованная ссылка. Вы не можете отойти от каких-либо ссылок, в том числе изменчивых.

Это на самом деле одна из часто запрашиваемых функций - особый вид ссылки, который позволил бы выйти из него. Это позволило бы использовать несколько видов полезных шаблонов. Здесь вы можете найти здесь здесь и . .

Тем временем для некоторых случаев вы можете использовать std::mem::replace и std::mem::swap . Эти функции позволяют «взять» значение из изменяемой ссылки, если вы дадите что-то взамен.