范畴论玩具：什么是单子 (monad)？

对于上了计概课的同学们, 相信大家都有很多问号, 什么是 monad 捏?

monad 就是自函子范畴上的一个"幺半群" (?)

我们来尝试理解一下这句话在说什么, 首先这里的"幺半群"是在通常意义上的幺半群的一个推广, 也就是说知道什么是幺半群的同学可以先忘掉原有概念

---

一个范畴 category $\mathcal C$ 是指下述资料:

• 一些对象, 构成集合 $\text{Ob}(\mathcal C)$;
• 一些态射, 构成集合 $\text{Mor}(\mathcal C)$, 以及映射 $s,t:\text{Mor}(\mathcal C)\to\text{Ob}(\mathcal C)$ 给出态射的来源和目标, 从而对于 $X,Y\in\text{Ob}(\mathcal C)$, $\text{Hom}_\mathcal C(X,Y):=s^{-1}(X)\cap t^{-1}(Y)$ 表示 $X$ 到 $Y$ 的态射构成的集合, 称为 $\text{Hom}$-集;
• 对于 $X\in\text{Ob}(\mathcal C)$ 都有恒等态射 $\text{id}_X\in\text{Hom}_\mathcal C(X,X)$;
• 对于 $X,Y,Z\in\text{Ob}(\mathcal C)$ 都有运算 $\circ:\text{Hom}_\mathcal C(Y,Z)\times\text{Hom}_\mathcal C(X,Y)\to\text{Hom}_\mathcal C(X,Z)$, 其将 $(f,g)$ 映至 $f\circ g$, 满足下述性质:
  • 对于 $f,g,h\in\text{Mor}(\mathcal C)$, 若 $(f\circ g)\circ h$ 和 $f\circ(g\circ h)$ 都有定义, 则 $(f\circ g)\circ h=f\circ(g\circ h)$.
  • 对于 $f\in\text{Hom}_\mathcal C(X,Y)$, 都有 $f\circ\text{id}_X=\text{id}_Y\circ f=f$.

对象很好理解, 就是一些元素...吗? 大多数时候, 我们应该把对象看作具有某种代数结构的集合, 而态射就是保持这些代数结构的映射.

我们有成堆的数学上的例子, 当然这都不重要, 就看看下面两个:

• 全体集合作为对象构成范畴 $\textsf{Set}$, 态射及其合成是自明的;
• 对于偏序集 $(P,\le)$, 我们构造范畴 $\mathcal P$ 如下: 其对象即为 $P$, 而对 $x,y\in P$ 若 $x\le y$ 则存在唯一态射 $x\to y$, 否则不存在态射. 特别地, 对于 $n\in\mathbb Z_{\ge 0}$, 将 $n$ 看作序数等同于全序集 $\{0,1,\cdots,n-1\}$, 这样构作的范畴记为 $\bold n$.

虽然但是, 我们好像是学 Haskell 的, 那就来看看这是怎么扯上关系的.

定义范畴 $\textsf{Hask}$ 的对象是 Haskell 语言的所有类型 a, 态射是所有函数 f :: a -> b, 态射的合成是运算符 (.) :: (b -> c) -> (a -> b) -> a -> c.

接下来就引出描述范畴之间态射的概念, 称为函子 functor, 它们要保持一个范畴所具有的"代数结构", 即对象之间的态射及其合成.

对于范畴 $\mathcal C',\mathcal C$, 一个函子 $F:\mathcal C'\to\mathcal C$ 是指下述资料:

