Out-of-order list iteration in Haskell - list

Question

I'm implementing a (toy) stack machine in Haskell. I've defined a step function, step :: State -> Instruction -> State, which applies the result of a given instruction to a given state and returns the resultant state of the machine. Obviously, I'd like to have a function, run :: State -> Program -> State (where Program :: [Instruction]) that essentially calls step as many times as needed in order to execute the given input program.
My initial, naive solution was to foldl, like so:
run :: State -> Program -> State
run st prog = foldl (step) st prog
Obviously, this can't support jumps, which would modify where abouts in the list I need to be. All this implementation does is iterate left-to-right through the program. For additional context, the program's state, State, is as follows:
data State = State {
pc :: Word,
reg :: Word,
stack :: [Word],
memory :: [Word]
}
deriving (Show, Eq)
and instructions are as follows:
data Opcode = Add | Sub | Mul | Div | Mod | Jump | Push | Pop | Load | Store | Set | Call | Ret | Pos | Dup | Swap | Halt | Nop
deriving (Enum, Show, Eq)
data Instruction = Instruction {
opcode :: Opcode,
arg :: Maybe Word
}
deriving (Show, Eq)
How do I iterate through the list in an arbitrary order (and potentially forever, of course) so that I can support jumps?

Answer 1

I guess your step function will need to report whether it's time to halt or not. For example, let's suppose you modify its type to step :: State -> Instruction -> Maybe State. Then you can implement run just by shipping out to it:
run :: State -> Program -> State
run state prog = case step state (prog !! fromIntegral (pc state)) of
Nothing -> state
Just state' -> run state' prog
(You can avoid the fromIntegral by making your pc have type Int instead of Word.)
Note that (!!) is O(2n)* (fight me in the comments ;-). You should consider switching from [Instruction] to Array Word Instruction so that you can use (!) instead, which is O(n).
* Okay, to be precise, (!!) is technically O(1) because Int has a fixed size -- but, ohhhh, that constant factor! So let's say, a suitable generalization of (!!) to Integer is O(2n). Similar quibbles apply to (!).

Answer 2

Using an array is probably a good way to go, but there's also a way to step through your program that's a bit more like a fold by doing away with the program counter altogether.
The program counter is simply a pointer to the instruction in your program that you're going to run next. So, instead of having a program counter, we can just put the instruction to run next right into the state. Consider this alternate implementation of State:
data State = State
{ reg :: Word
, stack :: [Word]
, memory :: [Word]
, program :: Program
} deriving (Show, Eq)
Now we must reconsider step. In particular, every time we step, we aren't increasing (or arbitrarily modifying) the pc but rather changing the program to be run. Furthermore, we don't need to take an instruction as an argument because State already knows what is about to be run. Thus, we have something like:
step :: State -> State
step st = case program st of
[] -> st
HALT : _ -> st {program = []}
ADD : rest -> st {program = rest, ...} -- Do whatever you do for add too
...
But, what do we do for JUMP? How can we jump to an arbitrary position in the program when the program is disappearing on us as we run it? One option is to additionally keep track of the original program. We could put this in the State as another field, but for variety, I'm going to pass it as an additional argument to step, as in:
step :: Program -> State -> State
step originalProgram st = case program st of
[] -> st
HALT : _ -> st {program = []}
JUMP n : _ -> st {program = drop n originalProgram}
...
(Note that here I'm assuming that your JUMP is absolute as opposed to relative. If you have relative jumps, then instead of keeping track of the original program, you'd need to keep track of the "already executed" part of the program, probably as a list of instructions in reverse order. That is, every time you execute an instruction, you would pop it off the program list and push it onto the executed list. When you hit a JUMP that went backwards n instructions, you would just pop n off of the executed and push them back onto the program list.)
Now all that's left is to run the whole program:
run :: State -> Program -> State
run startState originalProgram = go (startState {program = originalProgram})
where
go st = case program st of
[] -> st
_ -> go $ step originalProgram st
As far as performance goes, this is certainly worse than using an array; most steps will be fast, but JUMPS may take longer. On the other hand, you can run infinitely long programs this way, and you don't have to worry about indexes that are out of bounds.