# Thinking of Monads as imperative languages

Haskell provides `do`

notation, which is syntactic sugar to facilitate imperative programming. The `Monad`

of a `do`

block specifies the *imperative language*, which is typically equipped with *actions* (you might call them verbs of the language).

```
ioExample :: IO ()
ioExample = do
putStr "What is your name? " -- an action which prints to the console
name <- getLine -- an action which retrieves a line from the console
putStrLn "Hello, " ++ name
stateExample :: State Int ()
stateExample = do
x <- get -- an action which retrieves the current state
put (x + 1) -- an action which overrides the current state
```

These examples which I have defined are *actions* themselves. In other words, I have created new verbs in their respective languages, which have a meaning defined as a combination of other actions. We can invoke these actions within a `do`

block of the appropriate language.

```
invokeIOExample :: IO ()
invokeIOExample = do
ioExample
otherIOStuff
invokeStateExample :: State Int ()
stateExample
otherStateStuff
```

Monad laws represent the well-foundedness of refactoring. When definitions are inlined or factored out, the monad laws guarnatee that the meaning stays the same. I won't illustrate this, but it's important to think about if you haven't already.

Monad transformers, then, are language enhancers. They add additional actions to an underlying language. You might call them *language transformers*.

# The Pause transformer

Today we are going to write a monad transformer. This transformer will augment the underlying language with one additional action: `pause`

. This way, we will be able to build (for example) an IO action which can run for a while, and then pause itself when it reaches a checkpoint. At that point, it will produce a new action which can be run to continue where it left off, until the next pause point.

Let's start off simple.

```
data Pause m
= Run (m (Pause m))
| Done
pauseExample1 :: Pause IO
pauseExample1 = Run $ do
putStrLn "Let's begin"
putStrLn "Step 1"
return $ Run $ do
putStrLn "Step 2"
return $ Run $ do
putStrLn "Step 3"
putStrLn "Yay, we're done!"
return Done
```

Fairly simple stuff, though currently a bit crufty. We would like to be able to step these actions, or perhaps we would like to ignore the pauses and run them to completion.

```
data Pause m
= Run (m (Pause m))
| Done
pauseExample1 :: Pause IO
pauseExample1 = Run $ do
putStrLn "Let's begin"
putStrLn "Step 1"
return $ Run $ do
putStrLn "Step 2"
return $ Run $ do
putStrLn "Step 3"
putStrLn "Yay, we're done!"
return Done
-- show Try implementing these
runN :: Monad m => Int -> Pause m -> m (Pause m)
runN = undefined
fullRun :: Monad m => Pause m -> m ()
fullRun = undefined
-- show Check the result
main = do
rest <- runN 2 pauseExample1
putStrLn "=== should print through step 2 ==="
Done <- runN 1 rest
-- remember, IO Foo is just a recipe for Foo, not a Foo itself
-- so we can run that recipe again
fullRun rest
fullRun pauseExample1
```

```
runN :: Monad m => Int -> Pause m -> m (Pause m)
runN 0 p = return p
runN _ Done = return Done
runN n (Run m)
| n < 0 = fail "Invalid argument to runN" -- ewww I just used fail.
| otherwise = m >>= runN (n - 1)
fullRun :: Monad m => Pause m -> m ()
fullRun Done = return ()
fullRun (Run m) = m >>= fullRun
```

Nifty.

# Making Pause a real transformer

We accomplished what we wanted with the earlier code, but the way we had to write `pauseExample1`

was ugly. We want to create a "real" monad transformer, with a `pause`

action. For this example, it is as simple as adding a result to the `Done`

constructor.

```
-- show Given this definition...
import Control.Monad
import Control.Monad.Trans.Class
data PauseT m r
= RunT (m (PauseT m r))
| DoneT r
-- show implement these
instance (Monad m) => Monad (PauseT m) where
-- return :: Monad m => a -> PauseT m a
return a = undefined
-- (>>=) :: Monad m => PauseT m a -> (a -> PauseT m b) -> PauseT m b
DoneT r >>= f = undefined
RunT m >>= f = undefined
instance MonadTrans PauseT where
-- lift :: Monad m => m a -> PauseT m a
lift m = undefined
pause :: Monad m => PauseT m ()
pause = undefined
-- bonus exercise, implement joinP
-- double bonus: without relying on PauseT's monad instance
-- triple bonus: explain in English what joinP *means* for the Pause monad
joinP :: Monad m => PauseT m (PauseT m a) -> PauseT m a
joinP = undefined
-- show ...and see if it compiles.
main = putStrLn "it compiles"
```

UPDATE: Whoops, /r/haskell pointed out that there are problems with this representation of PauseT. Skip down below and see if you can figure out what's wrong. Then, please move on to Part 2 where we will build a better abstraction that obeys laws and works as you'd expect.

```
-- UPDATE: This implementation disobeys MonadTrans laws,
-- and pause isn't quite right.
instance (Monad m) => Monad (PauseT m) where
return a = DoneT a
DoneT r >>= f = f r
RunT m >>= f = RunT $ liftM (>>= f) m
instance MonadTrans PauseT where
lift m = RunT $ liftM DoneT m
pause :: Monad m => PauseT m ()
pause = DoneT ()
```

Great, now we can use `pause`

, and `lift`

anything else from the base language.

```
--/show
import Control.Monad
import Control.Monad.Trans.Class
data PauseT m r
= RunT (m (PauseT m r))
| DoneT r
instance (Monad m) => Monad (PauseT m) where
return a = DoneT a
DoneT r >>= f = f r
RunT m >>= f = RunT $ liftM (>>= f) m
instance MonadTrans PauseT where
lift m = RunT $ liftM DoneT m
pause :: Monad m => PauseT m ()
pause = DoneT ()
--show
example2 :: PauseT IO ()
example2 = do
lift $ putStrLn "Step 1"
pause
lift $ putStrLn "Step 2"
pause
lift $ putStrLn "Step 3"
fullRunT :: PauseT IO r -> IO r
fullRunT (DoneT r) = return r
fullRunT (RunT m) = m >>= fullRunT
runNT :: Int -> PauseT IO r -> IO (PauseT IO r)
runNT 0 p = return p
runNT _ d@DoneT{} = return d
runNT n (RunT m) = m >>= runNT (n - 1)
main = do
fail "your turn"
fail "Fill in this main method with your own experiments"
```

If you don't like all the `lift`

ing, then try using a typeclass like `MonadIO`

. Not always the best idea, but it's an option worth knowing about.

I used the `IO`

monad, because it is fairly easy to understand a prodecural idea like "pause" in those terms. What would PauseT *mean* if it were on top of the State monad? The List monad? Food for thought.

# Enhancements

`PauseT`

adds a way for us to pause ourselves, waiting patiently for whoever is "in charge" to resume us. Who is this mysterious "in charge" person? What if we could communicate with her? Next time, we will learn about coroutines, and elaborate a simple interface for bidirectional communication. (Then we can implement `PauseT`

in terms of this new abstraction, by setting the "to" and "from" fields to the trivial message, `()`

.)