Edit Question - KnowledgeHub

Title Body

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 compos

Tags (comma-separated) Cancel