How do I write an iterator that returns references to itself?

by

As far as I understand, you want want the iterator to return a vector of references into itself, right? Unfortunately, it is not possible in Rust.

This is the trimmed down Iterator trait:

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

Note that there is no lifetime connection between &mut self and Option<Item>. This means that next() method can’t return references into the iterator itself. You just can’t express a lifetime of the returned references. This is basically the reason that you couldn’t find a way to specify the correct lifetime – it would’ve looked like this:

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

except that this is not a valid next() method for Iterator trait.

Such iterators (the ones which can return references into themselves) are called streaming iterators. You can find more here, here and here, if you want.

Update. However, you can return a reference to some other structure from your iterator – that’s how most of collection iterators work. It could look like this:

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>> {
        ...
    }
}

Note how lifetime 'a is now declared on impl block. It is OK to do so (required, in fact) because you need to specify the lifetime parameter on the structure. Then you can use the same 'a both in Item and in next() return type. Again, that’s how most of collection iterators work.

More Related Contents:

  1. Returning iterator of a Vec in a RefCell
  2. How to implement Iterator and IntoIterator for a simple struct?
  3. How can I add new methods to Iterator?
  4. Are there equivalents to slice::chunks/windows for iterators to loop over pairs, triplets etc?
  5. Iterator returning items by reference, lifetime issue
  6. Iterating over a slice’s values instead of references in Rust?
  7. is it possible to filter on a vector in-place?
  8. How do I perform iterator computations over iterators of Results without collecting to a temporary vector?
  9. How can I zip more than two iterators?
  10. Writing a generic function that takes an iterable container as parameter in Rust
  11. Why can’t I store a value and a reference to that value in the same struct?
  12. Is there any way to return a reference to a variable created in a function?
  13. What are non-lexical lifetimes?
  14. The compiler suggests I add a ‘static lifetime because the parameter type may not live long enough, but I don’t think that’s what I want
  15. How can I create my own data structure with an iterator that returns mutable references?
  16. Lifetime error when creating a function that returns a value implementing serde::Deserialize
  17. How do I write the lifetimes for references in a type constraint when one of them is a local reference?
  18. How can this instance seemingly outlive its own parameter lifetime?
  19. What is the difference between ‘&self’ and ‘&’a self’?
  20. Why do generators not support map()?
  21. Why can’t I use a key function that returns a reference when sorting a vector with sort_by_key?
  22. How to operate on 2 mutable slices of a Rust array?
  23. When returning the outcome of consuming a StdinLock, why was the borrow to stdin retained?
  24. Why is the bound `T: ‘a` required in order to store a reference `&’a T`?
  25. Thread references require static lifetime?
  26. Why does Rust disallow mutable aliasing?
  27. Using max_by_key on a vector of floats [duplicate]
  28. How do I cope with lazy iterators?
  29. Rust lifetime error expected concrete lifetime but found bound lifetime
  30. How do I avoid unwrap when converting a vector of Options or Results to only the successful values?

Leave a Comment