An Iterator Can Resume After Returning None

Suppose a transcript pipeline presents speech segments through a Rust iterator. A consumer polls next(), sees None, stores a final transcript, then polls the same iterator again and receives another segment. The first None ended that traversal, but the iterator contract does not require every later call to remain empty.

The standard library’s fuse() documentation states that an iterator may yield Some(item) after it has yielded None. A small stateful source makes the issue concrete:

let mut call = 0;
let source = std::iter::from_fn(move || {
    call += 1;
    match call {
        1 => Some("first segment"),
        3 => Some("late segment"),
        _ => None,
    }
});

let mut segments = source.fuse();
assert_eq!(segments.next(), Some("first segment"));
assert_eq!(segments.next(), None);
assert_eq!(segments.next(), None);

Without fuse(), the third call to this source would return Some("late segment"). The adapter records the first None and returns None on every later call through it. This gives a reusable consumer a stable terminal state even when the underlying iterator has unusual behavior. Ordinary traversal such as a for loop already stops at its first None; the distinction becomes important when code retains an iterator and calls it again, or passes it to another consumer.

That stability has a cost. Fusing the transcript source discards anything it would have produced after its first empty result. If None means “no audio chunk available yet”, Iterator is carrying the wrong signal for a live producer. Represent a temporary gap as an item or use an interface that can explicitly express pending work; reserve None for actual end of input. Then decide whether a finalizing consumer should call fuse() at the boundary.

There is a further contract boundary: the standard library can avoid an extra wrapper for iterators that already implement FusedIterator, and an incorrect implementation of that trait can break the promised behavior. When writing an iterator, implement that trait only if every call after the first None truly remains empty. When consuming an iterator you do not control, use fuse() if permanent exhaustion is part of your algorithm, while checking that the producer has a sound end-of-stream meaning.