# Class Monad

Class `Monad`

is defined as follows:

```
-- from Control.Monad that comes with GHC
class Monad m where
-- | Sequentially compose two actions, passing any value produced
-- by the first as an argument to the second.
(>>=) :: forall a b. m a -> (a -> m b) -> m b
-- | Sequentially compose two actions, discarding any value produced
-- by the first, like sequencing operators (such as the semicolon)
-- in imperative languages.
(>>) :: forall a b. m a -> m b -> m b
-- Explicit for-alls so that we know what order to
-- give type arguments when desugaring
-- | Inject a value into the monadic type.
return :: a -> m a
-- | Fail with a message. This operation is not part of the
-- mathematical definition of a monad, but is invoked on pattern-match
-- failure in a @do@ expression.
fail :: String -> m a
{-# INLINE (>>) #-}
m >> k = m >>= \_ -> k
fail s = error s
```

The two key functions are `>>=`

and `return`

. Note that `>>`

, which sequences two actions, is given a default definition at the bottom. Instances of `Monad`

don't have to implement `>>`

if that default definition is okay, which it usually is.

# Reminder about do notation

```
stuff x y z = do
a <- anAction x
b <- anotherAction y z
let c = nifty a b
d <- if c == 0
then narfle a
else burble b
return (a,b,c,d)
```

translates into

```
stuff x y z =
anAction x >>= (\a ->
anotherAction y z >>= (\b ->
let
c = nifty a b
in (if c == 0 then narfle a else burble b) >>= (\d ->
return (a,b,c,d)
) -- end of \d -> ...
) -- end of \b -> ...
) -- end of \a -> ...
```

# What return does and doesn't do

We've seen the `IO`

monad's bind operator already:

```
instance Monad IO where
action1 >>= action2 = ...
-- perform action1, yielding a result x
-- perform (action2 x)
...
```

but `return`

is new. Note the type, `return :: a -> m a`

, so for the `IO`

monad, what `return`

does is produce `x`

, sort of as if it had been read from a file or some other input source, but without actually doing anything to the real world. Here's one reason you might need `return`

:

```
analyzeFile :: FilePath -> IO String
analyzeFile path = do
h <- openFile path ReadMode
result <- ...
hClose h
return result
main = do
result <- analyzeFile "/etc/stuff"
...
```

That is, you want to output something from an action, but you have to perform other actions after the construction of the result but before you consider your action complete. Note that unlike in Python, C, C++, Java, and so many other languages, `return`

is *not* a keyword, it doesn't generally cause exectution to exit from a procedure early, and you don't need it for a function that isn't a monadic action.

# About the unit type and value ()

Haskell functions have to result in some value. There is no `void`

as in C and Java. However, sometimes an action has nothing useful to produce. Haskell's convention is the unit type `()`

which suggests a 0-element tuple. The type of `()`

is also called `()`

. Here's a standard monadic conditional function:

```
when :: Monad m => Bool -> m () -> m ()
when t action =
if t
then action
else return ()
```

If the given test value `t`

is `True`

, perform the action, otherwise, do nothing. And since the result of `when`

may be an action that does nothing and produces nothing, the action you pass it to do when `t == True`

must also produce nothing. (Both branches of an `if`

must have the same type.)

# Famous monad

What follows is a rough sketch of several other monads that are built in to the Haskell standard library. They aren't exactly as I've presented here: I've left out a lot of complications because this article is about the concepts rather covering every tiny nasty little detail. Look at the modules `Control.Monad.*`

for full details and references to research papers and other articles.

## The State monad

### Threading state

Since you generally create new data structures rather than modifying them, it's common to have stuff like this in Haskell:

```
doTheWork x y z =
let
thing0 = ...
(a, thing1) = doStuff x thing0
(b, thing2) = doMoreStuff y thing1
(c, thing3) = doEvenMoreStuff z thing2
in
(..., thing3)
```

Common examples include adding things to a `Data.Set`

or other container, and random number generation.

### An easy random number generator

So, let's write a linear congruential generator. This isn't an especially good generator--Mersenne twister would be better for example--but it'll serve as an example.

```
import Data.Word
data LCGState = LCGState Word32 Word32 Word32 Word32
deriving (Read, Show, Eq, Ord)
-- This is apparently what glibc uses
makeSeed x = LCGState (2 ^ 31) 1103515245 12345 x
nextState :: LCGState -> LCGState
nextState (LCGState m a c x1) = LCGState m a c x2
where x2 = (a * x1 + c) `mod` m
-- | Pull a random number between 0 and 1
nextRandomDouble :: LCGState -> (Double, LCGState)
nextRandomDouble state0 =
let
LCGState m a c x = state0
state1 = nextState state0
in
((fromIntegral x) / (fromIntegral m), state1)
s0 = makeSeed 6502
(y1, s1) = nextRandomDouble s0
(y2, s2) = nextRandomDouble s1
(y3, s3) = nextRandomDouble s2
main = do
print s0
print [y1, y2, y3]
```

