View source for Monad Transformers Tutorial

Think about code in IO that needs to be able to break out of a loop:

<haskell>
forM_ [1..maxRetries] $ \i -> do
  response <- request i
  when (satisfied response) break
</haskell>

Reminder about "when":

<haskell>
when False _ = return ()
when True a = a
</haskell>

So, how would you implement "break"?

Another example:

<haskell>
do
  mc1 <- tryConnect "host1"
  case mc1 of
    Nothing -> return Nothing
    Just c1 -> do
      mc2 <- tryConnect "host2"
      case mc2 of
        Nothing -> return Nothing
        Just c2 -> do
          ..
</haskell>

Clearly we want something like Maybe's <hask>(>>=)</hask> here to catch the Nothing, but instead of Maybe values and functions we can combine with <hask>(>>=)</hask>, we have <hask>IO (Maybe a)</hask> values. So the "trick" is to implement the <hask>Maybe</hask> monad again, this time, on <hask>IO (Maybe a)</hask> values instead of <hask>Maybe a</hask> values:

<haskell>
newtype MaybeIO a = MaybeIO {
   runMaybeIO :: IO (Maybe a)
}

instance Monad MaybeIO where
  return x = MaybeIO (return (Just x))
  MaybeIO action >>= f = MaybeIO $ do
    result <- action
    case result of
      Nothing -> return Nothing
      Just x -> runMaybeIO (f x)
</haskell>

So now we can replace the above boilerplate code with:

<haskell>
result <- runMaybeIO $ do
  c1 <- MaybeIO $ tryConnect "host1"
  c2 <- MaybeIO $ tryConnect "host2"
  ..
</haskell>

Or if the tryConnect function wrapped its result in MaybeIO then we just have to use runMaybeIO there, and that's it. What happens if we now have some "print" in between?

<haskell>
result <- runMaybeIO $ do
  c1 <- MaybeIO $ tryConnect "host1"
  print "Hello"
  c2 <- MaybeIO $ tryConnect "host2"
  ..
</haskell>

This wouldn't work, because the type of each statement in our do block is <hask>MaybeIO a</hask> and not IO a, so a (print "Hello") which is <hask>IO ()</hask> cannot be put in there. This is where we want to "transform" an <hask>IO a</hask> value to a <hask>MaybeIO a</hask> value. All we have to do is convert the <hask>IO a</hask> to an <hask>IO (Maybe a)</hask> that doesn't "fail" our Maybe monad. So it just means putting a <hask>Just</hask> in there:

<haskell>
transformIOtoMaybeIO :: IO a -> MaybeIO a
transformIOtoMaybeIO action = MaybeIO $ do
  result <- action
  return (Just result)
</haskell>

And now we can do:

<haskell>
result <- runMaybeIO $ do
  c1 <- MaybeIO $ tryConnect "host1"
  transformIOtoMaybeIO $ print "Hello"
  c2 <- MaybeIO $ tryConnect "host2"
  ..
</haskell>

Now we can also break from the first example's loop!

<haskell>
break :: MaybeIO a
break = MaybeIO $ return Nothing

forM_ [1..maxRetries] $ \  i -> do
  response <- transformIOtoMaybeIO $ request i
  when (satisfied response) break
</haskell>

But, all of this code, while useful, is not in Haskell's spirit. Because MaybeIO really could work for any monad wrapping the Maybe, not just <hask>IO (Maybe a)</hask>. The only IO operations all of the MaybeIO code performs is return and bind! So let's generalize our MaybeIO definition to all monads:

<haskell>
newtype MaybeT m a = MaybeT {
   runMaybeT :: m (Maybe a)
}
instance Monad m => Monad (MaybeT m) where
  return x = MaybeT (return (Just x))
  MaybeT action >>= f = MaybeT $ do
    result <- action
    case result of
      Nothing -> return Nothing
      Just x -> runMaybeT (f x)
</haskell>

That was easy! I just replaced MaybeIO with MaybeT, IO with m, and added an "m" type parameter (with Monad constraint).

<haskell>
transformToMaybeT :: Monad m => m a -> MaybeT m a
transformToMaybeT action = MaybeT $ do
  result <- action
  return (Just result)
</haskell>

Again, really easy, just syntactic replacement of IO with a type parameter. Now, this "transformToMaybeT" operation is really common, because we don't just have <hask>MaybeT</hask>, we also want <hask>EitherT</hask> (when you want to break out of the loop or fail with a result!), ContT (lets you do really crazy things), ListT and many others. All of these have in common a <hask>lift</hask> operation which is very much like "transformToMaybeT". So if we have:

<haskell>
transformToMaybeT :: Monad m => m a -> MaybeT m a
transformToEitherT :: Monad m => m a -> EitherT l m a
</haskell>

It seems we can capture this pattern with a class:

<haskell>
class MonadTrans t where
    lift :: (Monad m) => m a -> t m a
</haskell>

And now "t" is our <hask>MaybeT</hask> (of kind <hask>(* -> *) -> * -> *</hask>, i.e: two type parameters) and <hask>lift</hask> is our transformToMaybeT, so:

<haskell>
instance MonadTrans MaybeT where
    lift = transformToMaybeT
</haskell>

Why are they named <hask>Monad Transformers</hask>? Note the kind signature of instances of the MonadTrans class:  <hask>(* -> *) -> (* -> *)</hask>. That is, every monad transformer type constructor takes a monad (kind <hask>* -> *</hask>) as an argument, and returns a monad (also <hask>* -> *</hask>) as a result.  So all Monad Transformers are basically type-functions from monad types to different monad types which have additional traits.