# Monad Transformers Tutorial

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

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

Reminder about "when":

```
when False _ = return ()
when True a = a
```

So, how would you implement "break"?

Another example:

```
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
..
```

Clearly we want something like Maybe's `(>>=)`

here to catch the Nothing, but instead of Maybe values and functions we can combine with `(>>=)`

, we have `IO (Maybe a)`

values. So the "trick" is to implement the `Maybe`

monad again, this time, on `IO (Maybe a)`

values instead of `Maybe a`

values:

```
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)
```

So now we can replace the above boilerplate code with:

```
result <- runMaybeIO $ do
c1 <- MaybeIO $ tryConnect "host1"
c2 <- MaybeIO $ tryConnect "host2"
..
```

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?

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

This wouldn't work, because the type of each statement in our do block is `MaybeIO a`

and not `IO a`

, so a (print "Hello") which is `IO ()`

cannot be put in there. This is where we want to "transform" an `IO a`

value to a `MaybeIO a`

value. All we have to do is convert the `IO a`

to an `IO (Maybe a)`

that doesn't "fail" our Maybe monad. So it just means putting a `Just`

in there:

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

And now we can do:

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

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

```
break :: MaybeIO a
break = MaybeIO $ return Nothing
forM_ [1..maxRetries] $ \ i -> do
response <- transformIOtoMaybeIO $ request i
when (satisfied response) break
```

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 `IO (Maybe a)`

. The only IO operations all of the MaybeIO code performs is return and bind! So let's generalize our MaybeIO definition to all monads:

```
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)
```

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

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

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 `MaybeT`

, we also want `EitherT`

(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 `lift`

operation which is very much like "transformToMaybeT". So if we have:

```
transformToMaybeT :: Monad m => m a -> MaybeT m a
transformToEitherT :: Monad m => m a -> EitherT l m a
```

It seems we can capture this pattern with a class:

```
class MonadTrans t where
lift :: (Monad m) => m a -> t m a
```

And now "t" is our `MaybeT`

(of kind `(* -> *) -> * -> *`

, i.e: two type parameters) and `lift`

is our transformToMaybeT, so:

```
instance MonadTrans MaybeT where
lift = transformToMaybeT
```

Why are they named `Monad Transformers`

? Note the kind signature of instances of the MonadTrans class: `(* -> *) -> (* -> *)`

. That is, every monad transformer type constructor takes a monad (kind `* -> *`

) as an argument, and returns a monad (also `* -> *`

) as a result. So all Monad Transformers are basically type-functions from monad types to different monad types which have additional traits.