It would be nice not to have to keep threading the random seed through all those calculations. It turns out that this type of calculation is handled nicely as a state monad. We want to end up writing stuff like this:

```
pickThree = do
y1 <- pullRandomDouble
y2 <- pullRandomDouble
y3 <- pullRandomDouble
return [y1, y2, y3]
```

### Implementing a state monad for the random generator

This is how to implement a state monad:

```
-- This is a wrapper around a transition function
-- that takes a s(tate) and returns a r(esult) and a new s(tate)
data State s r = State (s -> (r, s))
-- Running a state object on an s is easy, just apply the wrapped function
runState (State f) s = f s
instance Monad (State s) where
-- introduce the result without modifying s
return result = State (\s -> (result, s))
-- compose two transition functions,
-- threading the result of the first into the second
(State fTrans) >>= mkTrans = State hTrans
where
hTrans s0 =
let
(r1, s1) = fTrans s0
State gTrans = mkTrans r1
(r2, s2) = gTrans s1
in
(r2, s2)
```

So now we can do random number generation like this:

```
import Data.Word
data LCGState = LCGState Word32 Word32 Word32 Word32
deriving (Read, Show, Eq, Ord)
-- This is apparently what glibc uses
makeSeed x = LCGState (2 ^ 31) 1103515245 12345 x
nextState :: LCGState -> LCGState
nextState (LCGState m a c x1) = LCGState m a c x2
where x2 = (a * x1 + c) `mod` m
-- | Pull a random number between 0 and 1
nextRandomDouble :: LCGState -> (Double, LCGState)
nextRandomDouble state0 =
let
LCGState m a c x = state0
state1 = nextState state0
in
((fromIntegral x) / (fromIntegral m), state1)
-- This is a wrapper around a transition function
-- that takes a s(tate) and returns a r(esult) and a new s(tate)
data State s r = State (s -> (r, s))
-- Running a state object on an s is easy, just apply the wrapped function
runState (State f) s = f s
instance Monad (State s) where
-- introduce the result without modifying s
return result = State (\s -> (result, s))
-- compose two transition functions,
-- threading the result of the first into the second
(State fTrans) >>= mkTrans = State hTrans
where
hTrans s0 =
let
(r1, s1) = fTrans s0
State gTrans = mkTrans r1
(r2, s2) = gTrans s1
in
(r2, s2)
pullRandomDouble :: State LCGState Double
pullRandomDouble = State nextRandomDouble
pickThree :: State LCGState [Double]
pickThree = do
y1 <- pullRandomDouble
y2 <- pullRandomDouble
y3 <- pullRandomDouble
return [y1, y2, y3]
s0 = makeSeed 6502
(ys, sNext) = runState pickThree s0
main = do
print ys
```

The GHC library includes an implementation of the state monad very much like the one here. See the `Control.Monad.State`

module.

## Exercises

Use this workspace:

```
--show Imports
import Data.Word
import Control.Monad
--/show
--show Random number generator
data LCGState = LCGState Word32 Word32 Word32 Word32
deriving (Read, Show, Eq, Ord)
-- This is apparently what glibc uses
makeSeed x = LCGState (2 ^ 31) 1103515245 12345 x
nextState :: LCGState -> LCGState
nextState (LCGState m a c x1) = LCGState m a c x2
where x2 = (a * x1 + c) `mod` m
-- | Pull a random number between 0 and 1
nextRandomDouble :: LCGState -> (Double, LCGState)
nextRandomDouble state0 =
let
LCGState m a c x = state0
state1 = nextState state0
in
((fromIntegral x) / (fromIntegral m), state1)
--/show
--show State monad
-- This is a wrapper around a transition function
-- that takes a s(tate) and returns a r(esult) and a new s(tate)
data State s r = State (s -> (r, s))
-- Running a state object on an s is easy, just apply the wrapped function
runState (State f) s = f s
instance Monad (State s) where
-- introduce the result without modifying s
return result = State (\s -> (result, s))
-- compose two transition functions,
-- threading the result of the first into the second
(State fTrans) >>= mkTrans = State hTrans
where
hTrans s0 =
let
(r1, s1) = fTrans s0
State gTrans = mkTrans r1
(r2, s2) = gTrans s1
in
(r2, s2)
--/show
--show More friendly random number generation
-- | Generate a random number uniformly between 0 and 1
pullRandomDouble :: State LCGState Double
pullRandomDouble = State nextRandomDouble
-- Your job, see below:
pullRandomBool = undefined
pullDieToss = undefined
pullDieTosses = undefined
--/show
--show Test cases
pickThree :: State LCGState [Double]
pickThree = do
y1 <- pullRandomDouble
y2 <- pullRandomDouble
y3 <- pullRandomDouble
return [y1, y2, y3]
s0 = makeSeed 6502
(ys, sNext) = runState pickThree s0
main = do
print ys
--/show
```

