How can one struct own both a sequence and an iterator on the sequence?

Question

I am trying to construct a Defiler struct that owns a fixed sequence and an internal state describing current position within this sequence. The idea is that it can be iterated upon, but sometimes be reset to the beginning of the sequence.

I have picked an iterator as the internal state to represent the current value of the sequence. The idea is that it would be dropped and replaced by a fresh iterator when it's time to reset.

Here is my least fancy naive try so far:

use std::slice::IterMut;

struct Defiler<'a> {
    // This sequence should not change during the whole
    // lifetime of the struct, although I have not expressed it yet.
    seq: Vec<u32>,
    // Internal state pointing towards the next element to be
    // yielded. It will be randomly replaced by a fresh one.
    current: IterMut<'a, u32>,
    // ...
}

impl<'a> Defiler<'a> {

    fn new(mut seq: Vec<u32>) -> Self {
        Defiler {
            seq,
            current: seq.iter_mut(), // move out of borrowed value, of course.
        }
    }

    // Restart the iteration from scratch.
    fn reset(&'a mut self) {
        self.current = self.seq.iter_mut();
    }

    // ...

}

I understand why the above does not compile, and I am aware that I have not expressed many things I wish the compiler to be reassured about:

• even though its inner values are mutable, seq shall not grow or shrink during the whole lifetime of Defiler.
• current will only iterate on owned values in seq, ever.
• => no dangling iteration can be produced, I'm (quite) sure.

How could I write it?