= Solution
Adapt one machine update into one forward <iterator> element, then apply the skipping <iterator> of part (a) with $n=\mathrm{step}-1$ and the <bidirectional iterator> of part (b). Require a positive step and reset once on construction.
``
trait StateMachineIter[T] extends StateMachine[T] {
def getBiIter(step: Int): BiIter[T] = {
require(step > 0)
val machine = this
machine.reset()
val everyUpdate = new Iter[T] {
def hasNext: Boolean = !machine.shouldStop
def next(): T = {
if (!hasNext)
throw new NoSuchElementException("StateMachine.next")
machine.update()
machine.getValue
}
}
genBiIter(skipIter(everyUpdate, step-1))
}
}
``
After $j$ forward results at the unexplored frontier, the returned value is the machine's value after exactly $j\,\mathrm{step}$ updates. A partial final block contributes no element, and `update` is never called after `shouldStop` becomes true. For the printed `Add` example, the first three observed states are
$$
\boxed{1+2=3,\quad1+2+3+4=10,\quad1+2+3+4+5+6=21.}
$$
Because the <state machine> interface exposes no copy or rollback operation, determining whether enough updates remain generally requires executing them. Thus `hasNext` may advance the physical machine and cache the next observation. Backward traversal replays stored observations; it does not undo machine effects. This is a trace <iterator>, with the ordinary cursor semantics of part (b). Assume exclusive use of the machine while this <iterator> is active, and that returned values remain valid observations rather than mutable views overwritten by later updates.
Each physical update is executed at most once. Previously observed values can be revisited without rerunning the machine, and repeated `hasNext` calls do not perform duplicate updates once the next result is prepared.
Back to article page
