"use strict"; const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0]; const {useMDXComponents: _provideComponents} = arguments[0]; function _createMdxContent(props) { const _components = { a: "a", blockquote: "blockquote", code: "code", em: "em", h1: "h1", hr: "hr", li: "li", p: "p", path: "path", pre: "pre", span: "span", strong: "strong", svg: "svg", ul: "ul", ..._provideComponents(), ...props.components }; return _jsxs(_Fragment, { children: [_jsx(_components.p, { children: "Haskell 提供了一系列类型类（如 Functor、Applicative、Monad、Category 等）直接对应或源自范畴论的重要概念。这些抽象不仅有助于代码复用和模块化，更体现了深刻的数学含义。下面我们逐一解释这些类型类与范畴论概念的对应关系，并结合简单的代码实例来加深理解。" }), "\n", _jsxs(_components.h1, { id: "functor-类型类函子", children: [_jsx(_components.a, { className: "heading-link", href: "#functor-类型类函子", children: _jsx(_components.svg, { xmlns: "http:www.w3.org/2000/svg", fill: "#ab2b65", viewBox: "0 0 20 20", className: "w-5 h-5", children: _jsx(_components.path, { fillRule: "evenodd", clipRule: "evenodd", d: "M9.493 2.853a.75.75 0 00-1.486-.205L7.545 6H4.198a.75.75 0 000 1.5h3.14l-.69 5H3.302a.75.75 0 000 1.5h3.14l-.435 3.148a.75.75 0 001.486.205L7.955 14h2.986l-.434 3.148a.75.75 0 001.486.205L12.456 14h3.346a.75.75 0 000-1.5h-3.14l.69-5h3.346a.75.75 0 000-1.5h-3.14l.435-3.147a.75.75 0 00-1.486-.205L12.045 6H9.059l.434-3.147zM8.852 7.5l-.69 5h2.986l.69-5H8.852z" }) }) }), "Functor 类型类（函子）"] }), "\n", _jsxs(_components.p, { children: ["在范畴论中，", _jsx(_components.strong, { children: "函子" }), "是在两个范畴之间映射结构的映射：它将一个范畴中的每个对象映射到另一个范畴中的一个对象，同时将态射映射为态射，并且保持恒等态射和组合运算。特别地，", _jsx(_components.strong, { children: "自函子" }), "是映射范畴到自身的函子。Haskell 中的 ", _jsx(_components.code, { className: "language-auto", children: "Functor" }), " 类型类正是范畴 ", _jsx(_components.strong, { children: "Hask" }), " 上的自函子概念。", _jsx(_components.code, { className: "language-auto", children: "Functor" }), " 类型类定义如下："] }), "\n", _jsx(_components.pre, { className: "language-haskell", children: _jsxs(_components.code, { className: "language-haskell code-highlight", children: [_jsxs(_components.span, { className: "code-line", children: [_jsx(_components.span, { className: "token keyword", children: "class" }), " ", _jsx(_components.span, { className: "token constant", children: "Functor" }), " ", _jsx(_components.span, { className: "token hvariable", children: "f" }), " ", _jsx(_components.span, { className: "token keyword", children: "where" }), "\n"] }), _jsxs(_components.span, { className: "code-line", children: ["\t", _jsx(_components.span, { className: "token builtin", children: "fmap" }), " ", _jsx(_components.span, { className: "token operator", children: "::" }), " ", _jsx(_components.span, { className: "token punctuation", children: "(" }), _jsx(_components.span, { className: "token hvariable", children: "a" }), " ", _jsx(_components.span, { className: "token operator", children: "->" }), " ", _jsx(_components.span, { className: "token hvariable", children: "b" }), _jsx(_components.span, { className: "token punctuation", children: ")" }), " ", _jsx(_components.span, { className: "token operator", children: "->" }), " ", _jsx(_components.span, { className: "token hvariable", children: "f" }), " ", _jsx(_components.span, { className: "token hvariable", children: "a" }), " ", _jsx(_components.span, { className: "token operator", children: "->" }), " ", _jsx(_components.span, { className: "token hvariable", children: "f" }), " ", _jsx(_components.span, { className: "token hvariable", children: "b" }), "\n"] })] }) }), "\n", _jsxs(_components.p, { children: ["该定义表明：", _jsx(_components.code, { className: "language-auto", children: "f" }), " 是一个类型构造器（", _jsx(_components.code, { className: "language-auto", children: "* -> *" }), " ", _jsx(_components.em, { children: "kinding" }), "）时，它是一个函子，需要提供 ", _jsx(_components.code, { className: "language-auto", children: "fmap" }), " 来把", _jsx(_components.strong, { children: "源范畴 Hask" }), "中的态射", _jsx(_components.code, { className: "language-auto", children: "(a->b)" }), "映射为", _jsx(_components.strong, { children: "目标范畴（也是 Hask）" }), " 中的态射", _jsx(_components.code, { className: "language-auto", children: "(f a -> f b)" }), "。这里类型构造器 ", _jsx(_components.code, { className: "language-auto", children: "f" }), " 扮演函子在对象上的映射：给定任意类型 ", _jsx(_components.code, { className: "language-auto", children: "a" }), "，它产生一个新类型 ", _jsx(_components.code, { className: "language-auto", children: "f a" }), "；而 ", _jsx(_components.code, { className: "language-auto", children: "fmap" }), " 则对应将任意函数 ", _jsx(_components.code, { className: "language-auto", children: "a->b" }), " 映射为 ", _jsx(_components.code, { className: "language-auto", children: "f a->f b" }), "。必须满足函子公理：", _jsx(_components.code, { className: "language-auto", children: "fmap id = id" }), "（映射恒等函数得到恒等函数）以及 ", _jsx(_components.code, { className: "language-auto", children: "fmap (g . h) = fmap g . fmap h" }), "（映射复合函数等于依次映射后再复合）。这些正是函子保持范畴结构（单位元和组合）的要求。"] }), "\n", _jsxs(_components.p, { children: ["一个典型例子是 ", _jsx(_components.code, { className: "language-auto", children: "Maybe" }), " 类型构造器，它可以视为 Hask 上的一个自函子。", _jsx(_components.code, { className: "language-auto", children: "Maybe" }), " 将任意类型 ", _jsx(_components.code, { className: "language-auto", children: "T" }), " 对应到类型 ", _jsx(_components.code, { className: "language-auto", children: "Maybe T" }), "，同时我们为其定义 ", _jsx(_components.code, { className: "language-auto", children: "fmap" }), " 来映射函数en.wikibooks.org："] }), "\n", _jsx(_components.pre, { className: "language-haskell", children: _jsxs(_components.code, { className: "language-haskell code-highlight", children: [_jsxs(_components.span, { className: "code-line", children: [_jsx(_components.span, { className: "token keyword", children: "instance" }), " ", _jsx(_components.span, { className: "token constant", children: "Functor" }), " ", _jsx(_components.span, { className: "token constant", children: "Maybe" }), " ", _jsx(_components.span, { className: "token keyword", children: "where" }), "\n"] }), _jsxs(_components.span, { className: "code-line", children: [" ", _jsx(_components.span, { className: "token builtin", children: "fmap" }), " ", _jsx(_components.span, { className: "token hvariable", children: "f" }), " ", _jsx(_components.span, { className: "token punctuation", children: "(" }), _jsx(_components.span, { className: "token constant", children: "Just" }), " ", _jsx(_components.span, { className: "token hvariable", children: "x" }), _jsx(_components.span, { className: "token punctuation", children: ")" }), " ", _jsx(_components.span, { className: "token operator", children: "=" }), " ", _jsx(_components.span, { className: "token constant", children: "Just" }), " ", _jsx(_components.span, { className: "token punctuation", children: "(" }), _jsx(_components.span, { className: "token hvariable", children: "f" }), " ", _jsx(_components.span, { className: "token hvariable", children: "x" }), _jsx(_components.span, { className: "token punctuation", children: ")" }), "\n"] }), _jsxs(_components.span, { className: "code-line", children: [" ", _jsx(_components.span, { className: "token builtin", children: "fmap" }), " ", _jsx(_components.span, { className: "token hvariable", children: "_" }), " ", _jsx(_components.span, { className: "token constant", children: "Nothing" }), " ", _jsx(_components.span, { className: "token operator", children: "=" }), " ", _jsx(_components.span, { className: "token constant", children: "Nothing" }), "\n"] })] }) }), "\n", _jsxs(_components.p, { children: ["在此实例中，", _jsx(_components.code, { className: "language-auto", children: "fmap" }), " 接受一个函数 ", _jsx(_components.code, { className: "language-auto", children: "f :: a -> b" }), "，如果 ", _jsx(_components.code, { className: "language-auto", children: "Maybe" }), " 值是 ", _jsx(_components.code, { className: "language-auto", children: "Just x" }), "，则将其内部值应用 ", _jsx(_components.code, { className: "language-auto", children: "f" }), " 后包裹回 ", _jsx(_components.code, { className: "language-auto", children: "Just" }), "；如果是 ", _jsx(_components.code, { className: "language-auto", children: "Nothing" }), "，则仍返回 ", _jsx(_components.code, { className: "language-auto", children: "Nothing" }), "。这样，", _jsx(_components.code, { className: "language-auto", children: "fmap" }), " 实现了从 ", _jsx(_components.code, { className: "language-auto", children: "a->b" }), " 到 ", _jsx(_components.code, { className: "language-auto", children: "Maybe a->Maybe b" }), " 的映射，恰好满足函子的定义要求。使用示例：", _jsx(_components.code, { className: "language-auto", children: "fmap (+1) (Just 2)" }), " 结果为 ", _jsx(_components.code, { className: "language-auto", children: "Just 3" }), "，而 ", _jsx(_components.code, { className: "language-auto", children: "fmap (+1) Nothing" }), " 则仍为 ", _jsx(_components.code, { className: "language-auto", children: "Nothing" }), "。", _jsx(_components.code, { className: "language-auto", children: "Functor" }), " 抽象使我们能够编写与具体容器无关的", _jsx(_components.strong, { children: "可映射" }), "操作，例如可以定义一个多态函数通过 ", _jsx(_components.code, { className: "language-auto", children: "fmap" }), " 对任意 Functor 作用，从而同时适用于列表、", _jsx(_components.code, { className: "language-auto", children: "Maybe" }), "、树等各种函子结构。"] }), "\n", _jsxs(_components.p, { children: ["值得注意的是，Haskell 中的 ", _jsx(_components.code, { className: "language-auto", children: "Data.Functor" }), " 模块正是定义在 ", _jsx(_components.strong, { children: "Hask" }), " 上的自函子类型类。正如以上所示，对于具体的 Functor 实例，", _jsx(_components.strong, { children: "对象映射" }), "由类型构造器本身完成（比如 ", _jsx(_components.code, { className: "language-auto", children: "Maybe" }), "），而", _jsx(_components.strong, { children: "态射映射" }), "由 ", _jsx(_components.code, { className: "language-auto", children: "fmap" }), " 完成。函子这一抽象源自范畴论，但在日常 Haskell 编程中非常常用，为各种数据结构提供了一种统一的“可映射”接口。"] }), "\n", _jsx(_components.hr, {}), "\n", _jsxs(_components.h1, { id: "applicative-类型类内积函子单元函子", children: [_jsx(_components.a, { className: "heading-link", href: "#applicative-类型类内积函子单元函子", children: _jsx(_components.svg, { xmlns: "http:www.w3.org/2000/svg", fill: "#ab2b65", viewBox: "0 0 20 20", className: "w-5 h-5", children: _jsx(_components.path, { fillRule: "evenodd", clipRule: "evenodd", d: "M9.493 2.853a.75.75 0 00-1.486-.205L7.545 6H4.198a.75.75 0 000 1.5h3.14l-.69 5H3.302a.75.75 0 000 1.5h3.14l-.435 3.148a.75.75 0 001.486.205L7.955 14h2.986l-.434 3.148a.75.75 0 001.486.205L12.456 14h3.346a.75.75 0 000-1.5h-3.14l.69-5h3.346a.75.75 0 000-1.5h-3.14l.435-3.147a.75.75 0 00-1.486-.205L12.045 6H9.059l.434-3.147zM8.852 7.5l-.69 5h2.986l.69-5H8.852z" }) }) }), "Applicative 类型类（内积函子/单元函子）"] }), "\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Applicative" }), " 是 Functor 的增强，它在函子的基础上增加了“将带有上下文的函数应用于带有上下文的值”的能力。Applicative 类型类定义如下："] }), "\n", _jsx(_components.pre, { className: "language-haskell", children: _jsxs(_components.code, { className: "language-haskell code-highlight", children: [_jsxs(_components.span, { className: "code-line", children: [_jsx(_components.span, { className: "token keyword", children: "class" }), " ", _jsx(_components.span, { className: "token constant", children: "Functor" }), " ", _jsx(_components.span, { className: "token hvariable", children: "f" }), " ", _jsx(_components.span, { className: "token operator", children: "=>" }), " ", _jsx(_components.span, { className: "token constant", children: "Applicative" }), " ", _jsx(_components.span, { className: "token hvariable", children: "f" }), " ", _jsx(_components.span, { className: "token keyword", children: "where" }), "\n"] }), _jsxs(_components.span, { className: "code-line", children: [" ", _jsx(_components.span, { className: "token hvariable", children: "pure" }), " ", _jsx(_components.span, { className: "token operator", children: "::" }), " ", _jsx(_components.span, { className: "token hvariable", children: "a" }), " ", _jsx(_components.span, { className: "token operator", children: "->" }), " ", _jsx(_components.span, { className: "token hvariable", children: "f" }), " ", _jsx(_components.span, { className: "token hvariable", children: "a" }), "\n"] }), _jsxs(_components.span, { className: "code-line", children: [" ", _jsx(_components.span, { className: "token punctuation", children: "(" }), _jsx(_components.span, { className: "token operator", children: "<*>" }), _jsx(_components.span, { className: "token punctuation", children: ")" }), " ", _jsx(_components.span, { className: "token operator", children: "::" }), " ", _jsx(_components.span, { className: "token hvariable", children: "f" }), " ", _jsx(_components.span, { className: "token punctuation", children: "(" }), _jsx(_components.span, { className: "token hvariable", children: "a" }), " ", _jsx(_components.span, { className: "token operator", children: "->" }), " ", _jsx(_components.span, { className: "token hvariable", children: "b" }), _jsx(_components.span, { className: "token punctuation", children: ")" }), " ", _jsx(_components.span, { className: "token operator", children: "->" }), " ", _jsx(_components.span, { className: "token hvariable", children: "f" }), " ", _jsx(_components.span, { className: "token hvariable", children: "a" }), " ", _jsx(_components.span, { className: "token operator", children: "->" }), " ", _jsx(_components.span, { className: "token hvariable", children: "f" }), " ", _jsx(_components.span, { className: "token hvariable", children: "b" }), "\n"] })] }) }), "\n", _jsxs(_components.p, { children: [_jsx(_components.code, { className: "language-auto", children: "pure" }), " 将一个普通值放入函子的上下文中（例如将值包装到 ", _jsx(_components.code, { className: "language-auto", children: "Just" }), "中或单元素列表中），", _jsx(_components.code, { className: "language-auto", children: "<*>" }), " 则将函子内包含的函数作用于另一个函子内的值", _jsx(_components.a, { href: "https://thzt.github.io/2016/01/11/monad-in-hask-category/#:~:text=fmap%20%3A%3A%20%28a%20,f%20b", target: "_blank", rel: "noopener noreferrer", children: "thzt.github.io" }), "。Applicative 要求满足若干公理（如同态性、交换性等），确保其行为与直观的函数应用一致。"] }), "\n", _jsxs(_components.p, { children: ["从范畴论角度来看，Applicative 对应了", _jsx(_components.strong, { children: "单元（幺）函子和范畴乘积" }), "的概念。具体而言，Applicative 函子等价于在笛卡尔积单元范畴上", _jsx(_components.strong, { children: "具有张量态射的" }), "（强）** 挠性幺半函子。这意味着 Applicative 函子不仅是一个自函子，还与底层范畴的乘积结构相容：", _jsx(_components.code, { className: "language-auto", children: "pure" }), " 对应将恒等元映射到函子（类似恒等函子的自然变换），", _jsx(_components.code, { className: "language-auto", children: "<*>" }), " 则对应函子在乘积上的一种映射，使得 ", _jsx(_components.code, { className: "language-auto", children: "f (a⊗b) -> f a ⊗ f b" }), " 形式的转换成为可能。简单来说，在 Hask （一个以笛卡尔积为张量的幺半范畴）中，Applicative 函子允许我们在独立计算的结果之间进行组合操作，这在数学上对应函子保持该范畴的", _jsx(_components.strong, { children: "单元结构" }), "。"] }), "\n", _jsxs(_components.p, { children: ["举例来说，列表 ", _jsx(_components.code, { className: "language-auto", children: "[]" }), " 构造器是一个 Applicative Functor：", _jsx(_components.code, { className: "language-auto", children: "pure x" }), " 产生单元素列表 ", _jsx(_components.code, { className: "language-auto", children: "[x]" }), "，而 ", _jsx(_components.code, { className: "language-auto", children: "<*>" }), " 实现笛卡尔积式的组合，例如："] }), "\n", _jsx(_components.pre, { className: "language-haskell", children: _jsx(_components.code, { className: "language-haskell code-highlight", children: _jsxs(_components.span, { className: "code-line", children: [_jsx(_components.span, { className: "token hvariable", children: "pure" }), " ", _jsx(_components.span, { className: "token punctuation", children: "(" }), _jsx(_components.span, { className: "token operator", children: "+" }), _jsx(_components.span, { className: "token punctuation", children: ")" }), " ", _jsx(_components.span, { className: "token operator", children: "<*>" }), " ", _jsx(_components.span, { className: "token punctuation", children: "[" }), _jsx(_components.span, { className: "token number", children: "1" }), _jsx(_components.span, { className: "token punctuation", children: "," }), _jsx(_components.span, { className: "token number", children: "2" }), _jsx(_components.span, { className: "token punctuation", children: "]" }), " ", _jsx(_components.span, { className: "token operator", children: "<*>" }), " ", _jsx(_components.span, { className: "token punctuation", children: "[" }), _jsx(_components.span, { className: "token number", children: "10" }), _jsx(_components.span, { className: "token punctuation", children: "," }), _jsx(_components.span, { className: "token number", children: "20" }), _jsx(_components.span, { className: "token punctuation", children: "]" }), " ", _jsx(_components.span, { className: "token comment", children: "-- 结果为 [11,21,12,22]" }), "\n"] }) }) }), "\n", _jsxs(_components.p, { children: ["这里 ", _jsx(_components.code, { className: "language-auto", children: "[1,2]" }), " 和 ", _jsx(_components.code, { className: "language-auto", children: "[10,20]" }), " 两个列表的组合产生了所有可能的和。同样地，", _jsx(_components.code, { className: "language-auto", children: "Maybe" }), " 也是 Applicative：", _jsx(_components.code, { className: "language-auto", children: "pure x = Just x" }), "，而 ", _jsx(_components.code, { className: "language-auto", children: "<*>" }), " 会在任一参数为 ", _jsx(_components.code, { className: "language-auto", children: "Nothing" }), " 时产出 ", _jsx(_components.code, { className: "language-auto", children: "Nothing" }), "，否则就应用内部函数。例如："] }), "\n", _jsx(_components.pre, { className: "language-haskell", children: _jsxs(_components.code, { className: "language-haskell code-highlight", children: [_jsxs(_components.span, { className: "code-line", children: [_jsx(_components.span, { className: "token hvariable", children: "pure" }), " ", _jsx(_components.span, { className: "token punctuation", children: "(" }), _jsx(_components.span, { className: "token operator", children: "+" }), _jsx(_components.span, { className: "token punctuation", children: ")" }), " ", _jsx(_components.span, { className: "token operator", children: "<*>" }), " ", _jsx(_components.span, { className: "token constant", children: "Just" }), " ", _jsx(_components.span, { className: "token number", children: "3" }), " ", _jsx(_components.span, { className: "token operator", children: "<*>" }), " ", _jsx(_components.span, { className: "token constant", children: "Just" }), " ", _jsx(_components.span, { className: "token number", children: "4" }), " ", _jsx(_components.span, { className: "token comment", children: "-- 结果为 Just 7" }), "\n"] }), _jsxs(_components.span, { className: "code-line", children: [_jsx(_components.span, { className: "token hvariable", children: "pure" }), " ", _jsx(_components.span, { className: "token punctuation", children: "(" }), _jsx(_components.span, { className: "token operator", children: "+" }), _jsx(_components.span, { className: "token punctuation", children: ")" }), " ", _jsx(_components.span, { className: "token operator", children: "<*>" }), " ", _jsx(_components.span, { className: "token constant", children: "Nothing" }), " ", _jsx(_components.span, { className: "token operator", children: "<*>" }), " ", _jsx(_components.span, { className: "token constant", children: "Just" }), " ", _jsx(_components.span, { className: "token number", children: "4" }), " ", _jsx(_components.span, { className: "token comment", children: "-- 结果为 Nothing" }), "\n"] })] }) }), "\n", _jsx(_components.p, { children: "在这些操作中，可以看出 Applicative 允许我们对多个带有上下文的值进行运算，而无需显式地拆解上下文，从而提供了一种简洁的方式组合独立的效果或计算。" }), "\n", _jsx(_components.hr, {}), "\n", _jsxs(_components.h1, { id: "monad-类型类单子", children: [_jsx(_components.a, { className: "heading-link", href: "#monad-类型类单子", children: _jsx(_components.svg, { xmlns: "http:www.w3.org/2000/svg", fill: "#ab2b65", viewBox: "0 0 20 20", className: "w-5 h-5", children: _jsx(_components.path, { fillRule: "evenodd", clipRule: "evenodd", d: "M9.493 2.853a.75.75 0 00-1.486-.205L7.545 6H4.198a.75.75 0 000 1.5h3.14l-.69 5H3.302a.75.75 0 000 1.5h3.14l-.435 3.148a.75.75 0 001.486.205L7.955 14h2.986l-.434 3.148a.75.75 0 001.486.205L12.456 14h3.346a.75.75 0 000-1.5h-3.14l.69-5h3.346a.75.75 0 000-1.5h-3.14l.435-3.147a.75.75 0 00-1.486-.205L12.045 6H9.059l.434-3.147zM8.852 7.5l-.69 5h2.986l.69-5H8.852z" }) }) }), "Monad 类型类（单子）"] }), "\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Monad" }), " 可以看作是带有额外结构的 Applicative（当然也是 Functor）。范畴论中，单子（Monad）起源于对", _jsx(_components.strong, { children: "范畴的自函子上的幺半群" }), "结构的研究：用精练的话来说："] }), "\n", _jsxs(_components.blockquote, { children: ["\n", _jsx(_components.p, { children: "_“Monad 是范畴 C 上的自函子范畴中的一个幺半群。”" }), "\n"] }), "\n", _jsxs(_components.p, { children: ["简单解释即：给定范畴 C，考虑所有从 C 到 C 的函子所构成的范畴（对象是这些自函子，态射是函子之间的自然变换）。在这个函子范畴中可以定义函子的复合作为“乘法”，恒等函子作为“单位”。满足单子公理的函子就对应于其中的", _jsx(_components.strong, { children: "幺半群（Monoid）对象" }), "。对于 Hask 来说，单子就是", _jsx(_components.strong, { children: "在 Hask 自函子范畴中的幺半群" }), "，其中函子的复合", _jsx(_components.code, { className: "language-auto", children: "F ◦ F" }), "对应 monoid 的“乘法”，恒等函子对应“单位元”。这正是常被引用的定义：“", _jsx(_components.strong, { children: "Monad 就是 Endofunctor（自函子）范畴上的幺半群" }), "”。"] }), "\n", _jsx(_components.p, { children: "Haskell 中 Monad 类型类的定义为：" }), "\n", _jsx(_components.pre, { className: "language-haskell", children: _jsxs(_components.code, { className: "language-haskell code-highlight", children: [_jsxs(_components.span, { className: "code-line", children: [_jsx(_components.span, { className: "token keyword", children: "class" }), " ", _jsx(_components.span, { className: "token constant", children: "Applicative" }), " ", _jsx(_components.span, { className: "token hvariable", children: "m" }), " ", _jsx(_components.span, { className: "token operator", children: "=>" }), " ", _jsx(_components.span, { className: "token constant", children: "Monad" }), " ", _jsx(_components.span, { className: "token hvariable", children: "m" }), " ", _jsx(_components.span, { className: "token keyword", children: "where" }), "\n"] }), _jsxs(_components.span, { className: "code-line", children: [" ", _jsx(_components.span, { className: "token builtin", children: "return" }), " ", _jsx(_components.span, { className: "token operator", children: "::" }), " ", _jsx(_components.span, { className: "token hvariable", children: "a" }), " ", _jsx(_components.span, { className: "token operator", children: "->" }), " ", _jsx(_components.span, { className: "token hvariable", children: "m" }), " ", _jsx(_components.span, { className: "token hvariable", children: "a" }), "\n"] }), _jsxs(_components.span, { className: "code-line", children: [" ", _jsx(_components.span, { className: "token punctuation", children: "(" }), _jsx(_components.span, { className: "token operator", children: ">>=" }), _jsx(_components.span, { className: "token punctuation", children: ")" }), " ", _jsx(_components.span, { className: "token operator", children: "::" }), " ", _jsx(_components.span, { className: "token hvariable", children: "m" }), " ", _jsx(_components.span, { className: "token hvariable", children: "a" }), " ", _jsx(_components.span, { className: "token operator", children: "->" }), " ", _jsx(_components.span, { className: "token punctuation", children: "(" }), _jsx(_components.span, { className: "token hvariable", children: "a" }), " ", _jsx(_components.span, { className: "token operator", children: "->" }), " ", _jsx(_components.span, { className: "token hvariable", children: "m" }), " ", _jsx(_components.span, { className: "token hvariable", children: "b" }), _jsx(_components.span, { className: "token punctuation", children: ")" }), " ", _jsx(_components.span, { className: "token operator", children: "->" }), " ", _jsx(_components.span, { className: "token hvariable", children: "m" }), " ", _jsx(_components.span, { className: "token hvariable", children: "b" }), "\n"] })] }) }), "\n", _jsxs(_components.p, { children: ["其中 ", _jsx(_components.code, { className: "language-auto", children: "return" }), " （在 Haskell 2010 标准中使用，后来的版本中已将同义的 ", _jsx(_components.code, { className: "language-auto", children: "pure" }), " 视作更可取的名称）将普通值放入单子的上下文中，", _jsx(_components.code, { className: "language-auto", children: ">>=" }), "（bind）则把一个", _jsx(_components.strong, { children: "包含上下文的值" }), "与一个", _jsx(_components.strong, { children: "会产出该上下文的函数" }), "组合，产生新的上下文值。如果我们定义 ", _jsx(_components.code, { className: "language-auto", children: "join :: m (m a) -> m a" }), " 来直接“消除”一层上下文，那么 ", _jsx(_components.code, { className: "language-auto", children: "m >>= f" }), " 实质上等价于 ", _jsx(_components.code, { className: "language-auto", children: "join (fmap f m)" }), "，即先用 ", _jsx(_components.code, { className: "language-auto", children: "f" }), " 映射再扁平化。因此，可以将 ", _jsx(_components.code, { className: "language-auto", children: "return" }), " 对应单子中的单位自然变换 η，将 ", _jsx(_components.code, { className: "language-auto", children: "join" }), " 对应结合自然变换 μ。Monad 需要遵循三条定律（左单位、右单位和结合律），对应范畴论中幺半群的单位元和结合律公理："] }), "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "左单位" }), "：", _jsx(_components.code, { className: "language-auto", children: "return a >>= k ≡ k a" }), " （将纯值引入单子再绑定，等同于直接应用函数）"] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "右单位" }), "：", _jsx(_components.code, { className: "language-auto", children: "m >>= return ≡ m" }), " （将单子值绑定到 return，不改变原值）"] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "结合律" }), "：", _jsx(_components.code, { className: "language-auto", children: "(m >>= k) >>= h ≡ m >>= (\\x -> k x >>= h)" }), " （连续两次绑定的先后顺序不影响结果）"] }), "\n"] }), "\n"] }), "\n", _jsxs(_components.p, { children: ["在范畴论语言中，上述定律正对应 ", _jsx(_components.code, { className: "language-auto", children: "η" }), " 和 ", _jsx(_components.code, { className: "language-auto", children: "μ" }), " 满足 monoid 的单位元和结合律性质。这样，Monad 可以被视为在", _jsx(_components.strong, { children: "计算上下文" }), "中", _jsx(_components.strong, { children: "串联运算" }), "的抽象模型。"] }), "\n", _jsxs(_components.p, { children: ["实践中，Monad 是 Haskell 里极为重要的概念，用于抽象各种带有", _jsx(_components.strong, { children: "序列化效果" }), "的计算。例如，", _jsx(_components.code, { className: "language-auto", children: "Maybe" }), " Monad 表示可能失败的计算，", _jsx(_components.code, { className: "language-auto", children: "IO" }), " Monad 表示带有输入输出副作用的计算，", _jsx(_components.code, { className: "language-auto", children: "[]" }), " Monad 表示非确定性计算（列表推导）等。以下是一个使用 ", _jsx(_components.code, { className: "language-auto", children: "Maybe" }), " Monad 的简单示例，利用 ", _jsx(_components.strong, { children: "do 表达式" }), "（语法糖）来串联多步计算："] }), "\n", _jsx(_components.pre, { className: "language-haskell", children: _jsxs(_components.code, { className: "language-haskell code-highlight", children: [_jsxs(_components.span, { className: "code-line", children: [_jsx(_components.span, { className: "token hvariable", children: "safeDivide" }), " ", _jsx(_components.span, { className: "token operator", children: "::" }), " ", _jsx(_components.span, { className: "token constant", children: "Double" }), " ", _jsx(_components.span, { className: "token operator", children: "->" }), " ", _jsx(_components.span, { className: "token constant", children: "Double" }), " ", _jsx(_components.span, { className: "token operator", children: "->" }), " ", _jsx(_components.span, { className: "token constant", children: "Maybe" }), " ", _jsx(_components.span, { className: "token constant", children: "Double" }), "\n"] }), _jsxs(_components.span, { className: "code-line", children: [_jsx(_components.span, { className: "token hvariable", children: "safeDivide" }), " ", _jsx(_components.span, { className: "token hvariable", children: "_" }), " ", _jsx(_components.span, { className: "token number", children: "0" }), " ", _jsx(_components.span, { className: "token operator", children: "=" }), " ", _jsx(_components.span, { className: "token constant", children: "Nothing" }), "\n"] }), _jsxs(_components.span, { className: "code-line", children: [_jsx(_components.span, { className: "token hvariable", children: "safeDivide" }), " ", _jsx(_components.span, { className: "token hvariable", children: "x" }), " ", _jsx(_components.span, { className: "token hvariable", children: "y" }), " ", _jsx(_components.span, { className: "token operator", children: "=" }), " ", _jsx(_components.span, { className: "token constant", children: "Just" }), " ", _jsx(_components.span, { className: "token punctuation", children: "(" }), _jsx(_components.span, { className: "token hvariable", children: "x" }), " ", _jsx(_components.span, { className: "token operator", children: "/" }), " ", _jsx(_components.span, { className: "token hvariable", children: "y" }), _jsx(_components.span, { className: "token punctuation", children: ")" }), "\n"] }), _jsx(_components.span, { className: "code-line", children: "\n" }), _jsxs(_components.span, { className: "code-line", children: [_jsx(_components.span, { className: "token hvariable", children: "calc" }), " ", _jsx(_components.span, { className: "token operator", children: "::" }), " ", _jsx(_components.span, { className: "token constant", children: "Double" }), " ", _jsx(_components.span, { className: "token operator", children: "->" }), " ", _jsx(_components.span, { className: "token constant", children: "Double" }), " ", _jsx(_components.span, { className: "token operator", children: "->" }), " ", _jsx(_components.span, { className: "token constant", children: "Double" }), " ", _jsx(_components.span, { className: "token operator", children: "->" }), " ", _jsx(_components.span, { className: "token constant", children: "Maybe" }), " ", _jsx(_components.span, { className: "token constant", children: "Double" }), "\n"] }), _jsxs(_components.span, { className: "code-line", children: [_jsx(_components.span, { className: "token hvariable", children: "calc" }), " ", _jsx(_components.span, { className: "token hvariable", children: "x" }), " ", _jsx(_components.span, { className: "token hvariable", children: "y" }), " ", _jsx(_components.span, { className: "token hvariable", children: "z" }), " ", _jsx(_components.span, { className: "token operator", children: "=" }), " ", _jsx(_components.span, { className: "token keyword", children: "do" }), "\n"] }), _jsxs(_components.span, { className: "code-line", children: [" ", _jsx(_components.span, { className: "token hvariable", children: "r1" }), " ", _jsx(_components.span, { className: "token operator", children: "<-" }), " ", _jsx(_components.span, { className: "token hvariable", children: "safeDivide" }), " ", _jsx(_components.span, { className: "token hvariable", children: "x" }), " ", _jsx(_components.span, { className: "token hvariable", children: "y" }), " ", _jsx(_components.span, { className: "token comment", children: "-- x/y，可能失败" }), "\n"] }), _jsxs(_components.span, { className: "code-line", children: [" ", _jsx(_components.span, { className: "token hvariable", children: "r2" }), " ", _jsx(_components.span, { className: "token operator", children: "<-" }), " ", _jsx(_components.span, { className: "token hvariable", children: "safeDivide" }), " ", _jsx(_components.span, { className: "token hvariable", children: "r1" }), " ", _jsx(_components.span, { className: "token hvariable", children: "z" }), " ", _jsx(_components.span, { className: "token comment", children: "-- (x/y)/z，可能失败" }), "\n"] }), _jsxs(_components.span, { className: "code-line", children: [" ", _jsx(_components.span, { className: "token builtin", children: "return" }), " ", _jsx(_components.span, { className: "token hvariable", children: "r2" }), " ", _jsx(_components.span, { className: "token comment", children: "-- 将结果包装回 Maybe" }), "\n"] })] }) }), "\n", _jsxs(_components.p, { children: ["在上述代码中，如果任意一步产生 ", _jsx(_components.code, { className: "language-auto", children: "Nothing" }), "（如除以零失败），整个计算就短路返回 ", _jsx(_components.code, { className: "language-auto", children: "Nothing" }), "；否则会依次将结果传递下去，最终得到 ", _jsx(_components.code, { className: "language-auto", children: "Just" }), " 包裹的结果。这正体现了 Monad 的作用：通过 ", _jsx(_components.code, { className: "language-auto", children: ">>=" }), " 隐藏了显式的判错或状态传递逻辑，以", _jsx(_components.strong, { children: "可组合" }), "的方式把计算步骤串联起来。用范畴论的话说，每个类型构造器 ", _jsx(_components.code, { className: "language-auto", children: "m" }), " 的 Monad 实例确立了一个 ", _jsx(_components.strong, { children: "Kleisli 范畴" }), "：对象仍是类型，但态射不再是普通函数 ", _jsx(_components.code, { className: "language-auto", children: "a->b" }), "，而是形如 ", _jsx(_components.code, { className: "language-auto", children: "a -> m b" }), " 的", _jsx(_components.strong, { children: "单子函数" }), "；Kleisli 范畴中的态射组合就是通过 ", _jsx(_components.code, { className: "language-auto", children: ">>=" }), "（或 ", _jsx(_components.code, { className: "language-auto", children: ">=>" }), "）来实现。事实上，Haskell 提供了 ", _jsx(_components.code, { className: "language-auto", children: "Control.Category" }), " 中对 Kleisli 的 ", _jsx(_components.code, { className: "language-auto", children: "Category" }), " 实例，可以将 Monad 看作生成了一个", _jsx(_components.strong, { children: "新范畴" }), "，其中范畴的合成即 Monad bind。比如，对于任意 Monad ", _jsx(_components.code, { className: "language-auto", children: "m" }), "，Kleisli 范畴的恒等态射是 ", _jsx(_components.code, { className: "language-auto", children: "return :: a -> m a" }), "，两个 Kleisli 态射 ", _jsx(_components.code, { className: "language-auto", children: "f :: a -> m b" }), " 和 ", _jsx(_components.code, { className: "language-auto", children: "g :: b -> m c" }), " 的组合是 ", _jsx(_components.code, { className: "language-auto", children: "\\x -> f x >>= g" }), "。这再次印证了“单子是自函子范畴上的幺半群”这一说法：", _jsx(_components.code, { className: "language-auto", children: "return" }), " 提供单位（单位态射），", _jsx(_components.code, { className: "language-auto", children: ">>=" }), " 提供了类似“乘法”的组合操作，它们满足与范畴恒等和复合相同的规则，从而在抽象上扮演了", _jsx(_components.strong, { children: "可结合的计算序列" }), "的角色。"] }), "\n", _jsx(_components.hr, {}), "\n", _jsxs(_components.h1, { id: "category-类型类范畴抽象", children: [_jsx(_components.a, { className: "heading-link", href: "#category-类型类范畴抽象", children: _jsx(_components.svg, { xmlns: "http:www.w3.org/2000/svg", fill: "#ab2b65", viewBox: "0 0 20 20", className: "w-5 h-5", children: _jsx(_components.path, { fillRule: "evenodd", clipRule: "evenodd", d: "M9.493 2.853a.75.75 0 00-1.486-.205L7.545 6H4.198a.75.75 0 000 1.5h3.14l-.69 5H3.302a.75.75 0 000 1.5h3.14l-.435 3.148a.75.75 0 001.486.205L7.955 14h2.986l-.434 3.148a.75.75 0 001.486.205L12.456 14h3.346a.75.75 0 000-1.5h-3.14l.69-5h3.346a.75.75 0 000-1.5h-3.14l.435-3.147a.75.75 0 00-1.486-.205L12.045 6H9.059l.434-3.147zM8.852 7.5l-.69 5h2.986l.69-5H8.852z" }) }) }), "Category 类型类（范畴抽象）"] }), "\n", _jsxs(_components.p, { children: ["Haskell 的 ", _jsx(_components.code, { className: "language-auto", children: "Category" }), " 类型类直接对应范畴论中“范畴”的抽象概念。虽然在通常编程中我们默认使用函数组合和 ", _jsx(_components.code, { className: "language-auto", children: "id" }), " 来表示范畴（Hask）的结构，但 ", _jsx(_components.code, { className: "language-auto", children: "Category" }), " 类型类允许我们抽象出“一般化的态射”和“组合”。其定义如下（来自模块 ", _jsx(_components.code, { className: "language-auto", children: "Control.Category" }), "）："] }), "\n", _jsx(_components.pre, { className: "language-haskell", children: _jsxs(_components.code, { className: "language-haskell code-highlight", children: [_jsxs(_components.span, { className: "code-line", children: [_jsx(_components.span, { className: "token keyword", children: "class" }), " ", _jsx(_components.span, { className: "token constant", children: "Category" }), " ", _jsx(_components.span, { className: "token hvariable", children: "cat" }), " ", _jsx(_components.span, { className: "token keyword", children: "where" }), "\n"] }), _jsxs(_components.span, { className: "code-line", children: [" ", _jsx(_components.span, { className: "token builtin", children: "id" }), " ", _jsx(_components.span, { className: "token operator", children: "::" }), " ", _jsx(_components.span, { className: "token hvariable", children: "cat" }), " ", _jsx(_components.span, { className: "token hvariable", children: "a" }), " ", _jsx(_components.span, { className: "token hvariable", children: "a" }), "\n"] }), _jsxs(_components.span, { className: "code-line", children: [" ", _jsx(_components.span, { className: "token punctuation", children: "(" }), _jsx(_components.span, { className: "token punctuation", children: "." }), _jsx(_components.span, { className: "token punctuation", children: ")" }), " ", _jsx(_components.span, { className: "token operator", children: "::" }), " ", _jsx(_components.span, { className: "token hvariable", children: "cat" }), " ", _jsx(_components.span, { className: "token hvariable", children: "b" }), " ", _jsx(_components.span, { className: "token hvariable", children: "c" }), " ", _jsx(_components.span, { className: "token operator", children: "->" }), " ", _jsx(_components.span, { className: "token hvariable", children: "cat" }), " ", _jsx(_components.span, { className: "token hvariable", children: "a" }), " ", _jsx(_components.span, { className: "token hvariable", children: "b" }), " ", _jsx(_components.span, { className: "token operator", children: "->" }), " ", _jsx(_components.span, { className: "token hvariable", children: "cat" }), " ", _jsx(_components.span, { className: "token hvariable", children: "a" }), " ", _jsx(_components.span, { className: "token hvariable", children: "c" }), "\n"] }), _jsx(_components.span, { className: "code-line", children: "\n" })] }) }), "\n", _jsxs(_components.p, { children: ["这个定义与数学上范畴的公理惊人地一致：", _jsx(_components.code, { className: "language-auto", children: "id" }), " 提供每个对象上的恒等态射，", _jsx(_components.code, { className: "language-auto", children: "(.)" }), " 提供态射合成的运算。任何 ", _jsx(_components.code, { className: "language-auto", children: "Category" }), " 实例需要满足和先前 Hask 范畴相同的单位元与结合律：对于任意态射 ", _jsx(_components.code, { className: "language-auto", children: "f :: cat a b" }), " 和 ", _jsx(_components.code, { className: "language-auto", children: "g :: cat b c" }), "，都有 ", _jsx(_components.code, { className: "language-auto", children: "f . id = f = id . f" }), "；对于适当类型的 ", _jsx(_components.code, { className: "language-auto", children: "f, g, h" }), "，有 `(h . g) . f = h . (g . f)。"] }), "\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "函数范畴" }), "只是 ", _jsx(_components.code, { className: "language-auto", children: "Category" }), " 的一个实例：Haskell 已内置 ", _jsx(_components.code, { className: "language-auto", children: "instance Category (->)" }), "，其中 ", _jsx(_components.code, { className: "language-auto", children: "id = \\x -> x" }), "，组合 ", _jsx(_components.code, { className: "language-auto", children: "(.)" }), " 就是普通的函数复合。但是，我们可以用 ", _jsx(_components.code, { className: "language-auto", children: "Category" }), " 来表示比函数更一般的组合关系。例如，前面提到的 ", _jsx(_components.strong, { children: "Kleisli" }), " 箭头就是 ", _jsx(_components.code, { className: "language-auto", children: "Category" }), " 的实例：", _jsx(_components.code, { className: "language-auto", children: "instance Monad m => Category (Kleisli m)" }), "，它的 ", _jsx(_components.code, { className: "language-auto", children: "id" }), " 是 ", _jsx(_components.code, { className: "language-auto", children: "return" }), "，而组合 ", _jsx(_components.code, { className: "language-auto", children: "(.)" }), " 定义为 Kleisli 箭头的连接。再如，在", _jsx(_components.strong, { children: "箭头（Arrow）" }), " 框架中，我们处理的是更一般的计算结构（带有输入输出的进程），这些 Arrow 也往往是某种 ", _jsx(_components.code, { className: "language-auto", children: "Category" }), " 的实例，可以在不脱离抽象的情况下使用 ", _jsx(_components.code, { className: "language-auto", children: "." }), " 和 ", _jsx(_components.code, { className: "language-auto", children: "id" }), " 组合它们。"] }), "\n", _jsxs(_components.p, { children: ["通过 ", _jsx(_components.code, { className: "language-auto", children: "Category" }), " 类型类，Haskell 将“", _jsx(_components.strong, { children: "可组合的抽象计算" }), "”提炼为统一接口，使我们能够在不局限于具体实现（函数、Kleisli 箭头等）的情况下谈论“态射”和“范畴”。这是对范畴论的直接致敬：", _jsx(_components.strong, { children: "Category 类确保了我们自定义的组合符号遵循范畴论公理，从而可以无缝地应用数学中的范畴理论直觉来推理代码" }), "。"] })] }); } function MDXContent(props = {}) { const {wrapper: MDXLayout} = { ..._provideComponents(), ...props.components }; return MDXLayout ? _jsx(MDXLayout, { ...props, children: _jsx(_createMdxContent, { ...props }) }) : _createMdxContent(props); } return { default: MDXContent };