A topic in the Open Knowledge Graph — a free, open map of 15,290 topics and the order to learn them in.
A monad on a category C is a functor T: C → C together with two natural transformations: unit η: Id_C ⇒ T and multiplication μ: T∘T ⇒ T, satisfying associativity and unit laws analogous to those of a monoid (μ∘Tμ = μ∘μT and μ∘Tη = id_T = μ∘ηT). Every adjunction F ⊣ G gives a monad T = G∘F; conversely, every monad arises from an adjunction in (at least) two canonical ways via the Kleisli and Eilenberg-Moore categories. Monads appear throughout mathematics (algebras, closure operators) and computer science (sequencing effects in functional programming).
Derive the monad T = U∘F from the free-forgetful adjunction for groups: T(S) = underlying set of the free group on S. Identify the unit (inclusion of S into T(S)) and multiplication (the group homomorphism μ_S: T(T(S)) → T(S) given by the universal property). Verify the monad laws.
From your study of adjunctions, you know that an adjunction F ⊣ G consists of a pair of functors going in opposite directions with a natural bijection Hom(FA, B) ≅ Hom(A, GB). Every adjunction automatically produces a monad. The composite functor T = G ∘ F: C → C is an endofunctor. The adjunction unit η: Id_C ⇒ GF gives the monad's unit — a way to embed any object into its "T-context." The adjunction counit ε: FG ⇒ Id_D combines with G to give the monad's multiplication μ = GεF: GFGF ⇒ GF, which is a natural transformation μ: T² ⇒ T that "flattens" two layers of T into one. The triple (T, η, μ) is a monad.
The monad laws mirror monoid laws — because a monad is precisely a monoid in the category of endofunctors. The associativity law μ ∘ Tμ = μ ∘ μT says it doesn't matter whether you collapse the outer or inner layer of T² first when flattening T³ to T. The unit laws μ ∘ Tη = id_T = μ ∘ ηT say that embedding into T and then flattening gets you back to where you started. These are not trivially satisfied — they must be verified, and they encode genuine coherence. The free-forgetful adjunction for groups is the paradigm case: T(S) is the underlying set of the free group on S, η_S embeds elements of S as generators, and μ_S collapses a free group on free-group elements into a single free group by composing generators.
The Kleisli category C_T is the canonical construction built from a monad. Its objects are the objects of C. A Kleisli morphism from A to B is a C-morphism A → TB — an arrow that computes a "T-decorated" output. Kleisli composition is: to compose (A → TB) and (B → TC), apply T to the second, then compose with multiplication μ_C: T(TC) → TC. This formalizes the idea of "chaining T-computations." In Haskell, the Kleisli morphisms are exactly monadic computations: `a -> m b`, Kleisli composition is `>>=` (bind), the unit η is `return`, and the monad laws are the laws of `>>=`. The Kleisli category makes the connection between category-theoretic and programming-theoretic monads precise — Haskell's Monad typeclass is literally the Kleisli structure for a particular category.
What makes monads powerful is that they unify an enormous range of apparently different constructions. The maybe monad (T(A) = A + {Nothing}) models partial functions and failure propagation. The list monad (T(A) = List(A)) models nondeterminism — choosing among multiple possibilities. The state monad (T(A) = S → (A × S)) models stateful computation. The continuation monad (T(A) = (A → R) → R) models control flow. In each case, η embeds a pure value into the computational context, and μ flattens nested computations. The Eilenberg-Moore category (the other canonical construction from a monad) goes in the opposite direction: its objects are T-algebras — objects A equipped with a structure map α: TA → A satisfying coherence laws — and it recovers the original algebra (groups, rings, etc.) from the free-forgetful adjunction. The monad thus sits at the intersection of abstract algebra, categorical structure theory, and programming language semantics.