如何在Rust中修改结构体成员枚举变体并转移关联值？

问题背景 #

我正在Rust中实现一个音频播放状态机。Playback结构体用于存储文件以及播放状态（播放/暂停/停止），其中播放/暂停状态会保存播放进度。当前代码如下：

struct PlaybackProgress {
    playback_position: f32,
    stream_id: usize
}

enum PlaybackState {
    Stopped,
    Playing(PlaybackProgress),
    Paused(PlaybackProgress)
}

struct Playback {
    file: Option<String>,
    state: PlaybackState,
}

impl Playback {
    // 创建一个空的Playback实例（无文件，停止状态）
    pub fn new() -> Self {
        Playback {
            file: None,
            state: PlaybackState::Stopped
        }
    }

    pub fn play(&mut self, file: String) -> bool {
        match &self.state {
            PlaybackState::Playing(_) => {
                false
            }
            PlaybackState::Paused(progress) => {
                self.state = PlaybackState::Playing(progress); // 此处类型不匹配报错
                true
            }
            PlaybackState::Stopped => {
                self.file = Some(file);
                self.state = PlaybackState::Playing(PlaybackProgress { 
                    playback_position: 0.0, 
                    stream_id: 1 
                });
                true
            }
        }
    }
}

核心问题 #

将Paused变体转换为Playing变体时需要保留相同的进度。尝试直接match self.state时，编译器不允许转移progress的所有权；改用引用式匹配match &self.state则会出现引用值与目标类型不匹配的问题。

解决方案 #

以下是几种简洁可读的实现方式：

方法1：用std::mem::replace转移所有权 #

mem::replace可以先将当前状态临时替换为一个占位值（比如Stopped），同时获取原状态的所有权，这样就能自由拆解原状态并重新构造新状态：

use std::mem;

impl Playback {
    pub fn play(&mut self, file: String) -> bool {
        // 临时替换状态，拿到原状态的所有权
        let current_state = mem::replace(&mut self.state, PlaybackState::Stopped);
        match current_state {
            PlaybackState::Playing(old_state) => {
                // 状态不变，把原状态放回去
                self.state = PlaybackState::Playing(old_state);
                false
            }
            PlaybackState::Paused(progress) => {
                self.state = PlaybackState::Playing(progress);
                true
            }
            PlaybackState::Stopped => {
                self.file = Some(file);
                self.state = PlaybackState::Playing(PlaybackProgress { 
                    playback_position: 0.0, 
                    stream_id: 1 
                });
                true
            }
        }
    }
}

方法2：直接match所有权配合临时替换 #

Rust允许直接获取self.state的所有权进行匹配，只要每个分支都确保给self.state重新赋值，编译器会确认不会出现悬空状态：

impl Playback {
    pub fn play(&mut self, file: String) -> bool {
        match std::mem::take(&mut self.state) {
            PlaybackState::Playing(old_state) => {
                self.state = PlaybackState::Playing(old_state);
                false
            }
            PlaybackState::Paused(progress) => {
                self.state = PlaybackState::Playing(progress);
                true
            }
            PlaybackState::Stopped => {
                self.file = Some(file);
                self.state = PlaybackState::Playing(PlaybackProgress { 
                    playback_position: 0.0, 
                    stream_id: 1 
                });
                true
            }
        }
    }
}

注：std::mem::take是mem::replace的简化版，这里和mem::replace(&mut self.state, PlaybackState::Stopped)效果完全一致。

方法3：为状态实现Clone（适合轻量数据） #

如果PlaybackProgress是可以廉价克隆的类型（比如本例中的f32和usize），可以为相关结构体和枚举实现Clone，直接克隆进度值：

#[derive(Clone)]
struct PlaybackProgress {
    playback_position: f32,
    stream_id: usize
}

#[derive(Clone)]
enum PlaybackState {
    Stopped,
    Playing(PlaybackProgress),
    Paused(PlaybackProgress)
}

impl Playback {
    pub fn play(&mut self, file: String) -> bool {
        match &self.state {
            PlaybackState::Playing(_) => false,
            PlaybackState::Paused(progress) => {
                self.state = PlaybackState::Playing(progress.clone());
                true
            }
            PlaybackState::Stopped => {
                self.file = Some(file);
                self.state = PlaybackState::Playing(PlaybackProgress { 
                    playback_position: 0.0, 
                    stream_id: 1 
                });
                true
            }
        }
    }
}

这种方法最简洁，但如果PlaybackProgress包含大对象或不可克隆的类型则不适用。

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