¿Puedo escribir un iterador que se muta y luego produce una referencia en sí mismo?

Me encontré con un problema que se simplifica en lo siguiente:

struct MyIter {
    vec: Vec<i8>,
}

fn fill_with_useful_data(v: &mut Vec<i8>) {
    /* ... */
}

impl<'a> Iterator for MyIter {
    type Item = &'a [i8];

    fn next(&mut self) -> Option<&'a [i8]> {
        fill_with_useful_data(&mut self.vec);

        Some(&self.vec)
    }
}

fn main() {
    for slice in (MyIter { vec: Vec::new() }) {
        println!("{}", slice);
    }
}

Esto genera el error:

error[E0207]: the lifetime parameter `'a` is not constrained by the impl trait, self type, or predicates
 --> src/main.rs:9:6
  |
9 | impl<'a> Iterator for MyIter {
  |      ^^ unconstrained lifetime parameter

La idea es que el iterador realiza un montón de trabajo que se refleja en sus campos y en cada paso, produce una referencia en sí mismo al código de llamada. En este caso, podría modelarlo para obtener una copia del estado en lugar de la referencia, pero supongamos que eso no es posible o simplemente es costoso.

Intuitivamente, esto no debería ser un problema porque el verificador de préstamos puede garantizar que.next() no se vuelve a llamar mientras la referencia producida todavía se puede usar para inspeccionar el estado del iterador, pero elIterator el rasgo no parece proporcionar ese tipo de cosas directamente. Incluso con algunas permutaciones como solo mantener una referencia al vector en el iterador o hacer que el iterador sea una referencia o algo para que las vidas se horneen en el tipo anteriormente, no puedo pasar nada del verificador de préstamos.

Yo leo el "Iteradores que producen referencias mutables"blogpost pero no estoy seguro si / cómo se aplica a mi problema que no involucra referencias mutables.