Rust 实现迭代器

Question

所以我目前正在学习Rust，并且有一个关于如何实现非消耗迭代器的问题。我编写了一个堆栈：

struct Node<T>{
    data:T,
    next:Option<Box<Node<T>>>
}
pub struct Stack<T>{
    first:Option<Box<Node<T>>>
}
impl<T> Stack<T>{
    pub fn new() -> Self{
        Self{first:None}
    }
    pub fn push(&mut self, element:T){
        let old = self.first.take();
        self.first = Some(Box::new(Node{data:element, next:old}));
    }
    pub fn pop(&mut self) -> Option<T>{
        match self.first.take(){
            None => None,
            Some(node) =>{
                self.first = node.next;
                Some(node.data)
            }
        }
    }
    pub fn iter(self) -> StackIterator<T>{
        StackIterator{
            curr : self.first
        }
    }
}
pub struct StackIterator<T>{
    curr : Option<Box<Node<T>>>
}
impl<T> Iterator for StackIterator<T>{
    type Item = T;
    fn next (&mut self) -> Option<T>{
        match self.curr.take(){
            None => None,
            Some(node) => {
                self.curr = node.next;
                Some(node.data)
            }
        }
    }
}

使用堆栈迭代器，它是通过调用iter()堆栈上的方法创建的。问题：我必须让这个iter()方法消耗它的堆栈，因此堆栈只能迭代一次。如何在不消耗堆栈且不实现复制或克隆特征的情况下实现此方法？

Answer 1

如何在不消耗堆栈且不实现复制或克隆特征的情况下实现此方法？

让 StackIterator借用堆栈，迭代器返回对项目的引用。类似的东西

impl<T> Stack<T>{
    pub fn iter(&self) -> StackIterator<T>{
        StackIterator{
            curr : &self.first
        }
    }
}
pub struct StackIterator<'stack, T: 'stack>{
    curr : &'stack Option<Box<Node<T>>>
}
impl<'s, T: 's> Iterator for StackIterator<'s, T>{
    type Item = &'s T;
    fn next (&mut self) -> Option<&'s T>{
        match self.curr.as_ref().take() {
            None => None,
            Some(node) => {
                self.curr = &node.next;
                Some(&node.data)
            }
        }
    }
}

（我实际上没有测试这段代码，所以它可能不起作用）

这本质上就是这样std::iter::Iter做的（尽管它是作为较低级别实现的）。

也就是说，通过实现链表来学习 Rust可能不是世界上最好的主意，链表是退化图，借用检查器与图的关系并不友好。