如何编写一个返回自身引用的迭代器？

据我了解，您希望迭代器将引用向量返回到自身中，对吗？不幸的是，这在 Rust 中是不可能的。

这是被修剪的特征：Iterator

trait Iterator {
    type Item;
    fn next(&mut self) -> Option<Item>;
}

请注意，和 之间没有生存期联系。这意味着该方法无法将引用返回到迭代器本身中。您只是无法表示返回的引用的生存期。这基本上就是你找不到一种方法来指定正确的生存期的原因 - 它看起来像这样：&mut selfOption<Item>next()

fn next<'a>(&'a mut self) -> Option<Vec<&'a T>>

除了这不是 trait 的有效方法。next()Iterator

这种迭代器（可以将引用返回到自身的迭代器）称为流式迭代器。如果你愿意，你可以在这里、这里和这里找到更多。

更新。但是，您可以从迭代器返回对其他结构的引用 - 这就是大多数集合迭代器的工作方式。它可能看起来像这样：

pub struct PermutationIterator<'a, T> {
    vs: &'a [Vec<T>],
    is: Vec<usize>
}

impl<'a, T> Iterator for PermutationIterator<'a, T> {
    type Item = Vec<&'a T>;

    fn next(&mut self) -> Option<Vec<&'a T>> {
        ...
    }
}

请注意，现在如何在块上声明生存期。这样做是可以的（实际上是必需的），因为您需要在结构上指定生存期参数。然后，您可以在返回类型和返回类型中使用相同的方法。同样，这就是大多数集合迭代器的工作方式。'aimpl'aItemnext()

@VladimirMatveev的答案是正确的，因为它解释了为什么你的代码无法编译。简而言之，它说迭代器不能从自身内部产生借用的值。

但是，它可以从其他东西中产生借用的价值。这就是用 和 实现的：拥有值，而 the 只是一个包装器，能够在 中产生引用。VecIterVecIterVec

这是一个实现你想要的设计。迭代器与 和 一样，只是实际拥有值的其他容器的包装器。VecIter

use std::iter::Iterator;

struct PermutationIterator<'a, T: 'a> {
    vs : Vec<&'a [T]>,
    is : Vec<usize>
}

impl<'a, T> PermutationIterator<'a, T> {
    fn new() -> PermutationIterator<'a, T> { ... }

