Hi All, I just wrote a function to repeatedly transform something inside a monad using the same transforming function every time. I feel it might be dodgy though: iterateM :: (Monad m) => (a -> m a) -> m a -> m [a] iterateM f sm = sm >>= \s -> iterateM f (f s) >>= \ss -> return (s:ss) The context is that I was trying to write a state machine that responded to keyboard input: data Event = LoYes | LoNo | LoNum -- buttons on your phone | ReYes | ReNo | ReNum -- buttons on his phone data State = State { handler :: Event -> IO State } main = hSetBuffering stdin NoBuffering >> -- so you don't have to hit return iterateM (\st -> getEvent >>= handler st) (return idle) getEvent :: IO Event getEvent = getChar >>= \c -> case c of 'y' -> return LoYes 'n' -> return LoNo '0' -> return LoNum 'Y' -> return ReYes 'N' -> return ReNo '1' -> return ReNum _ -> getEvent idle, ringing, waiting, talking :: State idle = State $ \e -> case e of LoYes -> return idle LoNo -> return idle LoNum -> putStrLn "\tCalling somebody" >> return waiting ReYes -> return idle ReNo -> return idle ReNum -> putStrLn "\tIt's for you-hoo" >> return ringing -- other states similar The reason I'm worried is that this is the second time I've needed such a thing and it seems odd that it's not in the prelude already. Does it leak memory? Does it have a tail recursion problem? Is the functionality I want covered by something else? I guess I could consider [a] to be b in a regular monad but then the (\st -> getEvent >>= handler st) bit would have to juggle lists which seems meaningless. Am I missing something or does everybody else have this iterateM in their personal prelude? TIA, Adrian.