### Flip a coin (Bernouli random variables)

Write a monadic function `pullRandomBool :: Double -> State LCGState Double`

that takes a number q between 0 and 1 and generates `True`

with probability q, and `False`

with probability (1-q).

### Toss a die

Write a monadic function `pullDieToss :: Int -> State LCGState Int`

that takes a number n (= number of sides on the die) and generates a random number between 1 and n, uniformly.

### Many dice

Look up `Control.Monad`

on the Haskell web site. Look for a function called `replicateM`

. Use it to write a function `pullDieTosses :: Int -> Int -> State LCGState [Int]`

that takes a number k and a number n, and generates a list of k rolls of a die with n sides.

## The Maybe monad

Recall that the `Maybe`

type represents something that might not exist, like a pointer that is allowed to be null:

`data Maybe t = Nothing | Just t`

Maybeness also has monadic semantics, and I like to think of the `>>=`

operator as 'feeding' a value to a function. Feeding `Nothing`

to any function results in `Nothing`

. Feeding `Just x`

to a function applies it to `x`

, and the result might be an actual value `Just y`

or `Nothing`

.

```
instance Monad Maybe where
return x = Just x
Nothing >>= f = Nothing
Just x >>= f = f x
```

Using `Maybe`

monadically is a clean way to write a sequence of operations that could fail (resulting in `Nothing`

) at any step.

You can also create an error monad, which is very similar but instead of `Nothing`

, you return something describing the failure. You can use that as a means of throwing and catching exceptions, although Haskell can also do that within the IO monad. See `Control.Monad.Error`

.

## The List monad

A list has monadic sematics, too. If a `Maybe t`

is either one value `Just x`

or `Nothing`

, you can think of a list as zero or more possible values. Returning a value to the list monad produces a list of that one value. Binding a list of possible values to a function means applying that function to each possible value, and building one big list out of all the possible results it returns.

```
instance Monad [] where
return x = [x]
xs >>= f =
concat (map f xs)
```

And actually, the list comprehension notation is transformed into monadic binding during compilation:

```
ns = [1 .. 5]
squares = [n^2 | n <- ns]
squares2 = do
n <- ns
return (n^2)
-- all possible pairings of ns and squares:
pairs = [(n, m) | n <- ns, m <- squares]
-- all possible pairings of ns and squares:
pairs2 = do
n <- ns
m <- squares
return (n, m)
main = do
print ns
print squares
print squares2
print pairs
print pairs2
```

## The Identity monad

Plain old function application is also a monad, called the identity monad. All we have to do is wrap it:

```
data Identity t = Identity t
instance Monad Identity where
return x = Identity x
(Identity x) >>= f = f x
```

Why would you ever both with that? Well...

## Monad transformers

... it turns out there are ways to convert a monad into a *monad transformer*, which then adds properties to another monad. So, there's a `StateT`

that adds a state item to another monad. There's `ErrorT`

that adds exception handling capabilities. So in the Haskell standard libary, the plain old `State`

monad is defined by applying `StateT`

to `Identity`

and `Error`

is defined by applying `ErrorT`

to `Identity`

. There's also a `ListT`

that adds backtracking, `ReaderT`

, `WriterT`

, ... and you can combine them in all sorts of ways.

We don't have time for all of that here.

## ST

The state thread monad `ST`

is kind of like `State`

: It performs sequences of operations that send state around, but the state itself is an abstraction that is never made available. In fact, it's essentially an abstraction of the entire machine memory. The use of `ST`

is more like `IO`

than `Stat`

: It provides a way of sequencing imperative-like operations, such as changing a data structure in place. However, you can run many `ST`

actions in any part of the program, and the actions aren't as strictly ordered as in `IO`

. There's normally only one sequence of `IO`

actions (the `main`

function). And you can peek at `Control.Monad.ST`

and see how GHC implements `IO`

in terms of `ST`

.

The weirdness of `ST`

is a feature called *rank-n types*. In this case it refers to a phantom unspecified type that represents the abstract world state to be threaded, and because of how rank-*n* types work, each call to `runST`

that executes a sequence of `ST`

actions gets its own abstract world state. This bit of madness is needed to make sure that, for example, a mutable array under construction inside `runST`

in one place can't be deallocated by another sequence of actions running inside another `runST`

. (Remember that Haskell can evaluate a program in any order, so it's allowed to do some work on one `ST`

action, then turn its attention to another.)