    fn add(&mut self, v : &'a [T]) { ... }
}

impl<'a, T> Iterator for PermutationIterator<'a, T> {
    type Item = Vec<&'a T>;
    fn next(&mut self) -> Option<Vec<&'a T>> { ... }
}

fn main() {
    let v1 : Vec<i32> = (1..3).collect();
    let v2 : Vec<i32> = (3..5).collect();
    let v3 : Vec<i32> = (1..6).collect();

    let mut i = PermutationIterator::new();
    i.add(&v1);
    i.add(&v2);
    i.add(&v3);

    loop {
        match i.next() {
            Some(v) => { println!("{:?}", v); }
            None => {break;}
        }
    }
}

（游乐场）

---

与您的初始问题无关。如果这只是我，我会确保一次获取所有借用的向量。这个想法是在构造时删除对所有借用向量的重复调用并直接传递：add

use std::iter::{Iterator, repeat};

struct PermutationIterator<'a, T: 'a> {
    ...
}

impl<'a, T> PermutationIterator<'a, T> {
    fn new(vs: Vec<&'a [T]>) -> PermutationIterator<'a, T> {
        let n = vs.len();
        PermutationIterator {
            vs: vs,
            is: repeat(0).take(n).collect(),
        }
    }
}

impl<'a, T> Iterator for PermutationIterator<'a, T> {
    ...
}

fn main() {
    let v1 : Vec<i32> = (1..3).collect();
    let v2 : Vec<i32> = (3..5).collect();
    let v3 : Vec<i32> = (1..6).collect();
    let vall: Vec<&[i32]> = vec![&v1, &v2, &v3];

    let mut i = PermutationIterator::new(vall);
}

（游乐场）

(编辑：更改了迭代器设计，采用 a 而不是 .将 ref 带到容器比构建 refs 的容器更容易。Vec<&'a [T]>Vec<Vec<&'a T>>

正如其他答案中提到的，这被称为流式迭代器，它需要与 Rust 的 .一个提供这种功能的 crate 被恰当地称为 streaming-iterator，它提供了 StreamingIterator 特征。Iterator

下面是实现该特征的一个示例：

extern crate streaming_iterator;

use streaming_iterator::StreamingIterator;

struct Demonstration {
    scores: Vec<i32>,
    position: usize,
}

// Since `StreamingIterator` requires that we be able to call
// `advance` before `get`, we have to start "before" the first
// element. We assume that there will never be the maximum number of
// entries in the `Vec`, so we use `usize::MAX` as our sentinel value.
impl Demonstration {
    fn new() -> Self {
        Demonstration {
            scores: vec![1, 2, 3],
            position: std::usize::MAX,
        }
    }

    fn reset(&mut self) {
        self.position = std::usize::MAX;
    }
}

impl StreamingIterator for Demonstration {
    type Item = i32;

    fn advance(&mut self) {
        self.position = self.position.wrapping_add(1);
    }

    fn get(&self) -> Option<&Self::Item> {
        self.scores.get(self.position)
    }
}

fn main() {
    let mut example = Demonstration::new();

    loop {
        example.advance();
        match example.get() {
            Some(v) => {
                println!("v: {}", v);
            }
            None => break,
        }
    }

    example.reset();

    loop {
        example.advance();
        match example.get() {
            Some(v) => {
                println!("v: {}", v);
            }
            None => break,
        }
    }
}

遗憾的是，在实现 RFC 1598 中的泛型关联类型 （GAT） 之前，流式迭代器将受到限制。

我不久前写了这段代码，不知何故在这里偶然发现了这个问题。它完全按照问题的要求执行：它展示了如何实现一个迭代器，该迭代器将回调传递给自身的引用。

它向实例添加一个方法。最初我认为它应该自己实现，但这是一个不太灵活的设计决策。.iter_map()IntoIteratorIterator

我为它创建了一个小板条箱，并将我的代码发布到 GitHub，如果你想尝试它，你可以在这里找到它。

WRT OP 在定义项目的生命周期时遇到了麻烦，我在依赖默认省略的生命周期时没有遇到任何此类麻烦。

下面是一个用法示例。请注意，回调接收的参数是迭代器本身，回调应从中提取数据，并按原样传递数据或执行任何其他操作。

 use iter_map::IntoIterMap;

 let mut b = true;

 let s = "hello world!".chars().peekable().iter_map(|iter| {
     if let Some(&ch) = iter.peek() {
         if ch == 'o' && b {
             b = false;
             Some('0')
         } else {
             b = true;
             iter.next()
         }
     } else { None }
 }).collect::<String>();

 assert_eq!(&s, "hell0o w0orld!");

因为通用特征是为 实现的，所以你可以从任何支持该接口的东西上得到一个“iter map”。例如，可以直接从数组创建一个，如下所示：IntoIterMapIntoIterator

use iter_map::*;

fn main() 
{
    let mut i = 0;

    let v = [1, 2, 3, 4, 5, 6].iter_map(move |iter| {
        i += 1;
        if i % 3 == 0 {
            Some(0)
        } else {
            iter.next().copied()
        }
    }).collect::<Vec<_>>();
 
    assert_eq!(v, vec![1, 2, 0, 3, 4, 0, 5, 6, 0]);
}

这是完整的代码 - 令人惊讶的是，它只花了这么少的代码来实现，而且在将它们放在一起时，一切似乎都很顺利。它让我对 Rust 本身的灵活性及其设计决策有了新的认识。

/// Adds `.iter_map()` method to all IntoIterator classes.
///
impl<F, I, J, R, T> IntoIterMap<F, I, R, T> for J
//
where F: FnMut(&mut I) -> Option<R>,
      I: Iterator<Item = T>,
      J: IntoIterator<Item = T, IntoIter = I>,
{
    /// Returns an iterator that invokes the callback in `.next()`, passing it
    /// the original iterator as an argument. The callback can return any
    /// arbitrary type within an `Option`.
    ///
    fn iter_map(self, callback: F) -> ParamFromFnIter<F, I>
    {
        ParamFromFnIter::new(self.into_iter(), callback)
    }
}

/// A trait to add the `.iter_map()` method to any existing class.
///
pub trait IntoIterMap<F, I, R, T>
//
where F: FnMut(&mut I) -> Option<R>,
      I: Iterator<Item = T>,
{
    /// Returns a `ParamFromFnIter` iterator which wraps the iterator it's 
    /// invoked on.
    ///
    /// # Arguments
    /// * `callback`  - The callback that gets invoked by `.next()`.
    ///                 This callback is passed the original iterator as its
    ///                 parameter.
    ///
    fn iter_map(self, callback: F) -> ParamFromFnIter<F, I>;
}

/// Implements an iterator that can be created from a callback.
/// does pretty much the same thing as `std::iter::from_fn()` except the 
/// callback signature of this class takes a data argument.
pub struct ParamFromFnIter<F, D>
{
    callback: F,
    data: D,
}

impl<F, D, R> ParamFromFnIter<F, D>
//
where F: FnMut(&mut D) -> Option<R>,
{
    /// Creates a new `ParamFromFnIter` iterator instance.
    ///
    /// This provides a flexible and simple way to create new iterators by 
    /// defining a callback. 
    /// # Arguments
    /// * `data`      - Data that will be passed to the callback on each 
    ///                 invocation.
    /// * `callback`  - The callback that gets invoked when `.next()` is invoked
    ///                 on the returned iterator.
    ///    
    pub fn new(data: D, callback: F) -> Self
    {
        ParamFromFnIter { callback, data }
    }
}

/// Implements Iterator for ParamFromFnIter. 
///
impl<F, D, R> Iterator for ParamFromFnIter<F, D>
//
where F: FnMut(&mut D) -> Option<R>,
{
    type Item = R;
    
    /// Iterator method that returns the next item.
    /// Invokes the client code provided iterator, passing it `&mut self.data`.
    ///
    fn next(&mut self) -> Option<Self::Item>
    {
        (self.callback)(&mut self.data)
    }
}