Intuition: Monads for Structuring Programs

Monads were initially introduced to express input/output programs in a nicer way. Imagine we would like to write the following program in Haskell:

display the user a message: "Provide me a word> "
read the word (input)
decide if the given word is a palindrome:
- display the following message if it is: "A palindrome."
- otherwise display this one instead: "Not a palindrome."

An option to do so is to work with an explicit parameter that represents a global state, called World. This global state is to contain the actual state of the computer’s memory, so it can be used to get the contents of the keyboard’s input buffer so as to put messages on the screen.

Consider we have the following functions available:

-- display a message on the screen
putStr  :: String -> World -> World
-- read a line from the keyboard
getLine :: World -> (String, World)

So the program would be something like this:

($) :: (a -> b) -> a -> b
f $ x = f x

program :: World -> World
program w =
  (\(s, w) ->
    if (s == reverse s)
      then putStr "A palindrome." w
      else putStr "Not a palindrome." w) $
  getLine $
  putStr "Provide me a word> " $ w

But this may appear inconvenient as everything has to be written backwards due to the regular function composition. Let us flip the composition:

(|>) :: a -> (a -> b) -> b
x |> f = f x

program' :: World -> World
program' w = w |>
  putStr "Provide me a word> " |>
  getLine |> \(s, w) ->
  if (s == reverse s)
    then putStr "A palindrome." w
    else putStr "Not a palindrome." w

The situation may be improved further by making the w parameter (of type World) implicit.

type IO a = World -> (a, World)

Let us rewrite the flipped composition operation to handle the implicit parameter.

(>>=) :: IO a -> (a -> IO b) -> IO b
(f >>= g) w = (g x) w'
  where (x, w') = f w

Sometimes the result of the IO a function could be ignored as it would be unit (()). Hence a derived operator is introduced in addition.

(>>) :: IO a -> IO b -> IO b
f >> g = f >>= \_ -> g

Now the whole program can be rewritten like that:

putStr  :: String -> IO ()
getLine :: IO String

program'' :: IO ()
program'' =
  putStr "Provide me a word> " >>
  getLine >>= \s ->
  if (s == reverse s)
    then putStr "A palindrome."
    else putStr "Not a palindrome."

Note that the type of program'' is IO (), which basically resolves to World -> ((), World). That is, something has to provide an initial state that the program could pass along. Given that it is the global state of the entire program, this could be only done by the run-time system.

But that is it! For comparison, observe the corresponding real-life Haskell program.

main :: IO ()
main = do
  putStr "Provide me a word> "
  s <- getLine
  if (s == reverse s)
    then putStr "A palindrome."
    else putStr "Not a palindrome."

Further Monads by Examples

But monads are more than just that. Monads represent computations that have to be run in order to get their results and the associated side effect. For IO, the run function is hidden, but that is because IO is special. All the other monads are not.

type State s a = s -> (a, s)

--       (s -> (a, s)) -> (a -> (s -> (b, s))) -> (s -> (b, s))
(>>=) :: State s a     -> (a -> State s b)     -> State s b
(x >>= f) s = (f v) s'
  where (v, s') = x s

--        a -> (s -> (a, s))
return :: a -> State s a
(return x) s = (x, s)

--     s -> (s, s)
get :: State s s
(get) s = (s, s)

--     s -> ((), s)
put :: s -> State s ()
(put x) s = ((), x)

--          (s -> (a, s)) -> s -> (a, s))
runState :: State s a     -> s -> (a, s))
runState f s = f s

--           Int -> (Int, Int)
testState :: State Int Int
testState =
  put 3 >>
  get >>= \x ->
  put (x + 1) >>
  get >>= \y ->
  return (y + 1)

type Reader e a = e -> a

--       (e -> a)   -> (a -> (e -> b))   -> (e -> b)
(>>=) :: Reader e a -> (a -> Reader e b) -> Reader e b
(x >>= f) e = f (x e) e

--        a -> (e -> a)
return :: a -> Reader e a

--     e -> e
ask :: Reader e e
(ask) e = e

--           (e -> a)   -> e -> a
runReader :: Reader e a -> e -> a
runReader f e = f e

testReader :: Reader (Int,Int) String
testReader =
   ask >>= \(x,y) ->
   if (x < y)
     then return "lesser than"
     else return "greater than"

