Rust中替换结构体state属性时，如何合法转移旧属性的字段？

我实现了一个处理DLE/STX/ETX+CRC32帧的串口协议解码器，核心代码如下：

#[derive(Debug, PartialEq, Eq)]
enum State {
    WAIT_DLE,
    WAIT_STX,
    WAIT_DLE_OR_BYTE { payload: Vec<u8> },
    WAIT_DLE_OR_ETX { payload: Vec<u8> },
    WAIT_CRC { payload: Vec<u8>, crc: u32, remaining: usize },
}

#[derive(Debug, PartialEq, Eq)]
struct Decoder {
    state: State,
    decoded: u64,
    unstuffing_errors: u64,
    crc_errors: u64
}

impl Decoder {
    fn new() -> Decoder {
        Decoder { 
            state: State::WAIT_DLE,
            decoded: 0,
            unstuffing_errors: 0,
            crc_errors: 0,
        }
    }

    fn decode_byte(&mut self, byte: u8) -> Option<Vec<u8>> {
        self.state = match self.state {
            State::WAIT_DLE => match byte {
                DLE => State::WAIT_STX,
                _ => State::WAIT_DLE
            },
            State::WAIT_STX => match byte {
                STX => State::WAIT_DLE_OR_BYTE { payload: Vec::<u8>::new() },
                _ => State::WAIT_DLE
            },
            State::WAIT_DLE_OR_BYTE { mut payload } => match byte {
                DLE => State::WAIT_DLE_OR_ETX { payload },
                b => {
                    payload.push(b);
                    State::WAIT_DLE_OR_BYTE { payload }
                }
            },
            // 省略剩余状态分支
            ...
        }
    }
}

编译时遇到了所有权转移的错误：

error[E0507]: cannot move out of `self.state.payload` as enum variant `WAIT_CRC` which is behind a mutable reference
  --> common/src/dlecrc32.rs:46:28
   |
46 |         self.state = match self.state {
   |                            ^^^^^^^^^^ help: consider borrowing here: `&self.state`
...
55 |             State::WAIT_DLE_OR_BYTE { mut payload } => match byte {
   |                                       ----------- data moved here
...
62 |             State::WAIT_DLE_OR_ETX { mut payload } => match byte {
   |                                      ----------- ...and here
...
73 |             State::WAIT_CRC { payload, mut crc, remaining } => {
   |                               ------- ...and here
   |
   = note: move occurs because these variables have types that don't implement the `Copy` trait

编译器建议用&self.state匹配，但这无法满足需求——很多分支需要将旧状态中的payload: Vec<u8>转移到新状态，复制向量内容完全是浪费（旧状态会被立即覆盖销毁）。

我试过用mem::swap临时替换状态来规避这个问题：

fn decode_byte(&mut self, byte: u8) -> Option<Vec<u8>> {
    let mut swapped_state = State::WAIT_DLE;
    mem::swap(&mut self.state, &mut swapped_state);

    self.state = match swapped_state {
        // 处理逻辑
        ...
    }
}

但这种方法会复制self.state的字节，带来不必要的开销。另一种方案是把State的所有字段移到Decoder结构体中，将State改为无关联数据的C风格枚举，但这会破坏现有代码结构。

有没有办法让编译器理解：我即将给self.state赋值，因此可以安全地拆解旧的self.state？

最优解决方案：使用std::mem::take #

std::mem::take可以取出self.state的当前值，同时用该类型的默认值填充原位置。对于你的State枚举，WAIT_DLE是无关联数据的变体，作为默认值几乎没有开销，比mem::swap更高效：

use std::mem;

impl Decoder {
    // 保留new()方法...

    fn decode_byte(&mut self, byte: u8) -> Option<Vec<u8>> {
        // 取出旧状态，用默认值填充self.state
        let old_state = mem::take(&mut self.state);
        
        self.state = match old_state {
            State::WAIT_DLE => match byte {
                DLE => State::WAIT_STX,
                _ => State::WAIT_DLE
            },
            State::WAIT_STX => match byte {
                STX => State::WAIT_DLE_OR_BYTE { payload: Vec::new() },
                _ => State::WAIT_DLE
            },
            State::WAIT_DLE_OR_BYTE { mut payload } => match byte {
                DLE => State::WAIT_DLE_OR_ETX { payload },
                b => {
                    payload.push(b);
                    State::WAIT_DLE_OR_BYTE { payload }
                }
            },
            State::WAIT_DLE_OR_ETX { mut payload } => match byte {
                DLE => State::WAIT_DLE_OR_BYTE { payload },
                ETX => State::WAIT_CRC { payload, crc: 0, remaining: 4 },
                _ => {
                    self.unstuffing_errors += 1;
                    State::WAIT_DLE
                }
            },
            State::WAIT_CRC { mut payload, mut crc, remaining } => {
                crc = (crc << 8) | byte as u32;
                if remaining == 1 {
                    // 这里替换为实际的CRC校验逻辑
                    if crc == 0x12345678 {
                        self.decoded += 1;
                        // 校验通过，返回完整payload
                        self.state = State::WAIT_DLE;
                        return Some(payload);
                    } else {
                        self.crc_errors += 1;
                        State::WAIT_DLE
                    }
                } else {
                    State::WAIT_CRC { payload, crc, remaining: remaining - 1 }
                }
            }
        };
        
        None
    }
}

为什么这个方案可行？ #

1. 安全的所有权转移：mem::take确保在取出旧状态后，self.state立即被默认值填充，即使match过程中发生panic，self始终处于有效状态。
2. 零额外开销：所有payload的转移都是所有权移动，没有向量复制或内存分配的额外开销。
3. 代码结构不变：不需要重构State的设计，保持原有状态机的清晰逻辑。

可选：自定义默认状态 #

如果你的State默认值不是WAIT_DLE，可以手动实现Default trait来指定：

impl Default for State {
    fn default() -> Self {
        State::WAIT_DLE
    }
}

这样mem::take会自动使用这个默认值，无需额外配置。

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