如何在Rust枚举构造函数间移动非Copy值实现迭代器转换器？

问题背景 #

需要实现一个名为Padded的迭代器转换器，结构定义如下：

enum Step<T> {
    Before(T),
    During(T),
    After
}

struct Padded<T> {
    step: Step<T>
}

核心逻辑是在每次迭代中切换Step变体，将内部存储的T（迭代器）移动到下一个变体中，但多次尝试均遇到Rust借用检查器的报错。

尝试过程与错误 #

直接实现版本 #

impl<T: Iterator> Iterator for Padded<T> {
    type Item = Option<T::Item>;

    fn next(&mut self) -> Option<Self::Item> {
        match &self.step {
            Step::Before(start) => {
                self.step = Step::During(*start);
                Some(None)
            },
            Step::During(ref mut iter) => {
                match iter.next() {
                    Some(x) => { self.step = Step::During(*iter); Some(Some(x)) },
                    None => { self.step = Step::After; Some(None) },
                }
            },
            Step::After => {
                None
            }
        }
    }
}

编译报错：

error[E0507]: cannot move out of `*start` which is behind a shared reference
  --> src/lcd.rs:39:42
   |
39 |                 self.step = Step::During(*start);
   |                                          ^^^^^^ move occurs because `*start` has type `T`, which does not implement the `Copy` trait

error[E0596]: cannot borrow data in a `&` reference as mutable
  --> src/lcd.rs:42:26
   |
42 |             Step::During(ref mut iter) => {
   |                          ^^^^^^^^^^^^ cannot borrow as mutable

error[E0507]: cannot move out of `*iter` which is behind a mutable reference
  --> src/lcd.rs:44:59
   |
44 |                     Some(x) => { self.step = Step::During(*iter); Some(Some(x)) },
   |                                                           ^^^^^ move occurs because `*iter` has type `T`, which does not implement the `Copy` trait

所有权转移式实现 #

尝试通过所有权转移的方式实现逻辑：

impl<T: Iterator> Padded<T> {
    fn next_self_and_item(self) -> (Self, Option<Option<T::Item>>) {
        match self.step {
            Step::Before(start) => {
                (Padded{ step: Step::During(start) }, Some(None))
            },
            Step::During(mut iter) => {
                match iter.next() {
                    Some(x) => (Padded{ step: Step::During(iter) }, Some(Some(x))),
                    None => (Padded{ step: Step::After }, Some(None)),
                }
            },
            Step::After => {
                (Padded{ step: Step::After }, None)
            }
        }
    }
}

impl<T: Iterator> Iterator for Padded<T> {
    type Item = Option<T::Item>;

    fn next(&mut self) -> Option<Self::Item> {
        let (new_self, item) = self.next_self_and_item();
        *self = new_self;
        item
    }
}

编译报错：

error[E0507]: cannot move out of `*self` which is behind a mutable reference
  --> src/lcd.rs:79:32
   |
79 |         let (new_self, item) = self.next_self_and_item();
   |                                ^^^^ -------------------- `*self` moved due to this method call
   |                                |
   |                                move occurs because `*self` has type `Padded<T>`, which does not implement the `Copy` trait
   |
note: `Padded::<T>::next_self_and_item` takes ownership of the receiver `self`, which moves `*self`
  --> src/lcd.rs:57:27
   |
57 |     fn next_self_and_item(self) -> (Self, Option<Option<T::Item>>) {
   |                           ^^^^

错误原因分析 #

1. 直接实现的问题：

   • 使用&self.step进行match，得到的是共享引用，无法移动引用背后的T（因为T未实现Copy trait）
   • 在共享引用的match分支中，无法声明可变借用ref mut iter
   • 即使拿到可变引用，也无法移动*iter，因为可变引用仅允许借用而非所有权转移

2. 所有权转移实现的问题：

   • next_self_and_item方法需要获取self的所有权，但Iterator::next仅提供&mut self，无法将*self从可变引用中移动出去

解决方案 #

核心思路是通过std::mem::replace取出self.step的所有权，处理后再将新的状态赋值回去。具体代码如下：

use std::mem;

enum Step<T> {
    Before(T),
    During(T),
    After
}

struct Padded<T> {
    step: Step<T>
}

impl<T: Iterator> Iterator for Padded<T> {
    type Item = Option<T::Item>;

    fn next(&mut self) -> Option<Self::Item> {
        // 取出当前step的所有权，用Step::After临时占位
        let current_step = mem::replace(&mut self.step, Step::After);
        
        match current_step {
            Step::Before(start) => {
                // 将迭代器转移到During变体
                self.step = Step::During(start);
                Some(None)
            },
            Step::During(mut iter) => {
                match iter.next() {
                    Some(x) => {
                        // 迭代器还有元素，放回During变体
                        self.step = Step::During(iter);
                        Some(Some(x))
                    },
                    None => {
                        // 迭代器耗尽，切换到After变体
                        self.step = Step::After;
                        Some(None)
                    },
                }
            },
            Step::After => {
                // 已经结束，保持After状态
                self.step = Step::After;
                None
            }
        }
    }
}

方案解释 #

• mem::replace：从可变引用中取出目标值的所有权，同时放入一个临时占位值，避免直接操作引用时的借用冲突
• 所有权处理：match的是拥有所有权的current_step，因此可以自由将内部的T（迭代器）移动到新的Step变体中
• 状态更新：处理完成后，将新的Step变体赋值给self.step，更新迭代器的状态

思路可行性确认 #

你的核心思路完全可行——通过可变引用修改self.step，且仅移动内部的T。之前的问题只是没有正确处理所有权转移，使用mem::replace即可解决这个问题，让逻辑正常运行。

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