data Maybe a = Just a | Nothing

(>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b
(Just x) >>= f = f x
Nothing  >>= f = Nothing

return :: a -> Maybe a
return x = Just x

testMaybe :: Maybe Int
testMaybe =
  Just 3 >>= \x ->
  Just 4 >>= \y ->
  return (x + y)

testMaybe' :: Maybe Int
testMaybe' =
  Just 3  >>= \x ->
  Nothing >>= \y ->
  return (x + y)

data [a] = a : [a] | []

(>>=) :: [a] -> (a -> [b]) -> [b]
[]     >>= f = []
(x:xs) >>= f = (f x) ++ (xs >>= f)

return :: a -> [a]
return x = [x]

testList :: [(Integer, Integer, Integer)]
testList =
  [1,2]     >>= \x ->
  [10,20]   >>= \y ->
  [100,200] >>= \z ->
  return (x, y, z)

type Identity a = a

--       a          -> (a -> b)          -> b
(>>=) :: Identity a -> (a -> Identity b) -> Identity b
x >>= f = f x

--        a -> a
return :: a -> Identity a
return x = x

--             a          -> a
runIdentity :: Identity a -> a
runIdentity x = x

testIdentity :: Identity Int
testIdentity =
  return 1 >>= \x ->
  return 2 >>= \y ->
  return (x + y)

The Monad Type Class

All the operations used in the previous examples can be summarized in the following type class definition.

class Monad m where
  return :: a -> m a
  (>>=)  :: m a -> (a -> m b) -> m b
  -- minimum complete base

  (>>)   :: m a -> m b -> m b
  f >> g = f >>= \_ -> g

  fail   :: String -> m a
  fail s = error s

The fail function is an addition that will be covered below.

The do Notation

The do notation is a special syntax implemented to express monadic computations in a more convenient way. Any type that is instance of the Monad class may use this.

Rules of translation:

do { e1; e2 }          -->  e1 >> do { e2 }

do { p <- e1; e2 }     -->  e1 >>= \x -> case x of p -> do { e2 }
                                                   _ -> fail "error"

do { let p = e1; e2 }  -->  let p = e1 in do { e2 }

do { e }               -->  e

The >>= is often called the “programmable semicolon” as the actual semantics is determined by the underlying Monad instance. The fail function is used to interrupt the run of the computation, which could be also overloaded by the actual instance.

The use of semicolons is not a requirement, whole do blocks may be composed by proper indentation (that is, the off-side rule). That is, the following block

do { x <- f; y <- g; z <- h; let t = (x,y,z); return t }

is the same as the one below:

do x <- f
   y <- g
   z <- h
   let t = (x, y, z)
   return t

while it is the same as the composition of the corresponding monadic actions below:

f >>= \x ->
g >>= \y ->
h >>= \z ->
let t = (x, y, z) in
return t

Monad Laws

In order to use them properly, all the Monad instances shall obey the following rules:

• left identity:

   do x <- m            ===    do m
      return x

• right identity:

   do y <- return x     ===    do f x
      f y

• associativity:

   do y <- do x <- m    ===    do x <- m      ===    do x <- m
              f x                 y <- f x              do y <- f x
      g y                         f y                      g y

Using the “Kleisli fish” symbol (>=>), the rules become more evident.

(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> (a -> m c)
(f >=> g) x = f x >>= g

That is:

return >=> f     ===   f                (left identity)
f >=> return     ===   f                (right identity)
(f >=> g) >=> h  ===   f >=> (g >=> h)  (associativity)

Failing to satisfy the laws, the compiler may optimize the given Monad type wrongly. Note that the compiler cannot check for those laws, this has to be done by the programmer.

Adding Instances for the Monad Class

Note that the earlier definitions of the example monads use the same symbol. That is why the Monad type class was created, so they can be now overloaded for each of the types. However, Reader, State, and Identity all represented as functions. Thus neither of them cannot be added as an instance without overlapping with the others.

To work this limitation around, newtype wrappers have to be created. For example, the wrapper and the corresponding Monad instance would be the following for Identity:

newtype Identity a = Identity a

instance Monad Identity where
  return x = Identity x
  x >>= f = f (runIdentity x)

runIdentity :: Identity a -> a
runIdentity (Identity x) = x