Heλλo! Before introduction of IO monad, first versions of Haskell used synchronised streams [1]: main :: [Response] -> [Request] where Response and Request were ADTs containing all possible actions and responses: data Request = ReadFile Name | ... | AppendChan Name String | ... data Response = Success | Str String | Bn Bin | Failure ... I wanted to write an interpreter of this representation using a simplified version: import System.Environment (getArgs) data Response = Success | StrList [String] data Request = GetArgs | PutStr String eval :: Request -> IO Response eval GetArgs = StrList <$> getArgs eval (PutStr s) = putStrLn s >> return Success main' :: [Response] -> [Request] main' ~(StrList args : _) = [ GetArgs, PutStr (show args) ] main :: IO () main = ??? I can imagine how interpreting main' could work, thanks to laziness. However, when actually trying to implement it, I get lost. I cannot figure out how could I read requests (result of calling main') before having something to pass to main'. Having a look at ancient version of GHC [2] didn't help either. Is it actually possible without some low-level tricks? Perhaps using mutually recursive functions? Or by converting to continuations somehow? Thank you! Jiri [1] http://haskell.org/definition/haskell-report-1.0.ps.gz [2] https://downloads.haskell.org/~ghc/0.29/ghc-0.29-src.tar.gz