Question

I have come across a pattern where, I start with a seed value x and at each step generate a new seed value and a value to be output. My desired final result is a list of the output values. This can be represented by the following function:

my_iter :: (a -> (a, b)) -> a -> [b]
my_iter f x = y : my_iter f x'
   where (x',y) = f x

And a contrived example of using this would be generating the Fibonacci numbers:

fibs:: [Integer]
fibs = my_iter (\(a,b) -> let c = a+b in ((b, c), c)) (0,1)
-- [1, 2, 3, 5, 8...

My problem is that I have this feeling that there is very likely a more idiomatic way to do this kind of stuff. What are the idiomatic alternatives to my function?

The only ones I can think of right now involve iterate from the Prelude, but they have some shortcomings.

One way is to iterate first and map after

my_iter f x = map f2 $ iterate f1 x
    where f1 = fst . f
          f2 = snd . f

However, this can look ugly if there is no natural way to split f into the separate f1 and f2 functions. (In the contrived Fibonacci case this is easy to do, but there are some situations where the generated value is not an “independent” function of the seed so its not so simple to split things)

The other way is to tuple the “output” values together with the seeds, and use a separate step to separate them (kind of like the “Schwartzian transform” for sorting things):

my_iter f x = map snd . tail $ iterate (f.fst) (x, undefined)

But this seems wierd, since we have to remember to ignore the generated values in order to get to the seed (the (f.fst) bit) and add we need an “undefined” value for the first, dummy generated value.

Answer 1

As already noted, the function you want is unfoldr. As the name suggests, it’s the opposite of foldr, but it might be instructive to see exactly why that’s true. Here’s the type of foldr:

(a -> b -> b) -> b -> [a] -> b

The first two arguments are ways of obtaining something of type b, and correspond to the two data constructors for lists:

[]  :: [a]
(:) :: a -> [a] -> [a]

…where each occurrence of [a] is replaced by b. Noting that the [] case produces a b with no input, we can consolidate the two as a function taking Maybe (a, b) as input.

(Maybe (a, b) -> b) -> ([a] -> b)

The extra parentheses show that this is essentially a function that turns one kind of transformation into another.

Now, simply reverse the direction of both transformations:

(b -> Maybe (a, b)) -> (b -> [a])

The result is exactly the type of unfoldr.

The underlying idea this demonstrates can be applied similarly to other recursive data types, as well.