This article is based on my studies of Monads in Haskell. I will describe what I’ve learned using references and a simple theory aimed at practical applications in Haskell. Monads are rooted in category theory, as they involve concepts such as functors, morphisms, endofunctors, and more.

Background

“Monad is a way of composing embellished functions. It’s not about side effects or state. It’s about composition. [...] embellished functions may be used to express a variety of effects or state¹.”

“Monads were first introduced to computer science by Moggi² and later expanded by Wadler³ to express the semantics of programs with computational effects. Type and effect inference were also introduced to account for these effects⁴.”

“It is well known that purely functional programs are easier to reason about than imperative ones, and one of the first pieces of advice in Kernighan and Pike's The Practice of Programming is 'Be careful with side effects'⁴.”

“There are many equivalent ways of defining a monad¹”, “a monad introduces a type operator $(\mu)$, where $(\mu\tau)$ represents computations returning values of type $(\tau)$. The type $(\mu\tau)$ can be interpreted as an abstract datatype that encapsulates computations returning values of type $(\tau)$. These computations are accessed and manipulated using two fundamental operations: unit and bind⁴.”

Where $(\mu)$ is a monadic operator and $(\tau)$ is a generic type. So, $(\mu\tau)$ indicates a type that represents a computation that eventually returns a value of type $(\tau)$. For example, in Haskell, Maybe Int would be a monad that can compute and return an Int value or nothing.

Unit and Bind

Unit and Bind are fundamental functions of monads. In monadic terms, the unit function (often called return in haskell) is a fundamental building block of a monad and it is expressed as $(\tau \rightarrow \mu \tau)$. It lifts a value of type $(\tau)$ into the monadic context $(m\ \tau)$, transforming it into a computation of type $(\mu\tau)$⁴. In Haskell, it looks like:

return :: a -> m a

This corresponds to the mathematical expression $(\eta: \tau \rightarrow \mu \tau)$. Where $(\mu)$ represents the monadic type constructor m and $(\eta)$ is a natural transformation.

