ListT using conduit

ConduitListT.hs

import Control.Applicative
import Control.Monad

import Data.Conduit
import qualified Data.Conduit.List as CL

newtype ListT m a = ListT { runListT :: Producer m a }

instance (Monad m) => Functor (ListT m) where
  fmap f (ListT l) = ListT (l $= CL.map f)

instance (Monad m) => Applicative (ListT m) where
  pure = return
  (<*>) = ap

instance (Monad m) => Monad (ListT m) where
  return x = ListT $ toProducer $ yield x
  l >>= f = ListT $ runListT l $= awaitForever (\x -> runListT $ f x)
  
each :: (Monad m) => [a] -> ListT m a
each xs = ListT $ CL.sourceList xs

asList :: (Monad m) => ListT m a -> m [a]
asList l = runListT l $$ CL.consume


foo :: ListT IO Int
foo = do
  x <- each [1..10]
  y <- each [1..10]
  return (x + y)