Monad Lecture 2024-02-05

A monad is an interface.

public interface Monad<T> {
    <R> Monad<R> thread(Function<T, Monad<R>> f);
    Monad<T> wrap(T value);
}

class Monad m where
    thread :: m a -> (a -> m b) -> m b
    wrap :: a -> m a

Any type can become a monad, provided it implements this interface.

data Foo a = Foo a
  deriving (Show)

instance Functor Foo where
  fmap f (Foo a) = Foo $ f a

instance Applicative Foo where
  pure = Foo
  (Foo a) <*> x = fmap a x

instance Monad Foo where
  return = pure
  Foo x >>= f = f x

Turns out, monads are also functors and applicatives—never mind—just know that they also need to implement fmap and <*> as well.

Let’s start with the functor part: a functor is a fancy name for a container that you can map over. In Haskell land, we call this function fmap, but you can think of just implementing map.

What are applicatives? These generalize function application to work with things other than functions. You need two functions: pure, which just takes a value and wraps it in the data type, and apply or <*>.

An effect is any observable behavior other than the return value.

Question: What are some effects?

• failure/exception
• IO
• modifying state

Question: Why do you think effects might be something we want to worry about?

• Breaks local reasoning
• Side-effect-free functions are easier to test and compose
• Easier to reason about under concurrency
• Optimizations available
• etc.

Monads let us encode effects; let’s take a look at an example

data Maybe a = Nothing | Just a

instance Monad Maybe where
    return         = Just
    Nothing  >>= f = Nothing
    (Just x) >>= f = f x

instance MonadFail Maybe where
    fail _         = Nothing

instance MonadPlus Maybe where
    mzero             = Nothing
    Nothing `mplus` x = x
    x `mplus` _       = x

Monads are also useful to restrict access to a value outside a particular context.

Question: What have we gained by implementing Maybe?

Implementing a generic return is a little tricker if all we have are interfaces.

We can use custom constructors—not as nice as return because we have to know exactly what monad it is we are operating in.

Rust doesn’t have typeclasses, but that doesn’t mean we can’t have Monads. Result and Option are monads!

Fun fact, Java’s optional breaks the monad laws by not being able to have null inside an optional.

Second option: delay wrapping. Racket’s monad library works by delaying what functor it uses with pure. From the docs:

Lifts a plain value into an applicative functor. When initially called, this function simply places the value in a box because it cannot yet know what kind of functor it needs to produce. When used, the value will be coerced into a functor of the appropriate type using the relevant value’s pure method.

https://docs.racket-lang.org/functional/interfaces.html#%28def._%28%28lib._data%2Fapplicative..rkt%29._pure%29%29

This:

do
  x <- Just 42
  y <- Just (x + 1)
  Just (y * 2)

is the same as this:

Just 42 >>= (\x -> (Just (x + 1)) >>= (\y -> Just (y * 2)))

• liftM
• fmap
• <*> (from the Applicative type class)
• (Monad m) => m (m a) → m a join (fmap f m) ≡ m >>= f
• filterM
• mapM
• foldM

liftM :: Monad m => (a1 -> r) -> m a1 -> m r
fmap :: Functor f => (a -> b) -> f a -> f b
(<*>) :: Applicative f => f (a -> b) -> f a -> f b
join :: Monad m => m (m a) -> m a
mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b