我是否错误地实现了 IntoIterator 作为参考，或者这是一个应该报告的 Rust 错误？

Question

进一步介绍了根据the Rust book 为包装向量实现IntoIterator 的示例，我还尝试根据the following code (Playground link) 实现 IntoIterator 以获取对包装器的引用： p>

struct VecWrapper(Vec<i32>);

impl VecWrapper {
    fn iter(&'static self) -> Iter {
        Iter(Box::new(self.0.iter()))
    }
}

struct Iter(Box<Iterator<Item = &'static i32>>);

impl Iterator for Iter {
    type Item = &'static i32;
    fn next(&mut self) -> Option<Self::Item> {
        self.0.next()
    }
}

impl IntoIterator for &'static VecWrapper {
    type Item = &'static i32;
    type IntoIter = Iter;
    fn into_iter(self) -> Self::IntoIter {
        self.iter()
    }
}

fn main() {
    // let test = vec![1, 2, 3]; // obviously, works
    let test = VecWrapper(vec![1, 2, 3]); // not working
    for v in &test {
        println!("{}", v);
    }
}

虽然实现编译，但在main 中使用它的尝试不会出现以下错误：

error[E0597]: `test` does not live long enough
  --> src/main.rs:31:14
   |
31 |     for v in &test {
   |              ^^^^^
   |              |
   |              borrowed value does not live long enough
   |              argument requires that `test` is borrowed for `'static`
...
34 | }
   | - `test` dropped here while still borrowed

与我实际想要使用的代码相比，此代码已大大简化为仅使用 'static 生命周期，使用现有的包含类型，并将 i32 用于内部（迭代）类型，但归结为只显示问题。

---

接受的答案解决了问题的第一部分，即不使用 'static 和使用带有特征的 + 'a。我仍然对实际代码有问题，这是一个LazyList 实现。我已将其发布为Am I incorrectly implementing IntoIterator for a reference to a LazyList implementation or is this a Rust bug?。

Answer 1

您已经正确实现了对VecWrappers 的引用的迭代器，该迭代器在程序的整个长度内都存在——'static 的生命周期。

您可能希望拥有一个通用的生命周期。然后将为每个实例提供一个具体的生命周期，该生命周期是唯一的。通常，我们是懒惰的，只是给这一生起名字'a：

struct VecWrapper(Vec<i32>);

impl VecWrapper {
    fn iter(&self) -> Iter {
        Iter(Box::new(self.0.iter()))
    }
}

struct Iter<'a>(Box<dyn Iterator<Item = &'a i32> + 'a>);

impl<'a> Iterator for Iter<'a> {
    type Item = &'a i32;

    fn next(&mut self) -> Option<Self::Item> {
        self.0.next()
    }
}

impl<'a> IntoIterator for &'a VecWrapper {
    type Item = &'a i32;
    type IntoIter = Iter<'a>;

    fn into_iter(self) -> Self::IntoIter {
        self.iter()
    }
}

fn main() {
    let test = VecWrapper(vec![1, 2, 3]);
    for v in &test {
        println!("{}", v);
    }
}

重要变化：

• Box<dyn Iterator<Item = &'a i32> + 'a> - + 'a 已添加。这是必需的，因为 trait 对象 将假定没有内部值引用任何生命周期较短的对象。
• Item 类型现在是 &'a i32。
• 通用生命周期在许多地方声明并在许多其他地方提供 (<'a>)。

另见：

• Why is adding a lifetime to a trait with the plus operator (Iterator<Item = &Foo> + 'a) needed?

---

通常，这里没有理由使用 trait 对象。我只是直接嵌入迭代器：

struct Iter<'a>(std::slice::Iter<'a, i32>);

这避免了任何间接的需要，在这种情况下无论如何都不会使用它。此外，它更明显地耦合了生命周期。