Temporarily cache owned value between iterator adapters

Question

I'd like to know if there's a way to cache an owned value between iterator adapters, so that adapters later in the chain can reference it. (Or if there's another way to allow later adapters to reference an owned value that lives inside the iterator chain.)

To illustrate what I mean, let's look at this (contrived) example:

I have a function that returns a String, which is called in an Iterator map() adapter, yielding an iterator over Strings. I'd like to get an iterator over the chars() in those Strings, but the chars() method requires a string slice, meaning a reference.

Is this possible to do, without first collecting the Strings?

Here's a minimal example that of course fails:

fn greet(c: &str) -> String {
    "Hello, ".to_owned() + c
}

fn main() {
    let names = ["Martin", "Helena", "Ingrid", "Joseph"];
    let iterator = names.into_iter().map(greet);
    let fails = iterator.flat_map(<str>::chars);
}

Playground

Using a closure instead of <str>::chars - |s| s.chars() - does of course not work either. It makes the types match, but breaks lifetimes.

---

Edit (2022-10-03): In response to the comments, here's some pseudocode of what I have in mind, but with incorrect lifetimes:

struct IteratorCache<'a, T, I>{
    item : Option<T>,
    inner : I,
    _p : core::marker::PhantomData<&'a T>
}

impl<'a, T, I> Iterator for IteratorCache<'a, T,I>
    where I: Iterator<Item=T>
{
    type Item=&'a T;
    fn next(&mut self) -> Option<&'a T> {
        self.item = self.inner.next();
        if let Some(x) = &self.item {
            Some(&x)
        } else {
            None
        }
    }
}

The idea would be that the reference could stay valid until the next call to next(). However I don't know if this can be expressed with the function signature of the Iterator trait. (Or if this can be expressed at all.)

Answer 1

I don't think something like this exists yet, and collecting into a Vec<char> creates some overhead, but you can write such an iterator yourself with a little bit of trickery:

struct OwnedCharsIter {
    s: String,
    index: usize,
}

impl OwnedCharsIter {
    pub fn new(s: String) -> Self {
        Self { s, index: 0 }
    }
}

impl Iterator for OwnedCharsIter {
    type Item = char;

    fn next(&mut self) -> Option<Self::Item> {
        // Slice of leftover characters
        let slice = &self.s[self.index..];

        // Iterator over leftover characters
        let mut chars = slice.chars();

        // Query the next char
        let next_char = chars.next()?;

        // Compute the new index by looking at how many bytes are left
        // after querying the next char
        self.index = self.s.len() - chars.as_str().len();

        // Return next char
        Some(next_char)
    }
}

fn greet(c: &str) -> String {
    "Hello, ".to_owned() + c
}

fn main() {
    let names = ["Martin", "Helena", "Ingrid", "Joseph"];
    let iterator = names.into_iter().map(greet);
    let chars_iter = iterator.flat_map(OwnedCharsIter::new);

    println!("{:?}", chars_iter.collect::<String>())
}

"Hello, MartinHello, HelenaHello, IngridHello, Joseph"