Short overview of monads

(or, a few different views of monads)

So, what is a monad?
Monads are just burritos

http://chrisdone.com/posts/monads-are-burritos
 Monad is an interface

Fits well into modeling some problems

passing some additional context around: IO, (mutable) state,
exceptions, concurrency (async code and futures)

Components
datatype and encapsulation
composable functions
monad laws

Actions
sequential (daisy) chaining
provides do notation
Can model imperative aspects of programming
Can combine pure and unpure code
 Main part of the monad definition
Bind
class Monad m where
(>>=) :: m a -> (a -> m b) -> m b

*Pictures taken from very nice pictorial explanations of monads given in this blog post
 Maybe/Option
Maybe type
as a monad

wrap a computation inside it

half x = if even x
then Just (x `div` 2)
else Nothing

cannot be applied directly

half $ Just 3
 Maybe monad, bind
We need bind
instance Monad Maybe where
Nothing >>= func = Nothing
Just val >>= func = func val

Handles both cases

of Maybe
 Maybe, chaining
Successive applications of our computation

> Just 20 >>= half >>= half >>= half

Nothing
 Handling unpure code
Haskell is a purely functional language
Mechanism for handling unpure code
side effects
state and mutations
Solution? Encapsulate unpure things
into a monad
use bind to effectively combine it with pure code
Once you have unpure code, you cannot escape
contrast with, e.g. Maybe monad
the concept of escaping a monad
 IO monad
Like others, but also special
Provided operations
getLine :: IO String
readFile :: FilePath -> IO String
putStrLn :: String -> IO ()
unit type
getLine >>= readFile >>= putStrLn (eff. no value)

foo = do
filename <- getLine
contents <- readFile filename
putStrLn contents
 Benefits of the interface
data Expr = Val Int | Div Expr Expr > eval (Div (Val 4) (Val 2))
2

we want to write
this evaluator
 Benefits of the interface
data Expr = Val Int | Div Expr Expr > eval (Div (Val 1) (Val 0))
*** Exception: divide by zero
eval :: Expr -> Int
eval (Val n) = n
eval (Div x y) = eval x div eval y we want to
avoid this error

simple
implementation
 Benefits of the interface
data Expr = Val Int | Div Expr Expr
eval :: Expr -> Int
eval (Val n) = n
eval (Div x y) = eval x div eval y
> eval (Div (Val 1) (Val 0))
*** Exception: divide by zero
safediv :: Int -> Int -> Maybe Int
safediv _ 0 = Nothing
safediv n m = Just (n div m)

eval :: Expr -> Maybe Int

eval (Val n) = Just n Our evaluator with a safe
eval (Div x y) = case eval x of division, as a monad
Nothing -> Nothing
Just n -> case eval y of
Nothing -> Nothing
Just m -> safediv n m

> eval (Div (Val 1) (Val 0))

Nothing
 Benefits of the interface
data Expr = Val Int | Div Expr Expr > eval (Div (Val 1) (Val 0))
*** Exception: divide by zero
eval :: Expr -> Int
eval (Val n) = n safediv :: Int -> Int -> Maybe Int
eval (Div x y) = eval x div eval y safediv _ 0 = Nothing
safediv n m = Just (n div m)

eval :: Expr -> Maybe Int

eval (Val n) = Just n
eval (Div x y) = case eval x of
Nothing -> Nothing eval :: Expr -> Maybe Int
Just n -> case eval y of eval (Val n) = Just n
Nothing -> Nothing eval (Div x y) =
Just m -> safediv n m do n <- eval x
m <- eval y
> eval (Div (Val 1) (Val 0)) safediv n m
Nothing do notation makes it
a bit more concise
 Rest of the interface
Full Interface (>>=) :: forall a b. m a -> (a -> m b) -> m b
(>>) :: forall a b. m a -> m b -> m b
return :: a -> m a
fail :: String -> m a

Pattern matching
might fail
do { action1 x1
; mk_action3 x1 x2 }
do { True <- action1 x1
; x2 <- action2 do { putString(Hello)
; action3 x1 x2 } putString(World)
return () }

Fail is called
action1 x1 >>= f >>
where similar to bind
f True = do { x2 <- action2; mk_action3 x1 x2 } but does not use value
f_ = fail "..." -- A compiler-generated message.
 Monad laws
Left identity: return a >>= k =ka
Right identity:
m >>= return =m
which gives us

do { x <- return x; f x } do { f x }

identity law says two are equivalent

Associativity
gives us m >>= (\x -> k x >>= h) = (m >>= k) >>= h
do do
y <- do
x <- m x <- m
equivalent due to
y <- k x <=> k x
h y h y associativity law

Note that developers need to ensure laws hold

Monad types
Writer monad
(similar to the one given in lectures)

Reader monad

State monad
 Writer monad
Example of using writer monad
data Writer w a = Writer { runWriter :: (a, w) }

half :: Int -> Writer String Int

half x = do
tell ("I just halved " ++ (show x) ++ "!")
return (x `div` 2)

runWriter $ half 8 >>= half

=> (2, "I just halved 8!I just halved 4!")