Hi all, I am having a problem with the implementation of a program (a genetic algorithm) which requires randomness in it. It all hinges on the ability to generate something (in the example below an Int), then provide a function to update it such that the prelude's iteratefunction (or an equivalent) may be used. In my program I require that both the generation and the updating function contain randomness. I have drafted a (simplified) example of my problem: This code show a trivial case where randomness (and hence the IO monad) is not used and the first 10 elements of the produced list are printed: aNum :: Int aNum = 2 addTwo :: Int -> Int addTwo = (+) 2 firstTen :: [Int] firstTen = take 10 (iterate addTwo aNum) main :: IO () main = do print firstTen As required the program terminates printing: [2,4,6,8,10,12,14,16,18,20] Now I present my 'conversion' of this trivial case where we both generate a random number, and add a random amount to it upon each iteration. Again we only wish to print the first 10: import System.Random -- Taken directly from function 'rollDice' in Haskell98 report randNum :: IO Int randNum = getStdRandom (randomR (1, 6)) addRand :: Int -> IO Int addRand x = do y <- randNum return (x + y) firstTen :: IO [Int] firstTen = do infiniteNums <- iterateM addRand randNum return (take 10 infiniteNums) main :: IO () main = do tenNums <- firstTen print tenNums -- Monadic interpretation of prelude iterate definition iterateM :: Monad m => (a -> m a) -> m a -> m [a] iterateM f xM = do x <- xM mcons xM (iterateM f (f x)) -- Taken from prelude definition of sequence mcons :: Monad m => m a -> m [a] -> m [a] mcons p q = p >>= \x -> q >>= \y -> return (x:y) However this latter case gets stuck in an infinite loop, terminating on a stack overflow. My question asks why this is the case, when laziness should ensure only the first 10 cases need to be computed. If anyone wishes to suggest another way entirely to approach this problem that would also be welcome! Many Thanks, Dave