Monad transformer explained

In functional programming, a monad transformer is a type constructor which takes a monad as an argument and returns a monad as a result.

Monad transformers can be used to compose features encapsulated by monads – such as state, exception handling, and I/O – in a modular way. Typically, a monad transformer is created by generalising an existing monad; applying the resulting monad transformer to the identity monad yields a monad which is equivalent to the original monad (ignoring any necessary boxing and unboxing).

Definition

A monad transformer consists of:

1. A type constructor t of kind (* -> *) -> * -> *
2. Monad operations return and bind (or an equivalent formulation) for all t m where m is a monad, satisfying the monad laws
3. An additional operation, lift :: m a -> t m a, satisfying the following laws:^[1] (the notation `bind` below indicates infix application):
   1. lift . return = return
   2. lift (m `bind` k) = (lift m) `bind` (lift . k)

Examples

The option monad transformer

Given any monad

M A , the option monad transformer M \left( A ^{?} \right) (where A ^{?} denotes the option type) is defined by:\begin{array}{ll} return : & A \rarr M \left( A ^{?} \right) = a \mapsto return ( Just a) \\ bind : & M \left( A ^{?} \right) \rarr \left( A \rarr M \left( B ^{?} \right) \right) \rarr M \left( B ^{?} \right) = m \mapsto f \mapsto bind m \left(a \mapsto \begin{cases} returnNothing & if a = Nothing \ f a' & if a = Just a' \end{cases} \right) \\ lift : & M (A) \rarr M \left( A ^{?} \right) = m \mapsto bind m (a \mapsto return ( Just a)) \end{array}

The exception monad transformer

Given any monad

M A , the exception monad transformer M (A + E) (where is the type of exceptions) is defined by:\begin{array}{ll} return : & A \rarr M (A + E) = a \mapsto return ( value a) \\ bind : & M (A + E) \rarr (A \rarr M (B + E)) \rarr M (B + E) = m \mapsto f \mapsto bind m \left( a \mapsto \begin{cases} returnerr e & if a = err e\ f a' & if a = value a' \end{cases} \right) \\ lift : & M A \rarr M (A + E) = m \mapsto bind m (a \mapsto return ( value a)) \\ \end{array}

The reader monad transformer

Given any monad

M A , the reader monad transformer E \rarr M A (where is the environment type) is defined by:\begin{array}{ll} return : & A \rarr E \rarr M A = a \mapsto e \mapsto return a \\ bind : & (E \rarr M A) \rarr (A \rarr E \rarr M B) \rarr E \rarr M B = m \mapsto k \mapsto e \mapsto bind (m e) ( a \mapsto k a e) \\ lift : & M A \rarr E \rarr M A = a \mapsto e \mapsto a \\ \end{array}

The state monad transformer

Given any monad

M A , the state monad transformer S \rarr M (A x S) (where is the state type) is defined by:\begin{array}{ll} return : & A \rarr S \rarr M (A x S) = a \mapsto s \mapsto return (a, s) \\ bind : & (S \rarr M (A x S)) \rarr (A \rarr S \rarr M (B x S)) \rarr S \rarr M (B x S) = m \mapsto k \mapsto s \mapsto bind (m s) ((a, s') \mapsto k a s') \\ lift : & M A \rarr S \rarr M (A x S) = m \mapsto s \mapsto bind m (a \mapsto return (a, s)) \end{array}

The writer monad transformer

Given any monad

M A , the writer monad transformer M (W x A) (where is endowed with a monoid operation with identity element \varepsilon ) is defined by:\begin{array}{ll} return : & A \rarr M (W x A) = a \mapsto return (\varepsilon, a) \\ bind : & M (W x A) \rarr (A \rarr M (W x B)) \rarr M (W x B) = m \mapsto f \mapsto bind m ((w, a) \mapsto bind (f a) ((w', b) \mapsto return (w * w', b))) \\ lift : & M A \rarr M (W x A) = m \mapsto bind m (a \mapsto return (\varepsilon, a)) \\ \end{array}

The continuation monad transformer

Given any monad

M A , the continuation monad transformer maps an arbitrary type into functions of type (A \rarr M R) \rarr M R , where is the result type of the continuation. It is defined by:\begin{array}{ll} return \colon & A \rarr \left( A \rarr M R \right) \rarr M R = a \mapsto k \mapsto k a \\ bind \colon & \left( \left( A \rarr M R \right) \rarr M R \right) \rarr \left( A \rarr \left( B \rarr M R \right) \rarr M R \right) \rarr \left( B \rarr M R \right) \rarr M R = c \mapsto f \mapsto k \mapsto c \left( a \mapsto f a k \right) \\ lift \colon & M A \rarr (A \rarr M R) \rarr M R = bind \end{array} Note that monad transformations are usually not commutative: for instance, applying the state transformer to the option monad yields a type S \rarr \left(A x S \right) ^{?} (a computation which may fail and yield no final state), whereas the converse transformation has type S \rarr \left(A ^{?} x S \right) (a computation which yields a final state and an optional return value).

See also

• Monads in functional programming

External links

• A highly technical blog post briefly reviewing some of the literature on monad transformers and related concepts, with a focus on categorical-theoretic treatment

Notes and References

1. Sheng . Liang . Hudak, Paul . Jones, Mark . Monad transformers and modular interpreters . Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages . 333–343 . ACM . 1995 . New York, NY . PDF . 10.1145/199448.199528. free .