“Bind, sometimes referred to as star, can be represented as $(\mu \tau \rightarrow (\tau \rightarrow \mu \tau') \rightarrow \mu \tau')$. Bind takes a computation of type $(\mu\tau)$ (a computation that eventually returns a value of type $(\tau)$) and a function that transforms the value $(\tau)$ into a new computation of type $(\mu \tau')$. Bind then chains these two computations, passing the result of the first computation to the function that produces the second computation⁴.”

“In Haskell, bind is represented by >>=. The >>= function takes the value from a monad container and passes it to a function to produce a monad container containing a new value, possibly of a different type. The >>= function is known as "bind" because it binds the value in a monad container to the first argument of a function. By adding logic to the binding function, a monad can implement a specific strategy for combining computations in the monad⁵.”

For example, given a Maybe Int and a function f :: Int -> Maybe String, bind allows us to chain these computations to produce a new computation of type Maybe String.

• $\mu \tau$ $=$ represents a monadic value, such as Maybe Int.
• $\tau \rightarrow \mu \tau'$ $=$ is a function that takes an Int and returns a Maybe String.
• $\mu \tau'$ $=$ is the resulting monadic value, Maybe String.

Laws

The laws that define the properties of monads are grounded in category theory because they delve into the realm of categories, endofunctors, and functors. This is a more intricate area, but briefly:

Left Identity $( \mu \circ T\eta = id )$:

When you "lift" a value into the monad's context (using $(\eta)$) and then "flatten" it back down (using $(\mu)$), the final result is just the original value, unchanged.

• $(\mu)$: This "flattens" a nested structure (for example, T (T a) becomes T a).
• $(T\eta)$: Here, $(T)$ is the functor associated with the monad, and $(\eta)$ is the unit (also called return or pure in some contexts). $(T\eta)$ indicates that we first apply the functor $(T)$ to the result of applying the natural transformation $(\eta)$. In other words, $(\eta)$ encapsulates a value into a computation (for example, it turns a into T a), and then $(T)$ is applied to transform it further.
• $(\mu \circ T\eta)$: The composition operator $(\circ)$ denotes function composition. This means we first apply $(T\eta)$ and then apply $(\mu)$ to the result. Concretely, think of it as first applying return and then "flattening" the result.
• $(= id)$: This equation means that the result of this composition is the same as applying the identity function (id), i.e., the original value with no modifications.

return a >>= f  =  f a

Right Identity $( \mu \circ \eta T = id )$:

The idea is that if you encapsulate a value inside the monad's context and then flatten it (using $(\mu)$), the result should be the original value, unchanged. This is a second way to ensure that monads preserve identity.

• $(\eta T)$: Here, $(\eta T)$ means that we first apply the functor $(T)$ to the value and then apply the unit $(\eta)$. In other words, we're encapsulating the value into a computation and then applying the functor to that computation.
• $(\mu \circ \eta T)$: This means we first encapsulate the value using $(\eta)$, apply the functor $(T)$, and then "flatten" it with $(\mu)$.
• $(= id)$: Again, identity means that the final result should be the original value with no modifications.

m >>= return  =  m

Associativity $( \mu \circ T\mu = \mu \circ \mu T )$:

This law ensures that the order in which you apply the flattening operations doesn't matter. You can flatten part of the structure first and then the other part, or flatten everything all at once. The final result will be the same.

• $(T\mu)$: Here, we apply the functor $(T)$ to a computation that has already been flattened once with $(\mu)$. This results in a nested computation.
• $(\mu \circ T\mu)$: First, we apply $(T\mu)$—i.e., use the functor to transform the computation—and then apply $(\mu)$ to flatten it again. This should be equivalent to...
• $(\mu \circ \mu T)$: Here, we apply $(\mu)$ directly, then apply $(T)$ to the resulting computation, before flattening it a second time.

(m >>= f) >>= g  =  m >>= (\x -> f x >>= g)

Haskell Monads

The Monad typeclass includes three essential operations, but for a complete minimal Monad instance, you only need to define the >>= function⁶.

(>>=) :: m a -> (a -> m b) -> m b
(>>) :: m a -> m b -> m b
return :: a -> m a

The ">>" operator

“The >> operator sequences two actions while discarding any resulting value of the first action⁶”. For example, here the >> operator ignores the result of the first action (Just 5), and returns the result of the second action (Just "Second Action").

-- The type signature is:
-- (>>) :: Maybe Int -> Maybe String -> Maybe String
ignm :: Maybe String
ignm = Just 5 >> Just "Second Action"

The ">>=" operator

“The >>= operator is called bind and is — or, at least, comprises — what makes Monad special. Typically, when working with monads, we apply the bind function (>>=). We might use it explicitly, or indirectly through the do notation⁶”.

The bind operator (>>=) is responsible for "chaining" monadic operations, passing the unwrapped value (for example, the value inside Just in the case of Maybe) to the next function, and so forth.

-- (>>=) :: m a -> (a -> m b) -> m b
 
-- Just x     :: Maybe Int            -- m a
-- \a -> ...  :: Int -> Maybe Int     -- a -> m b
-- (>>=)      :: Maybe Int -> (Int -> Maybe Int) -> Maybe Int -- m b
bind :: Int -> Maybe Int
bind x = Just x >>= \a -> Just (a + 1)

The "return" operator

The monadic context in Maybe is the encapsulation of the value in the Just or Nothing constructor. This encapsulation allows the value to be manipulated within a monadic "sequence of operations" without leaving the Maybe context. Therefore, return (x * 2) places the value of x * 2 inside the monadic Maybe context, which is Just.

-- :: Int -> Maybe Int -- Puts the value in the Maybe context (Just)
-- return (x * 2) == Just (x * 2)
justr :: Int -> Maybe Int
justr x = return (x * 2)

Summary

• Monad: It's a context that encapsulates a value (or the absence of it) and handles side effects in a controlled way.
• bind: Unwraps a monad and flattens the result, passing it to another function.
• unit: Puts a value into a monadic context.

There is much more to explore regarding Monads, including a deeper analysis of categories, functors, and Applicative in Haskell, but I will reserve those topics for a future post to maintain the brevity and clarity of this one. Thank you for reading, and should you have any questions or contributions, please submit an issue.