Beyond Monads: Rethinking Effect Composition with Natural Transformations

Article illustration 1

Functional programming has worshipped at the altar of monads for decades, but what if this abstraction is fundamentally limiting our approach to effect composition? In a provocative technical deep dive, Я language designer Murat Kasimov declares: "Monads are overwhelmingly overrated"—and offers a compelling alternative architecture built on granular natural transformations.

Deconstructing the Monad Myth

Kasimov begins by dismantling monads to their categorical foundations: 

η[i]: i → T i          (Unit/return)
μ[i]: T (T i) → T i   (Join/bind)

He demonstrates the famous coherence condition using the Maybe monad, where μ ∘ η must yield identity. But rather than celebrating this structure, he argues:

"Monad is just a functor with two natural transformations and one coherence condition. Instead of using such a packed up term, we should use its contents directly!"

The Composition Problem

The core limitation emerges when combining effects—monads famously don't compose. Traditional solutions like monad transformers force artificial layering:

-- Haskell transformer stack
StateT state (Maybe reason)

Я's solution? Jointed effects (JNT) that interleave effect handlers:

(Stops reason `JNT` State state) i 
≈ Given s (Stops r (Stash s i))

This structure enables unprecedented flexibility through the yok combinator, which dispatches operations without explicit lifting:

x `yok` New `ha` f  -- State operation
x `yok` Try `ha` g  -- Stops operation

Natural Transformations as Primitives

The revolutionary proposal: Ditch monads entirely and directly manipulate natural transformations (ψ) between effect types:

ψ[i]: (World `JNT` Stops r `T'TT'I` World) i → (World `JNT` Stops r) i
ψ[i]: (State s `JNT` Stops r `T'TT'I` Stops r) i → (State s `JNT` Stops r) i

This transforms effect composition from a closed system (monads) to an open one (custom transformations), with binding generalized to:

(`yok`): t a → (a → tt a) → t o

The critical question shifts from "Is this a monad?" to "Does this natural transformation exist?"—liberating developers to build effect systems matching their domain's actual requirements.

Implications for Language Design

Kasimov's approach reflects Я's philosophy of composable primitives over monolithic abstractions. By treating effects as interoperable building blocks rather than rigid monadic containers:

  1. Effect systems gain flexibility for real-world scenarios
  2. New effects integrate without transformer boilerplate
  3. Domain-specific compositions become first-class citizens

As functional programming grapples with complex modern systems—concurrent, distributed, error-prone—this granular paradigm offers a path beyond 40-year-old abstractions. The monad's reign may not be over, but its unquestioned dominance certainly is.

Source: Murat Kasimov's technical article