Phylum: Monad | Order: Transformer | Family: IO
A fearsome creature whose bind operation chains computations into an inescapable sequence. Beginners who encounter it rarely return unchanged. Known to inhabit the deepest layers of effect systems.
Phylum: Functor | Order: Mappable | Family: Maybe
Poses a single riddle to all who pass: "What can be mapped over?" Those who answer correctly gain the power of fmap. Those who fail are condemned to write Java forever.
Phylum: Optic | Order: Lens | Family: Control.Lens
For every head you sever, two more accessors grow back. Its type signatures alone have driven scholars mad. The creature's many necks reach deep into nested records.
Phylum: Applicative | Order: Liftable | Family: ZipList
Reborn from pure and apply, it lifts functions over structures with effortless grace. Less powerful than the Dragon, yet more elegant. Found nesting in validation libraries.
Phylum: TypeClass | Order: Ad-hoc | Family: Polymorphic
A beast with many heads, each implementing a different interface. Speak Show and it reveals itself; speak Eq and it compares. Its instance declarations echo through the GHC compiler.
Phylum: Evaluation | Order: Non-Strict | Family: Thunk
Vast beyond comprehension yet it moves not until forced. Its infinite body coils through memory, evaluated only where observed. Space leaks trail in its wake like shed scales.
A Scholarly Examination of Composite Creatures
The Monad Transformer Stack (MonadStack giganticus) represents perhaps the most terrifying specimen in our collection. Unlike singular creatures such as the Monad Dragon or the Functor Sphinx, this beast is a composite organism — a towering assembly of monad transformers layered one upon another, each adding new capabilities and new complexity to the whole.
“To understand the Transformer Stack is to understand that every effect is a layer, and every layer is a choice, and every choice has consequences that propagate upward through the entire edifice.”
Consider the canonical example. One begins with the base monad — IO, the primordial creature from which all side effects spring. Upon this foundation, the naturalist layers ReaderT1, providing the creature with an environment it can sense but never alter. Then comes StateT2, granting mutable state — the ability to remember and change. Finally, ExceptT3 crowns the stack, adding the possibility of failure and recovery.
type AppMonad = ExceptT AppError
(StateT AppState
(ReaderT AppConfig
IO))
runApp :: AppConfig -> AppState -> AppMonad a
-> IO (Either AppError a, AppState)
runApp config state app =
runReaderT (runStateT (runExceptT app) state) configThe resulting type signature alone has been known to reduce junior developers to tears. Yet there is an austere beauty to it — each transformer declares its effects explicitly, making the creature's capabilities visible at the type level. The compiler becomes a naturalist's field guide, documenting precisely what each function can and cannot do.
Practitioners of the mtl school4 have developed a technique of abstracting over the concrete stack entirely. Rather than naming the specific layers, one describes only the capabilities required — MonadReader, MonadState, MonadError — allowing the stack to be rearranged or replaced entirely without disturbing the functions that operate within it.
“The true horror of the Transformer Stack is not its complexity, but the dawning realization that it is, in fact, the simplest correct solution.”
Recent expeditions into the territories of algebraic effects and delimited continuations suggest that new species may eventually supplant the Transformer Stack. Libraries such as polysemy and effectful promise a world where effects compose without the notorious n2 instance problem. Yet the Monad Transformer Stack endures, a venerable and well-documented creature, familiar to all who venture into Haskell's depths.
A chronological record of notable creature appearances across Haskell releases.
The original Haskell Report is published. Type classes emerge from the primordial soup of functional programming research.
Monadic I/O officially adopted. Do-notation arrives, taming the Dragon for everyday use.
The Haskell 98 Report is published. A stable taxonomy for all known creatures is established.
Applicative functors enter the standard libraries. A new creature joins the hierarchy.
The lens library begins its ascent. Type signatures of unprecedented length are observed in the wild.
The AMP lands. The natural hierarchy is restored: Functor → Applicative → Monad.
LinearTypes extension ships. New species of resource-tracking creatures begin to appear.