a subaqueous meditation on pure abstraction
We begin at the surface where light still reaches — where a program is merely a specification, and the sea is calm enough to see through to the sand. Here, lambdas are still small: they flicker in the shallows like silver fry.
greet :: String -> String
greet name = "hello, " ++ name"pure functions are fish that never rot —
they return the same scale in the same light, forever."
An expression may be replaced by its value. Nothing in the tide pool remembers being disturbed.
data Maybe a
= Nothing
| Just aThe simplest sea creature: a box that may be empty. It teaches us to ask before we assume.
Haeckel drew 4,000 species
of radiolarians by hand.
Not one of them IO.
Before the descent, pause. The eye adjusts. The ear adjusts. The breath adjusts. Reading a type signature, like watching a kelp frond, is an act of patience: only after long observation does the whole shape become intelligible.
fmap :: Functor f => (a -> b) -> f a -> f bA layer of sudden cold, where the easy surface metaphors stop working and the sea reveals it has been composing itself all along. Here, the first monad arrives — not as an abstraction but as a rhythm of dependent steps.
(>>=) :: m a -> (a -> m b) -> m bclass Functor f where
fmap :: (a -> b)
-> f a
-> f b
class Functor f
=> Applicative f where
pure :: a -> f a
(<*>) :: f (a -> b)
-> f a
-> f ban applicative is a functor
that has learned to hold
its own breath.
We lift pure values into the current. We zip two floating things and make them speak.
A shape that performs. The only vertebrate in the phylum.
do
name <- readLine
depth <- sense
pure (descend name depth)Each line is a frond. The frond above cannot see the frond below — it only yields, and trusts.
the compiler is a very
patient marine biologist.
fmap id = id
fmap (f . g) = fmap f . fmap gIdentity. Composition. Two laws, no more, no less — a coral the right size.
This sentence is a joke and a theorem simultaneously. The deeper you go, the less it matters which.
newtype StateT s m a
= StateT
{ runStateT ::
s -> m (a, s) }
instance Monad m
=> Monad (StateT s m)
where
return a = StateT $
\s -> return (a, s)A transformer stack is a column of organisms, each one breathing what the one below it exhales.
The continuation monad swims sideways through time. It eats its own call-stack.
The deep produces its own light. A type signature at this depth does not describe behavior — it is the behavior, glowing faintly from within the compiler's darkness. Each inference is a flash.
foldr :: Foldable t => (a -> b -> b) -> b -> t a -> bat this pressure,
imperative idioms
simply crumple.
class Functor w => Comonad w where
extract :: w a -> a
duplicate :: w a -> w (w a)Where a monad produces context, a comonad is suspended inside it — a creature that experiences, rather than performs. The mirror-image of a jellyfish.
Leviathan :: forall a. Monad m => Depth -> Silence -> m (Maybe Revelation)
The monster is never shown. Only the shape it leaves in the type system. Only the pressure it exerts on the surrounding types.
surface again —
or do not.
the sea is patient.