Rust中match循环内如何为typestate模式的变量重绑定不同类型？

你遇到的核心问题是：Typestate模式下，状态转换方法会消耗当前实例（self），导致循环迭代时无法再访问原变量。下面提供两种可行的解决方案：

方法1：用枚举封装所有状态的售货机 #

将不同状态的VendingMachine<S>包装到一个枚举中，通过更新枚举变体来实现循环内的状态流转，让所有权在枚举内部安全传递。

示例代码：

// 定义状态标记ZST
#[derive(Debug)]
struct Start;
#[derive(Debug)]
struct Payment;
#[derive(Debug)]
struct Checkout;

// 基础售货机结构体
struct VendingMachine<S> {
    state: S,
    inventory: u32,
    balance: f64,
}

// Start状态的方法实现
impl VendingMachine<Start> {
    fn new() -> Self {
        VendingMachine {
            state: Start,
            inventory: 10,
            balance: 0.0,
        }
    }

    fn to_payment(self) -> VendingMachine<Payment> {
        VendingMachine {
            state: Payment,
            inventory: self.inventory,
            balance: self.balance,
        }
    }
}

// Payment状态的方法实现
impl VendingMachine<Payment> {
    fn to_checkout(self) -> VendingMachine<Checkout> {
        VendingMachine {
            state: Checkout,
            inventory: self.inventory,
            balance: self.balance + 2.0,
        }
    }

    fn back_to_start(self) -> VendingMachine<Start> {
        VendingMachine {
            state: Start,
            inventory: self.inventory,
            balance: 0.0,
        }
    }
}

// Checkout状态的方法实现
impl VendingMachine<Checkout> {
    fn dispense(self) -> VendingMachine<Start> {
        VendingMachine {
            state: Start,
            inventory: self.inventory - 1,
            balance: 0.0,
        }
    }
}

// 封装所有状态的枚举
enum MachineState {
    Start(VendingMachine<Start>),
    Payment(VendingMachine<Payment>),
    Checkout(VendingMachine<Checkout>),
}

fn main() {
    let mut machine = MachineState::Start(VendingMachine::new());

    loop {
        machine = match machine {
            MachineState::Start(m) => {
                println!("当前状态：Start，准备进入支付流程");
                MachineState::Payment(m.to_payment())
            }
            MachineState::Payment(m) => {
                println!("当前状态：Payment，投币完成，进入结账");
                // 可根据业务逻辑选择转换方向，比如取消操作回到Start
                // MachineState::Start(m.back_to_start())
                MachineState::Checkout(m.to_checkout())
            }
            MachineState::Checkout(m) => {
                println!("当前状态：Checkout，出货后回到初始状态");
                let new_machine = m.dispense();
                if new_machine.inventory == 0 {
                    println!("库存耗尽，退出");
                    break;
                }
                MachineState::Start(new_machine)
            }
        };
    }
}

这种方式通过枚举统一了所有可能的状态类型，每次循环都会消耗当前枚举变体并返回新变体，完全符合Rust的所有权规则。

方法2：用递归函数替代循环 #

利用递归传递转换后的售货机实例，完美适配Typestate的类型安全特性，避免循环中的所有权冲突。

示例代码：

// 状态标记和结构体定义同方法1，此处省略重复代码

fn run_machine<S>(machine: VendingMachine<S>) -> ! {
    match machine.state {
        Start => {
            println!("当前状态：Start，进入支付状态");
            let payment_machine = machine.to_payment();
            run_machine(payment_machine);
        }
        Payment => {
            println!("当前状态：Payment，进入结账状态");
            let checkout_machine = machine.to_checkout();
            run_machine(checkout_machine);
        }
        Checkout => {
            println!("当前状态：Checkout，出货回到初始状态");
            let start_machine = machine.dispense();
            if start_machine.inventory == 0 {
                println!("库存为空，退出程序");
                std::process::exit(0);
            }
            run_machine(start_machine);
        }
    }
}

fn main() {
    let initial_machine = VendingMachine::new();
    run_machine(initial_machine);
}

递归函数每次接收特定状态的售货机实例，处理后转换为新状态实例并传入下一次递归，所有权传递清晰。注意：如果状态循环次数极多，可能存在栈溢出风险，但CLI场景下一般不会触发。

原代码报错原因 #

你在match分支中调用to_payment(self)时，machine被移动到方法中，下一次循环迭代时原变量已失效，编译器无法保证循环的合法性。上面两种方法分别通过枚举统一类型、递归传递所有权解决了这个问题。

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