[Haskell-cafe] Simple list processing

[Andrew Coppin]

OK, so this is a fairly basic question about list processing.

Several times now, I have found myself wanting to process a list to 
produce a new list. However, the way later elements are processed 
depends on what the earlier elements are - in other words, this isn't a 
simple "map".

What is the best way to handle this?

According to the theory, anything that consumes a list and produces a 
value is some kind of fold. [Assuming it traverses the list in a 
sensible order!] So it looks like you could implement this as a fold. 
But should that be a LEFT-fold or a RIGHT-fold? (I always get confused 
between the two!)

Actually, anything that takes a value and processes it repeatedly to 
produce a list is technically an unfold. [Again assuming a sensible 
processing order.] So it looks like this function could also be an 
UNfold. As in, you take a list as input, and keep unfolding until that 
list becomes empty.

So it looks like this can be implemented as a fold or an unfold. But 
neither way looks especially easy. Both of these patterns seem to be 
more general than necessary; I only want to take 1 element of input and 
produce 1 element of output, but keeping track of a running state. I 
guess I could use some sort of state monad and make the whole thing 
monadic - but that again is overkill for what I'm trying to do.

Any hints here?