• 对象间的映射 $F:\text{Ob}(\mathcal C')\to\text{Ob}(\mathcal C)$;
• 对于 $X,Y\in\text{Ob}(\mathcal C')$ 有态射间的映射 $F:\text{Hom}_\mathcal{C'}(X,Y)\to\text{Hom}_\mathcal C(F(X),F(Y))$ 使得 $F(f\circ g)=F(f)\circ F(g)$, $F(\text{id}_X)=\text{id}_{F(X)}$.

对应到 Haskell 语言中, 因为我们现在还只有 $\textsf{Hask}$ 这个范畴, 所以只能考虑 $\textsf{Hask}$ 到 $\textsf{Hask}$ 的函子, 这样的函子称为自函子 endofunctor, 写成代码就是大家熟悉的这个样子:

view codeclass Functor f where
    fmap :: (a -> b) -> f a -> f b
    -- Functor Law #1: fmap id = id
    -- Functor Law #2: fmap (f . g) = fmap f . fmap g

这样的 f 称为类型构造器 type constructor, 其将一个类型"包装"为另一个类型, 注意不要与类型 type 搞混了.

有了 Functor 类之后, 在实践过程中我们会遇到 Maybe (Maybe a) 这样的东西, 这启发我们考虑函子的"合成运算", 甚至还有函子之间的态射, 而无聊的 Haskell 设计者们怎么会放过又一次提升抽象层次的机会呢 (?), 即所有自函子构成一个范畴, 称为自函子范畴 endofunctor category, 记作 $\text{End}(\mathcal C):=\text{Fct}(\mathcal C,\mathcal C)$, 为此我们需要一些准备工作.

对于函子 $F,G:\mathcal C'\to\mathcal C$, 定义自然变换 natural transformation $\theta:F\to G$ 是指一族态射 $(\theta_X\in\text{Hom}_\mathcal C(FX,GX))_{X\in\text{Ob}(\mathcal C')}$ 使得下图对 $\mathcal C'$ 中的态射 $f:X\to Y$ 交换:

图表交换是指对于起点和终点相同的路径, 其上态射的合成相同, 例如上面的图表就是 $\theta_Y\circ Ff=Gf\circ\theta_X$.

"自然"在数学上指的是能画出来的图表可交换, 翻译到 Haskell 语言, 实际上是说对于相同的对象构造的函数, 在类型确定的情况下是唯一的, Transformation 类的定义如下:

view codeclass (Functor f, Functor g) => Transformation f g t where
    (#) :: t -> f a -> g a
    -- Natural Law: fmap h . (r #) = (r #) . fmap h

至于函子间合成怎么办捏? 我们要在范畴上定义二元运算, 这引出幺半范畴 monoidal category 的概念. 为了简化理论我们只讨论严格幺半范畴 strict monoidal category, 这是说在范畴 $\mathcal V$ 上有二元函子 $\otimes:\mathcal V\times\mathcal V\to\mathcal V$ 和幺元 $\bold 1\in\mathcal V$ 使得 $(X\otimes Y)\otimes Z=X\otimes(Y\otimes Z)$ 且 $\bold 1\otimes X=X\otimes\bold 1=X$. 容易验证自函子 $\text{End}(\mathcal C)$ 构成严格幺半范畴.

严格幺半范畴上的幺半对象 monoid object, 简称 monoid 错误地直译为幺半群是指对象 $M$ 附带乘法 $\mu:M\otimes M\to M$ 和幺元 $\eta:\bold 1\to M$ 满足结合律和幺元性质, 即如下的交换图表:

自函子范畴上的幺半对象即为单子 monad. 完成目标, 完结撒花 (?)

先看看远处的错误翻译"幺半群", 实际上不无道理! (哈?)
$\textsf{Set}$ 作为幺半范畴, 其上的幺半对象确实是通常意义上的幺半群, 因而是一个推广定义!

再重复一遍: 具体到实际意义上时 $M$ 是函子 (类型构造器) 而 $\mu$ 和 $\eta$ 都是自然变换, 而自然变换在定义上是对全体类型 a 的一族态射 (函数).

还是以无聊的 Maybe 举例子, $\mu$ 称为 join 函数, 将 Maybe (Maybe a) 映至 Maybe a, $\eta$ 称为 unit 函数, 也记作 pure, return, 将 a 映至 Maybe a, 写成代码就是大家熟悉的这个样子:

view codeclass Functor m => Monad m where
    return :: a -> m a
    join   :: m (m a) -> m a
    (>>=)  :: m a -> (a -> m b) -> m b
    -- Monad Law #1 (left identity):  join . return      = id
    -- Monad Law #2 (right identity): join . fmap return = id
    -- Monad Law #3 (associativity):  join . fmap join   = join . join

这里的 (>>=) 是个啥捏? 这就涉及到 monad 在 Haskell 中的具体应用, 例如实现管道操作和 do 语法糖, 与本文讲述理论的主题没啥关系, 而且大家在计概课也有学（

实际上, join 与 (>>=) 可以按照下述方式互相定义:

view codejoin :: Monad m => m (m a) -> m a
join x = x >>= id

(>>=) :: Monad m => m a -> (a -> m b) -> m b
x >>= f = join $ fmap f x

相信大家确实理解 monad 是什么了, 于是就真的完结撒花了）