I used to ask a similar question once. Now I'll be more specific. The purpose is to learn a Haskell idiom to write iterative algorithms with monadic results. In particular, this might be useful for implementing all kinds of randomized algorithms, such as genetic algorithms and a like.

I wrote an example program that manifests my problem with such algorithms in Haskell. Its complete source is on hpaste.

The key point is to update an element randomly (thus the result is in State StdGen or some other monad):

type RMonad = State StdGen -- An example of random iteration step: one-dimensional random walk. randStep :: (Num a) => a -> RMonad a randStep x = do rnd <- get let (goRight,rnd') = random rnd :: (Bool, StdGen) put rnd' if goRight then return (x+1) else return (x-1)

And then one needs to update many elements, and repeat the process many, many times. And here is a problem. As every step is a monad action ( :: a -> m a ), repeated many times, it's important to compose such actions effectively (forgetting the previous step quickly). From what I learned from my previous quesion (Composing monad actions with folds), seq and deepseq help a lot to compose monadic actions. So I do:

-- Strict (?) iteration. iterateM' :: (NFData a, Monad m) => Int -> (a -> m a) -> a -> m a iterateM' 0 _ x = return $!! x iterateM' n f x = (f $!! x) >>= iterateM' (n-1) f -- Deeply stict function application. ($!!) :: (NFData a) => (a -> b) -> a -> b f $!! x = x `deepseq` f x

It is certainly better than lazy composition. Unfortunately, it is not enough.

-- main seems to run in O(size*iters^2) time... main :: IO () main = do (size:iters:_) <- liftM (map read) getArgs let start = take size $ repeat 0 rnd <- getStdGen let end = flip evalState rnd $ iterateM' iters (mapM randStep) start putStr . unlines $ histogram "%.2g" end 13

When I measured time required to finish this program, it appears, that it is similar to O(N^2) with respect to the number of iterations (memory allocation seems to be acceptable). This profile should be flat and constant for linear asymptotics:

And this is how a heap profile looks:

I assume that such a program should run with very modest memory requirements, and it should take time proportional to the number of iterations. How can I achieve that in Haskell?

The complete runnable source of the example is here.