Translation of Category Theory for Programmers on boboboker~

2.2 Limits and Colimits - 端和余端

Thu, 03 Sep 2020 00:00:00 +0800

Limits and Colimits

Category Theory II 1.2: Limits Category Theory II 2.1: Limits, Higher order functors Category Theory II 2.2: Limits, Naturality Category Theory II 3.1: Examples of Limits and Colimits

极限和余极限

在范畴论中，所有事物之间都是有联系的，我们可以从任意角度对它们进行考察。例如对积的泛构造，现在我们已经了解了函子和自然变换，那么这个泛构造是否可以简化甚至泛化？下面尝试一下

积的构造始于对两个对象a和b的选择，我们想要构造这二者的积。首先，“选择对象”到底意味着什么？我们能否用范畴论中的术语来描述这一动作？两个对象形成了一个非常简单的模式，我们可以将这个模式抽象到一个非常简单的范畴。我们将这个范畴称为2，它只包含了1和2两个对象，除了两个必须存在的恒等态射，也没有其他态射了。现在可以将“从范畴C中选择两个对象”的行为表述为“定义一个从范畴2到范畴C的函子D”。一个函子将对象映射到对象，因此它的象只是两个对象（也可能是一个，若该函子映射对象时有坍缩行为的话）；函子也映射态射，在当前情况下只是将恒等态射映射成恒等态射。

这种方式的优点它建立在范畴概念上，避免了“选择对象”这种不确切描述。此外，它也很容易概括，因为很容易就能用比2更复杂的范畴来定义模式。

继续，定义一个积的下一步便是对候选对象c的选择。再次对“选择”换个说法，将之描述成从单例范畴出发的函子。（实际若是用Kan extensions来表述就好多了，但尚未接触这一概念，因此这里用了一点小技巧）从范畴2到范畴C的常量函子Δ。

Here again, we could rephrase the selection in terms of a functor from a singleton category. And indeed, if we were using Kan extensions, that would be the right thing to do. But since we are not ready for Kan extensions yet, there is another trick we can use: a constant functor Δ from the same category 2 to C. The selection of c in C can be done with Δc. Remember, Δc maps all objects into c and all morphisms into idc.

2.1 Category Theory and Declarative Programming - 范畴论和声明式编程

Sun, 30 Aug 2020 00:00:00 +0800

Category Theory and Declarative Programming

Category Theory II 1.1: Declarative vs Imperative Approach

第一部分中，讨论了范畴论和编程都是关乎组合的概念。编程过程中，将一个大问题解构成多个子问题，再将这些子问题解构成规模更小的子问题，最终子问题的粒度足够细，从而变成人类能够直接解决的小问题；所有的小问题都解答完毕之后，再将小问题的结果组合起来，一层层向上回溯，最终解决这一原始的、规模较大的问题。一般而言，总是会存在两种编程方式：告诉电脑“做什么/(what to do)”、或者告诉电脑“怎么做/(how to do)”。前者称之为命令式/imperative，后者称为声明式/declarative

考虑一个实例，复合操作本身就可以从声明式和命令式两种途径给出定义。假定函数h是函数g及f的复合，声明式的写法是h = g . f；而命令式h x = let y = f x in g y。命令式编程定义了一系列动作，这些动作严格按顺序进行，在函数f计算完成之前，对g的调用绝对不可能发生（从代码的概念设计上如此，在某些惰性计算、按需调用的参数传递的语言中，实际执行情况可能存在一些不一致）。

事实上，基于编译器的工作，以上两个版本的代码在实际执行时可能仅有一点差别甚至并无区别。在写出既能解决问题、又有较强维护性和可测试性的代码的过程中，背后的方法论可能完全不一样。

主要问题在于：当我们面对一个难题的时候，是否总是可以在命令式或声明式两种方法中自由选择？若是存在一个声明式风格的解决方案，是否总是可以将之转换成代码实现？这一问题似乎有些偏离主题了，但若能找到答案，很可能会再次革新我们对宇宙万物的理解。

现在通过解释一个物理学概念来演示解决问题的两种方式。物理学中，大部分法则的解释都有两种方式，一种是从局部角度考虑、或者无穷小角度。观测一个规模很小的系统状态，预测在下一个时刻系统状态的变化，通常用微分方程表述，通过对一段时间进行积分或求和等，得出系统状态

这种方式便体现了命令式思想：通过一步步逼近从而到达最终状态，每一步都依赖上一步的结果。事实上，计算机对物理系统的模拟就是将微分方程转换为差分方程，然后进行迭代。宇宙飞船射击类游戏中，飞船的运动便是这样计算出来的。随时间跳动，飞船的坐标都是在进行增量累加，位置增量是由速度和时间得出的，而速度是由初速度、加速度和时间得出，加速度又是由力和质量得出。这一系列方程背后便是牛顿运动定律。对于更复杂的问题，也可以用同样的思想来解答，例如用麦克斯韦方程组来研究电磁场的传播，用晶格QCD（量子色动力学）研究质子内部夸克和胶子的行为等。

数字计算机鼓励了时空离散化与局部化思想的结合。斯蒂芬·沃尔夫拉姆（Stephen Wolfram）曾尝试将整个宇宙的复杂性简化为一个元胞自动机系统，这一行为极致地体现了两者结合。

另一种办法是从全局考虑。观察系统的起始状态和最终状态，然后通过某个函数计算链接这两个状态的最短轨迹。

最简单的例子是费马最小时间原理，它指出光线是沿着传播时间最短的路径传播。一般而言，没有反射和折射发生时，光线从A点到达B点的必定是走的最短路径，即直线路径。光线在透明介质中的传播是比真空中要慢的，若是光线起点位于空气中，止点位于水中，那么尽量让光在空气中跑远一点，在水中跑近一点，这样整体传播时间才更短。所有的经典力学都可以从最小作用原理导出。通过积分动势能之差的拉格朗日函数，可以计算任何轨迹。例如发射一枚炮弹并击中目标，炮弹首先向上飞直到重力势能最大点，然后再转向下飞，势能转化成动能。费马的这些贡献甚至可以用于解释量子机制，这一原理只是关注起始和最终状态，然后计算中间轨迹。

从上看出，在解释物理定律时有两种对偶的办法，可以基于一个局部视角、事件按序发生、事件间进行某些增量的叠加；也可以基于一个全局视角，声明起始状态和结束状态，两状态之间的所有东西就在各自时空位置上安静待着。

全局视角的思考方式也确实可以用在编程上。考虑实现一个光线传播程序，声明光源和观测点，那么就直接可以计算其传播路径。实现过程中并没有显式进行“最短时间”、“最短路径”等相关设置，但是隐含的还是用到了相关物理定理和几何知识。

这两种看待问题的方式最大的不同在于它们对于空间以及更重要的时间的处理方式。局部视角更关注“此时此地”，而全局视角是一个静态视角的长期观测，好像未来是确定的，我们只是在分析某个永恒宇宙的性质。

用函数响应式编程/Functional Reactive Programming来编写用户交互程序时也特别体现全局视角的优越性。常见编程模型是对于所有可能出现的用户输入编写对应的事件处理程序，这些事件处理程序之间可能修改一组共享的可变状态。FRP编程模型外部事件视为一个无限列表，然后在这个列表上应用一系列变换，从概念上讲，所有未来可能出现的动作就在那摆着，等着作为输入进入程序。从程序本身的视角看，这些事件是无序且随机的，对于所有情况，若想得知第N项的状态，那必须先处理完前N-1项。当应用于时序型事件时，我们称之具备因果关系。

范畴论鼓励我们尽可能采用全局视角来看待问题，因此也就是在鼓励声明式编程。首先，范畴论不像是微积分那样有距离、附近、极限、时间等概念，我们所拥有的全部东西就是抽象的对象和对象间的态射。若是能通过一系列步骤从A到达B，那么必定存在从A直接到B的办法。此外，范畴论中的主要工具就是泛构造，泛构造本身也是全局视角看待和解决问题的一个例子。

我们曾用泛构造来定义积，通过声明积的性质即完成。积是一个伴随着两个投影态射的对象，它是个“最好”的对象，因为它能将其他对象及投影进行分解。相对应地，传统的笛卡尔积定义就相当命令式了，需要描述清楚如何从一个集合中选取一个元素、从另一个集合选取一个元素，然后将这两个元素构造成一个序对，这个序对便是积的一个实例。此外，还需要定义解构的方法。

当然，几乎所有的编程语言都直接内置了积、余积、函数类型等概念，而不是通过泛构造来定义（当然也有范畴式编程语言对此进行尝试）。不管是否直接使用，范畴论中的定义都可以证明已有的编程结构是合理的，并且可以产生新的结构。最重要的是，最重要的是，范畴理论提供了一种元语言，用于在声明层次上对计算机程序进行推理。它还鼓励在将问题规范转换为代码之前对其进行推理。

1.10 Natural Transformations - 自然变换

Sat, 04 Apr 2020 00:00:00 +0800

Natural Transformations - 自然变换

Natural Transformations

<译> 自然变换

函子可以在维持范畴结构的前提下实现范畴之间的映射。函子可以将一个范畴嵌入到另一个范畴，它也可以让多个范畴坍缩为一个范畴且不会破坏范畴的结构。将一个范畴嵌入到另一个范畴可能有许多种方式。有时这些方式是等价的，有时它们不等价。可以将整个的范畴坍缩为另一个范畴中的一个对象，也可以将一个范畴中的每个对象映射为另一个范畴中不同的对象，将前者中的每个态射映射为后者中的不同的态射。自然变换可以对比这些实现。自然变换是函子之间的映射——可以保持函子性质不变的特殊映射。

对于范畴 C 与 D 之间的两个函子 F 与 G，如果我们只关注 C 中的一个对象 a，它被映射为 D 中的两个对象：F a 与 G a，那么应该存在一个函子映射，它可以将 F a 映射为 G a。由于在同一范畴中的对象映射应该不会脱离该范畴，而且我们不想人工建立 F a 与 G a 的联系，因此很自然的考虑使用既有的联系——所谓的态射。自然变换本质上是如何选取态射：对于任意对象 α ，自然变换就是选取一个从 F a 到 G a 的态射。如果将一个自然变换称为 α，那么这个态射就被称为在 a 上的 α 分量（Component of α at a），记作 $\alpha_a$ α_a: α_a :: F a -> G a

记住，a 是一个在 C 中的对象，而 α_a 是 D 中的一个态射。对于某个 a，如果在 F a 与 G a 之间没有态射，那么 F 与 G 之间也就不存在自然变换。

函子所映射的不止是对象，它们也能映射态射，自然变换应该如何对待这种映射？答案是，态射的映射是固定的——在 F 与 G 之间的任何一个自然变换下，F f 必须变换成 G f。也就是说，两个函子对态射所形成的映射会彻底限制与之相适的自然变换的定义。来考虑在范畴 C 中的两个对象 a 与 b 之间的态射 f，它被映射为范畴 D 中的两个态射 F f 与 G f：

1
2

F f :: F a -> F b
G f :: G a -> G b

自然变换 α 提供两个附加的态射来补全 D 中的结构：

1
2

α_a :: F a -> G a
α_b :: F b -> G b

现在，便有了两个从 F a 到 G b 的途径。为了保证这两种途径等价，必须引入自然性条件（Naturality condition）：G f ∘ α_a = α_b ∘ F f 这个条件应该对于任意的 f 都成立。

自然性条件非常有用。例如，如果态射 F f 是可逆的，自然性决定了以 α_a 形式表示的 α_b。通过 f，基于自然性条件可将 α_a 变换为：α_b = (G f) ∘ α_a ∘ (F f)^(-1)

Polymorphic Functions - 多态函数

之前讲过函子（更确切的说，是自函子）在编程中所扮演的角色。它们相当于类型构造子——将类型映射为类型。不过，函子也能将函数映射为函数，这种映射是通过一个高阶函数 fmap（在 C++ 中则是 transform, then 之类的行为）。

为了构造一个自然变换，我们从一个对象开始，也就是一种类型，设为 a。一个函子 F，可以将 a 映射为类型 F a。另一个函子 G，可以将 a 映射为 G a。在 a 上的自然变换 alpha 的分量是一个从 F a 到 G a 的函数。使用用伪 Haskell 代码，可将其表示为：alpha_a :: F a -> G a 通常，可将其写为：alpha :: F a -> G a 这是由 a 参数化的一个函数族。这是 Haskell 语法简洁性的又一个示例。在 C++ 中，与之类似的构造要麻烦一些： template<Class A> G<A> alpha(F<A>);

Haskell 的多态函数与 C++ 的泛型函数之间存在很大的区别，主要体现为函数的实现方式以及类型检查方式上。在 Haskell 中，一个多态函数必须对于所有类型是唯一的。一个公式必须适用于所有的类型。这就是所谓的参数化多态（Parametric polymorphism）。C++ 默认提供的是特设多态（Ad hoc polymorphism），这意味着模板不一定涵盖所有类型。一份模板是否适用于某种给定的类型需要在实例化时方能确定，彼时，编译器会用一种具体的类型来替换模板的类型参数。类型检测是以推导的形式实现的，编译器经常会给出难以理解的错误信息。在 C++ 中，还有一种函数重载与模板特化机制，通过这种机制可以为不同的类型定义函数的不同版本。Haskell 也有类似的机制，即类型类（Type class）与类型族（Type family）。

Haskell 的参数化多态有一个一个不可预料的结果。凡是像这种类型的多态函数：alpha :: F a -> G a 函子 F 与 G 自动满足自然性条件。这里，我们再回到范畴论的概念（f 是一个函数，f::a->b）：G f ∘ α_a = α_b ∘ F f 在 Haskell 中，函子 G 作用于一个态射 f 是通过 fmap 实现的。可使用 Haskell 伪码将上述概念表示为：fmap_G f . alphaa = alphab . fmap_F f 归功于 Haskell 的类型推导，上述类型标记是不需要的，因此可写为以下形式：fmap f . alpha = alpha . fmap f 这依然不是真正的 Haskell 代码——在代码中无法表示函数等式——不过，上式是恒等的，程序员在等式推导中可以使用这个公式，此外，编译器也可以利用这个公式对代码进行优化。

自然性条件之所以在 Haskell 里会自动被满足，这是『免费的定理』的自然结果。在 Haskell 里，参数化多态，将其用于定义自然变换，会引入非常强的限制条件——一个公式适应所有类型。这些限制条件会变成面向这些函数的方程一样的定理。对于能够对函子进行变换的函数，免费的定理是自然性条件。

在 Haskell 里，可以将函子视为泛型容器。我们可以继续这个类比，将自然变换视为一种重组方法，即将一个容器里的东西取出来放到另一个容器里。我们不会触碰这些东西：不修改，也不创造。我们只是将它们（或它们的一部分）复制到新的容器里，在这个过程中有时候会对它们作几次乘法。于是，自然性条件就是，首先它不关心我们是先通过 fmap 修改这些东西，然后再将它们放到新容器里，还是先把它们放到新容器里再用适用于这个容器的 fmap 去修改它们。重组与 fmap，它们是正交的

来看一下 Haskell 里的自然变换。首先来看列表与 Maybe 这两种函子之间的自然变换，它的功能是，当且仅当列表非空时返回列表的首元素：

1
2
3

safeHead :: [a] -> Maybe a
safeHead [] = Nothing
safeHead (x:xs) = Just x

它是面向 a 的函数多态化。它可以不受限制地作用于任意一种类型 a，因此它是一个参数化多态的例子。从而，它就是两个函子之间的一个自然变换。不过，现在这只是我们在自以为是，下面来验证它是否符合自然性条件。fmap f . safeHead = safeHead . fmap f

-- 考虑两种情况；一个空列表：
fmap f (safeHead []) = fmap f Nothing = Nothing
safeHead (fmap f []) = safeHead [] = Nothing

-- 和一个非空列表：
fmap f (safeHead (x:xs)) = fmap f (Just x) = Just (f x)
safeHead (fmap f (x:xs)) = safeHead (f x : fmap f xs) = Just (f x)

当函子之一是 Const 函子的时候，会发生一件有趣的事。一个以 Const 函子为始点或终点的自然变换，看上去就像一个函数，它即面向它的返回类型多态，也面向它的参数类型多态。

-- 可将 length 视为从列表函子到 Const Int 函子的自然变换：
length :: [a] -> Const Int a
length [] = Const 0
length (x:xs) = Const (1 + unConst (length xs))

-- unConst 用于剥除 Const 构造子：
unConst :: Const c a -> c
unConst (Const x) = x

-- 实际上 length 的定义是下面这样：
length :: [a] -> Int

-- 这个定义有效地掩盖了 length 作为自然变换的本质。

寻找一个以 Const 函子为始点的参数化多态函数有点难，因为这需要无中生有创造一个值出来。我们所能想到的最好的办法是：

1
2

scam :: Const Int a -> Maybe a
scam (Const x) = Nothing

还有一个不同寻常的函子，在 Yoneda 引理中扮演了重要的角色。这个函子就是 Reader 函子。下面我用 newtype 来重写一下它的定义：newtype Reader e a = Reader (e -> a) 这个函子被两种类型参数化了，但是它的（协变）函子性仅着落在第二个类型上：instance Functor (Reader e) where fmap f (Reader g) = Reader (\x -> f (g x)) 对于每种类型 e，都可以定义从 Reader e 到任何其他函子的自然变换家族。以后会看到，这个家族的成员总是与 f e 的元素壹壹对应（Yoneda 引理）。

例如，考虑有时会被忽略的仅有一个值 () 的 unit 类型 ()。函子 Reader () 接受任何一种类型 a，将它射入函数类型 () -> a。这些函数可以从集合 a 中拮取一个元素。这些函数的数量与 a 中元素的数量一样多。现在，来看一下从这种函子到 Maybe 函子的自然变换：alpha :: Reader () a -> Maybe a 这样的自然变换只有 dumb：dumb (Reader _) = Nothing 与 obvious：obvious (Reader g) = Just (g ()) （用 g 能做的事情仅仅是让它作用于 ()。）

Beyond Naturality - 超自然性

两个函子之间的参数化多态函数（包括 Const 函子这种边界情况）必定是自然变换。因为所有的标准代数数据类型都是函子，在这些类型之间的任何一个多态函数都是自然变换。我们还掌握了函数类型，它们对于它们的返回类型而言具有着函子性。我们可以使用它们来构造函子（例如 Reader 函子），并为这些函子构造自然变换——更高阶的函数。

不过，对于参数类型而言，函数类型不具备协变性，它们具备逆变性。当然，逆变函子就是相反范畴中的协变函子。在范畴意义上，两个逆变函子之间的多态函数依然可视为自然变换，除了它们只能作用于 Haskell 类型所构成的两个相反的范畴里的函子。

之前我们见过的一个逆变函子的示例：newtype Op r a = Op (a -> r) 这个函子对于 a 而言具有逆变性：instance Contravariant (Op r) where contramap f (Op g) = Op (g . f) 我们可以写一个函数，假设它从 Op Bool 到 Op String：predToStr (Op f) = Op (\x -> if f x then "T" else "F") 由于这两个函子不具备协变性，它并非 Hask 范畴中的自然变换。不过，由于它们都具备逆变性，所以它们满足『相反的』自然性条件：contramap f . predToStr = predToStr . contramap f 注意，函数 f 必须得走与 fmap 的作用下的方向相反的方向，因为 contramap 的签名是：contramap :: (b -> a) -> (Op Bool a -> Op Bool b)

存在不是函子的类型构造子吗，它是协变的还是逆变的？看下面的例子：a -> a 这不是一个函子，因为同一类型的 a 出现在负（逆变）位与正（协变）位上。对于这种类型，fmap 或 contramap 都无法实现。因此，函数签名：(a -> a) -> f a 其中 f 是任意函子，这个函数不是自然变换。

Functor Category - 函子范畴

现在有了函子之间的映射——自然变换——因此很自然地就会想到，函子是否能够形成范畴？可以。对于每对范畴而言，仅存在一个函子范畴。在这个范畴里，对象是从 C 到 D 的函子，而态射就是这些函子之间的自然变换。

必须得定义两个自然变换的复合，这相当容易。自然变换的分量是态射，而我们知道怎样实现态射的复合。

以从函子 F 到函子 G 的自然变换 α 为例。它在对象 a 上的分量是某个态射：α_a :: F a -> G a 打算用对 α 与 β 进行复合，后者是从 G 到 H 的自然变换。β 在 a 上的分量是一个态射：β_a :: G a -> H a 这些态射是可复合的，复合结果又是一个态射：β_a ∘ α_a :: F a -> H a 可以用这个态射作为自然变换 β . α 的分量——自然变换 β 在 a 之后的复合：(β ⋅ α)_a = β_a ∘ α_a 这种复合的结果是从 F 到 H 的自然变换： H f ∘ (β ⋅ α)_a = (β ⋅ α)_b ∘ F f 自然变换的复合遵循结合律，因为它们的分量都是常规态射，而后者的复合是遵循结合律的。最后，对于每个函子 F，存在一个恒等自然变换 1_F，它的分量是恒等态射：id_{F a} :: F a -> F a 所以，函子的确能形成范畴。

2-Categories - 2-范畴

根据定义，Cat 里的任意 Hom-集都是函子集合。但是两个对象之间的函子有着比集合更丰满的结构。它们形成一个范畴，以自然变换为态射。由于在 Cat 里，函子被认为是态射，自然变换就是态射之间的态射。这个更丰满的结构是 2-范畴的一个例子。2 -范畴是一个广义的范畴，其中，除了对象和态射（这里应该叫 1-态射）之外，还有 2-态射，它就是态射之间的态射。Cat 的 2-范畴具有：对象：（小）范畴; 1-态射：范畴之间的函子; 2-态射：函子之间的自然变换

用 Hom-范畴——函子范畴 D^C 来代替范畴 C 与 D 之间的 Hom-集。有常规的函子复合：来自 D^C 的函子 F 与来自 E^D 的函子 G 复合，可以得到来自 E^C 的函子 G ∘ F。但是，在每个 Hom-范畴内部，也存在着复合——函子之间自然变换或 2-态射的竖向复合。

先选在 Cat 里选两个函子，或者 1-态射：F :: C -> D G :: D -> E 与它们的复合：G ∘ F :: C -> E 假设我们有两个自然变换，α 与 β，它们分别作用于函子 F 与 G：α :: F -> F' β :: G -> G' 注意，我们不能对这两个自然变换应用竖向复合，因为 α 的终点与 β 的始点不重合。实际上，它们分别属于两个不同的函子范畴 D^C 与 E^D。不过，我们能够复合函子 F’ 与 G’，因为 F’ 的终点与 G’ 的起点重合——它就是范畴 D。函子 G’∘ F’ 与 G ∘ F 之间有什么关系呢？这个自然变换称为 α 与 β 的横向复合：β ∘ α :: G ∘ F -> G'∘ F'

Conclusion

对象与范畴是名词；态射、函子以及自然变换是动词。态射连接了对象，函子连接了范畴，自然变换连接了函子。

已经看到了，一个抽象层上的一个动作，在下一个抽象层次上就变成了一个对象。态射的集合变成了函数对象。作为对象，它可以是另一个态射的始点或终点。这就是高阶函数背后的思想。

函子，将对象映射为对象，因此我们将其作为类型构造子，或者作为一种参数化的类型。函子，也能将态射映射为态射，因此它也是高阶函数——fmap。有一些简单的函子，例如 Const、积以及余积，它们可以产生大量的代数数据类型。函数类型也具有函子性，协变性与逆变性，它们可以用于扩充代数数据类型。

函子在函子范畴里可以视为对象。这样，它们就变成了态射的始点与终点，于是有了自然变换。自然变换就是特定形式的多态函数。

1.9 Function Type - 函数类型

Wed, 01 Apr 2020 00:00:00 +0800

Function Type - 函数类型

Function Types

<译> 函数类型

曾多次提到函数类型，函数类型与其它普通类型有显著不同。以Integer为例，它是整数的集合；Bool是两个元素构成的集合。然而一个函数类型a->b的内涵要更大一些，它是从a到b的所有态射构成的集合。从一个对象到另一个对象的所有态射构成的集合，叫hom-集。在集合范畴中，hom-集自身也是个对象。对其它范畴而言，hom-集会形成一个外部范畴，这样的hom-集成为外hom-集。集合的范畴的自引用属性使得函数类型变得有些特殊。但是，至少在某些范畴中，有一种方法可以构造 hom-集这样的对象。这种 hom-集被称为内 hom-集。

Universal Construction - 泛构造

先着手尝试去构造一个函数类型，或者从广义上说，去构造一个内 hom-集。

可将函数类型视为一种复合类型，因为它描述的是一个参数类型（Argument Type）与结果类型（Result Type）之间的关系。用泛构造定义过积类型与余积类型，现可以用同样技巧来定义函数类型，前提是需给出可以联系三种对象的模式。这三种对象分别是：要构造的函数类型，参数类型及结果类型。

显然，联系这三种类型的模式就是函数应用（Function Application）或求值。对于函数类型，假设存在一个候选者 z（在非集合的范畴中，z 只是个普通的对象），设参数类型为 a（一个对象），函数『应用』可将 z 与 a 构成的序对映射为结果类型 b（一个对象）。现有三个对象，它们中有两个是固定的（一个是参数类型，另一个是结果类型），剩下的那个就是『应用』。『应用』是一种映射，该如何将它融入到我们刚才所建立的模式之中？如果允许查看对象的内部，就可以将一个函数 f（z 的一个元素）与参数 x 封装为序对，然后将这个序对映射为 f x（f 作用于 x，所得结果就是 b 的一个元素）。只是能处理单个的序对 (f, x) 是没有多少意思的，我们要处理的是函数类型的候选者 z 与参数类型 a 的积，即 z×a。这个积是一个对象，可以选择从这个对象到 b 的一个箭头 g 作为态射，g 也就是『应用』。在集合的范畴中，g 就是将每个 (f, x) 映射为 f x 的函数。

这样，就建立起了这样一个模式：对象 z 与对象 a 的积，通过态射 g 被关联到另一个对象 b。

以对象与态射构成的模式为起点，它是一种不精确的查询，通常会命中很多东西。特别是在集合的范畴中，几乎每一样东西都与其他东西具有相关性。可以拮取任意一个对象 z，将其与 a 形成积，再找个函数将积映射为 b（除非 b 是空集）。这样，排名（Ranking）就派上了用场，就是检查一下是不是在函数类型的候选者之间存在唯一的映射——可以因式化泛构造的映射。当且仅当存在一个唯一的从 z’ 到 z 的映射，使得 g’ 可由 g 的因式来构造，即可判定伴随态射 g（从 z×a 到 b）的 z 比伴随 g’ 的候选者 z’ 更好。

假设存在态射 h:: z’ -> z，我们想获得从 z’×a 到 z×a 的态射。由于积类型本身是一个函子（更确切的说，是二元自函子），因此可以提升一对态射。也就是说，不仅能定义对象的积，也能定义态射的积。由于不需要改变 z’×a 这个积的第二个成员 a，因此我们要提升的态射序对是 (h, id)，其中 id 是作用于 a 的恒等态射。现在我们可以建立『应用』的因式了，将 g’ 表示为 g 的因式：g' = g ∘ (h × id) 这里，关键之处在于态射积的作用

泛构造的第三个步就是选出最好的那个候选者——称之为 a⇒b（在这里，将它视为一个对象的名字即可，不要与 Haskell 类型类的约束符号混淆，下文会给出其他命名方式）。这个对象伴随的『应用』——从 (a⇒b)×a 到 b 的态射——称之为 eval。如果其他候选者所对应的『应用』g 都能由 eval 被唯一的构造出来，那么 a⇒b 就是最好的那个候选者。

形式定义如下：

一个从 a 到 b 的函数对象是伴随着态射eval :: ((a⇒b) × a) -> b的a⇒b，它对于伴随着态射g :: z × a -> b的任意其他对象 z 而言，存在唯一的态射h :: z -> (a⇒b)， g 可表示为 h 与 eval 所构成的因式：g = eval ∘ (h × id)。

虽然不能担保对于某个范畴中的任意的对象 a 与 b 都存在着 a⇒b，但是对于集合的范畴却总是存在着这样的 a⇒b，并且在集合的范畴中，a⇒b 与 Hom-集 Set(a,b) 同构。这也是为何在 Haskell 中我们将函数类型 a -> b 解释为范畴意义上的函数对象 a⇒b 的原因。

Currying - 柯里化

再次观察函数类型的所有候选者。不过这次将态射 g 视为两个变量 z 与 a 的函数：g :: z × a -> b 一个接受积类型的态射与一个接受两个变量的函数很相似。特别是在集合的范畴中，g 是接受值的序对的函数，其中一个值来自集合 z，另一个来自集合 a。另一方面，泛性质告诉我们，对于每个这样的 g，都存在唯一的态射 h——将 z 映射为一个函数类型 a⇒b：h :: z -> (a⇒b)

在集合的范畴中，这恰恰意味着 h 是一个接受 z 类型并返回一个从 a 到 b 的函数的函数。也就是说，h 是一个高阶函数。因此这种泛构造在「接受两个变量的函数」与「接受一个变量并返回函数的函数」之间建立了壹壹对应的关系。这种对应关系叫做柯里化，并且 h 叫做 g 的柯里化版本。

这种对应关系一对一的，因为对于任意 g 都存在唯一的 h，而对于任意的 h，总是能重建一个接受 2 个参数的函数 g，即：g = eval ∘ (h × id) 可将函数 g 称为 h 的反柯里化版本 (uncurried)。

柯里化是 Haskell 内建的语法。返回一个函数的函数：a -> (b -> c) 经常被视为一个接受两个参数的函数，也就是将上述的函数签名中的括号去掉，即：a -> b -> c 严格的说，接受 2 个参数的函数，它本质上接受的是一个序对（积类型）：(a, b) -> c

有两个函数可以实现它们的相互转换，这两个函数分别叫 curry 与 uncurry：

curry :: ((a, b)->c) -> (a->b->c)
curry f a b = f (a, b)

uncurry :: (a->b->c) -> ((a, b)->c)
uncurry f (a, b) = f a b

注意，curry 是函数类型泛构造的因子生成器，将其写为下面的形式会更清晰一些

1
2

factorizer :: ((a, b)->c) -> (a->(b->c))
factorizer g = \a -> (\b -> g (a, b))

在非函数式语言中，例如 C++，可以实现柯里化，但不是那么简单。借助模板 std::bind，可实现 C++ 函数的部分应用。

std::string catstr(std::string s1, std::string s2) {
        return s1 + s2;
}

using namespace std::placeholders;

auto greet = std::bind(catstr, "Hello ", _1);
std::cout << greet("Haskell Curry");

虽然 Scala 要比 C++ 或 Java 更加的函数化，但是它却做不到函数的部分应用。如果需要函数能被部分应用，必须借助多参数列表：

`1`	`def catstr(s1: String)(s2: String) = s1 + s2`

Exponentials - 指数

在数学领域，从对象 a 到对象 b 的函数或内 hom-对象（hom-集合中的对象）通常称为指数，表示为$b^a$ 。注意，函数参数类型位于指数的位置。

考虑一下那些建立在有限类型——值的数量为有限的类型，例如 Bool, Char, 甚至 Int 或 Double 之上的函数。至少在理论上，这些函数可被记忆化，亦即可将这些函数转化为表，然后通过查表的方式获得函数返回值。这是函数（态射）与函数类型（对象）之间等价的本质。

例如，一个接受 Bool 的（纯）函数可以被特化为一对值：一个对应于 False，另一个对应于 True 。比方说，所有从 Bool 到 Int 的函数等价于所有 Int 序对所构成的集合，用积来表示就是 Int × Int，或者再有点创造性，可将其表示为 $Int^2$ $Int^{Bool}$。

再看一个例子，C++ 的 char 类型，它包含 256 个值。在 C++ 标准库中经常会使用数据查询的方式来定义一些函数。例如 isupper 或 isspace 都是用表来实现的，它等价于 256 个布尔值构成的元组。元组是积类型，因此我们要处理的是 256 个 Bool 值的积：bool × bool × bool × … × bool。在算术中，重复的积就是幂。如果你将 bool 乘以它自身 256（或 char）次，那么你得到的就是 $bool^{char}$。bool 的 256-元组一共有多少个？答案是 $2^{256}$ 个。这也就是从 char 到 bool 的不同函数的总数，每个函数对应唯一的 256-元组。同理，从 bool 到 char 的函数数量是 $256^2$ 。在这些例子中，函数类型的指数表示相当美妙。

我们可能并不想将一个接受 int 或 double 的函数完全的记忆化，因为这样不切实际，但是函数与数据类型之间的等价性总是客观存在的。还有一些有限类型，例如列表、字符串或树，如果将接受这些类型的函数进行记忆化，需要无限的存储空间。然而 Haskell 是一种惰性语言，因此在惰性求值的（无限的）数据结构与函数之间的界限并不那么明显。这种函数与数据之间的对偶性揭示了 Haskell 的函数类型与范畴化的指数对象之间的等价性——我们又朝向数据迈进了一步。

Cartesian Closed Categories - 笛卡尔闭范畴

一个笛卡尔闭范畴必须包含：终端对象、任意对象序对的积、任意对象序对的指数。集合范畴就属于此类范畴。

若能将指数想象为重复的积（可能是无限次），那么你就可以将笛卡尔闭范畴想象为支持任意数量的积运算的范畴。特别是，可将终端对象想象为 0 个对象的积，或者一个对象的 0 次幂。从计算机科学的角度来看，笛卡尔闭范畴的有趣之处在于它为简单的类型 Lambda 演算提供了模型。

终端对象与积也分别具有对偶物：初始对象与余积。笛卡尔闭范畴也支持后者，积通过分配率可转化为余积：

1
2

a × (b + c) = a × b + a × c
(b + c) × a = b × a + c × a

这样的范畴被称为双向笛卡尔闭范畴(bicartesian closed category)。

Exponentials and Algebraic Data Types - 指数与代数数据类型

从指数的角度来阐释函数类型，这种方式也能很好的适用于代数数据类型。事实上，中学代数中所涉及的 0，1，加法，乘法以及指数等结构，在任何双向笛卡尔闭范畴中同样存在，它们分别对应于初始对象，终端对象，余积，积以及指数等。

Zeroth Power - 0次幂

$a^0 = 1$

在范畴论中，0 即初始对象，1 即终端对象，『相等』即恒等态射。指数即内 hom-对象。面这个特殊的指数表示的是从初始对象到任意对象 a 的态射集合。基于初始对象的定义，这样的态射只有一个，因此 hom-集 $C(0,a)$ 是一个单例集合。一个单例集合在集合范畴中是终端对象，因此上面这个等式在集合范畴中是成立的，这也意味着它在任何双向笛卡尔闭范畴中都成立。

在 Haskell 中，用 Void 表示 0，用 unit 类型 () 表示 1，用函数类型表示指数。所有从 Void 到任意类型 a 的函数集合等价于 unit 类型——单例集合。换句话说，有且仅有一个函数 Void -> a，这个函数叫 absurd。不过，这样讲有些不严谨，原因有二。第一，在 Haskell 不存在没有值的类型——每种类型都包含着『永不休止的运算』，即底。第二，absurd 的所有实现都是等价的，因为无论用那种方式实现它们，也没人能够执行它们——没有值可以传递给 absurd。（如果你传递给它一个永不休止的运算，它什么也不会返回！）

Power of One - 1的幂

$1^a = 1$

在集合范畴中，这个等式重申了终端对象的定义：从任意对象到终端对象存在唯一的态射。从 a 到终端对象的内 home-对象通常与终端对象本身是同构的。在 Haskell 中，只有一个函数是从任意类型 a 到 unit 类型的，之前见过这个函数—— unit。你可以认为它是 const 函数对 () 的偏应用。

First Power - 1次幂

$a^1 = a$

这个等式重申了从终端对象出发的态射可用于从对象 a 中拮取元素。这种态射的集合与对象 a 本身是同构的。在集合范畴与 Haskell 中，集合 a 与从 a 中拮取元素的函数 () -> a 是同构的。

Exponentials of Sums - 指数的和

$a^{b+c} = a^c + b^c$

从范畴论的角度来看，这个等式描述的幂为两个对象的余积的指数与两个指数的积同构。

在 Haskell 中，这种代数等式有着非常特别的解释，它告诉了我们，两个类型的和的函数与两个参数类型为单一类型的函数的积同构。这恰恰就是我们在定义作用于和类型的函数时所用到的分支分析，也就是说，函数定义中的 case 语句可以用两个或多个处理特定类型的函数来替代。例如，下面这个从和类型 (Eigher Int Double) 出发的函数 f：f :: Either Int Double -> String 可以定义为一个函数对：

1
2

f (Left n)  = if n < 0 then "Negative int" else "Positive int"
f (Right x) = if x < 0.0 then "Negative double" else "Positive double"

在此，n 是 Int，而 x 是 Double。

Exponentials of Exponentials - 指数的指数

$(a^b)^c = a^{b \times c}$

这个等式表达的是指数对象形式的柯里化——返回一个函数的函数等价与积类型的函数（带两个参数的函数）。

Exponentials over Products - 积的指数

$(a \times b)^c = a^c \times b^c$

在 Haskell 中，返回一个序对的函数与一对函数等价，后者的每个函数都返回序对的一个元素。

Curry-Howard Isomorphism 柯里-霍华德同构

逻辑学与代数数据类型之间有一些对应。Void 类型与 unit 类型 () 分别对应于错误与正确。积类型与和类型分别对应于逻辑与运算 $\vee$ 与逻辑或运算 $\wedge$ 。遵循这一模式，我们所定义的函数类型对应于逻辑推理$\Longrightarrow$ ，换句话说，类型 a -> b 可以读为『如果 a 那么 b』。

根据柯里-霍华德同构理论，每种类型可视为一个命题——为真或为假的陈述语句。如果类型是有值的，那么它就是真命题，否则就是伪命题。在实践中，如果一个函数类型有值，亦即存在这样的函数，那么与它对应的逻辑推理就为真。去实现一个函数，就是在证明一个定理。写程序，就等价于证明许多定理。下面看几个例子。

以函数类型定义中所用的 eval 函数为例，它的签名是：eval :: ((a -> b), a) -> b 它接受一个由函数与其参数构成的序对，产生相应的类型。这个函数是一个态射的 Haskell 实现，该态射为： eval :: (a⇒b) × a -> b 这个态射定义了函数类型 a⇒b（或指数类型$b^a$ ）。运用柯里-霍华德同构理论，可将这个签名转化为逻辑命题：$((a \Longrightarrow b) \vee a ) \Longrightarrow b$ 可将上面这条陈述读为：如果 b 由 a 推出为真，并且 a 为真，那么 b 肯定为真。这就是所谓的肯定前件式。要证明这个定理，只需要实现一个函数，即：eval :: ((a -> b), a) -> b eval (f, x) = f x 如果你给我一个从 a 到 b 的函数 f 以及 a 类型的一个值 x 所构成的序对，我就可以将 f 作用于 x，从而产生 b 类型的一个值。通过实现这个函数，我可以证明 ((a -> b), a) -> b 是有值的。因此，在我们的逻辑中，这一肯定前件式为真。

结果为假的逻辑命题是怎样的？看这个例子，如果 a 或 b 为真，那么 a 肯定为真：$a \wedge b \Longrightarrow b$ 这个命题肯定是错的，因为当 a 为假而 b 为真时，就可以构成一个反例。运用柯里-霍华德同构理论，可将这个命题映射为函数签名：Either a b -> a 根本无法实现这样的函数，因为对于 Right 构造的值而言，无法产生类型为 a 的值。（注意，说的是纯函数）。

最后，来理解一下 absurd 函数：absurd :: Void -> a 将 Void 视为假，可得：$false \Longrightarrow a$ 这意味着由谎言可推理出一切（爆炸原理）。对于这个命题（函数），下面用 Haskell 给出的一个证据（实现）：absurd (Void a) = absurd a 其中 Void 的定义如下：newtype Void = Void Void 这是我们惯用的花招，这个定义使得 Void 不可能用于构造一个值，因为你要用它构造一个值，前提是必须先提供这个类型的一个值。这样就可以使得 absurd 永远无法被调用。

1.8 Functoriality - 函子性

Thu, 26 Mar 2020 00:00:00 +0800

Functoriality - 函子性

Functoriality

<译> 函子性

Bifunctors - 二元函子

函子是Cat（范畴的范畴，the category of categories）中的态射，因此对态射/函数形成的大部分直觉对函子也能成立。例如，一个函数能有两个参数，函子也可以有两个参数，这种函子称为二元函子/Bifunctor。对对象而言，二元函子将每个对象对（一个来自范畴C，另一个来自范畴D）映射为范畴E中的某个对象。也就是说，二元汉字是将范畴C与范畴D的笛卡尔积CxD映射为E。

函子性也要求一个函子必须能映射态射。二元函子必须将一个态射对（一个来自C另一个来自D）映射为E中的态射。注意，这个态射对，只不过是范畴CxD中的一个态射。若一个态射是在范畴的笛卡尔积中定义的，那么它的行为就是将一对对象映射为另一对对象。这样的态射对可以复合：(f, g) ∘ (f', g') = (f ∘ f', g ∘ g')。这种复合是符合结合律的，并且它也有一个恒等态射，即恒等态射对 (id, id)。因此，范畴的笛卡尔积实际上也是一个范畴。

将二元函子想象为具有两个参数的函数会更直观一些。要证明二元函子是否是函子，不必借助函子定律，只需独立的考察它的参数即可。如果有一个映射，它将两个范畴映射为第三个范畴，只需证明这个映射相对于每个参数（例如，让另一个参数变成常量）具有函子性，那么这个映射就自然是一个二元函子。对于态射，也可以这样来证明二元函子具有函子性。

下面用 Haskell 定义一个二元函子。在这个例子中，三个范畴都是同一个：Haskell 类型的范畴。一个二元函子是一个类型构造子，它接受两个类型参数。下面是直接从 Control.Bifunctor 库中提取出来的 Bifunctor 类型类的定义：

class Bifunctor f where
    bimap :: (a -> c) -> (b -> d) -> f a b -> f c d
    bimap g h = first g . second h
    first :: (a -> c) -> f a b -> f c b
    first g = bimap g id
    second :: (b -> d) -> f a b -> f a d
    second = bimap id

类型变量 f 表示二元函子，可以看到有关它的所有类型签名都是作用于两个类型参数。第一个类型签名定义了 bimap 函数，它将两个函数映射为一个被提升了的函数 (f a b -> f c d)，后者作用于二元函子的类型构造子所产生的类型。 bimap 有一个默认的实现，即 first 与 second 的复合，这表明只要 bimap 分别对两个参数都具备函子性，就意味着它是一个二元函子。其他两个类型签名是 first 与 second，他们分别作用于 bimap 的第一个与第二个参数，因此它们是 f 具有函子性的两个 fmap 证据。上述类型类的定义以 bimap 的形式提供了 first 与 second 的默认实现。

当声明 Bifunctor 的一个实例时，可以去实现 bimap，这样 first 与 second 就不用再实现了；也可以去实现 first 与 second，这样就不用再实现 bimap 了。当然，也可以三个都实现了，但是需要确定它们之间要满足类型类的定义中的那些关系。

Product and Coproduct Bifunctors - 积与余积二元函子

二元函子的一个重要的例子是范畴积——由泛构造（Universal Construction）定义的两个对象的积。如果任意一对对象之间存在积，那么从这些对象到积的映射就具备二元函子性，这通常是正确的，特别是在 Haskell 中。

序对构造子就是一个 Bifunctor 实例——最简单的积类型：

instance Bifunctor (,) where
    -- bimap :: (a -> c) -> (b -> d) -> (a, b) -> (c, d)
    bimap f g (x, y) = (f x, g y)

(,) a b = (a, b)

余积作为对偶，如果它作用于范畴中的每一对对象，那么它也是一个二元函子。在 Haskell 中，余积二元函子的例子是 Either 类型构造子，它是 Bifunctor 的一个实例：

instance Bifunctor Either where
    -- bimap :: (a -> c) -> (b -> d) -> (a, b) -> (c, d)
    bimap f _ (Left x)  = Left (f x)
    bimap _ g (Right y) = Right (g y)

Functorial Algebraic Data Types - 具有函子性的代数数据类型

复杂的数据类型是由简单的数据类型构造出来的。特别是代数数据类型（ADT），它是由和与积创建的。基于和与积的函子性，也了解了函子的复合。因此，若能揭示代数数据类型的基本构造块是具备函子性的，那么就可以确定代数数据类型也具备函子性。

参数化的代数数据类型的基本构造块是什么？首先，有些构造块是不依赖于函子所接受的类型参数的，例如 Maybe 中的 Nothing，List 中的 Nil。它们等价于 Const 函子。记住，Const 函子忽略它的类型参数（实际上是忽略第二个类型参数，第一个被保留作为常量）。

其次，有些构造块简单的将类型参数封装为自身的一部分，例如 Maybe 中的 Just，它们等价于恒等函子。之前提到过恒等函子，它是 Cat 范畴中的恒等态射，不过 Haskell 未对它进行定义。给出它的定义(可将 Indentity 视为最简单的容器，它只存储类型 a 的一个（不变）的值。)：

data Identity a = Identity a

instance Functor Identity where
    fmap f (Identity x) = Identity (f x)

其他的代数数据结构都是使用这两种基本类型的和与积构建而成。基于此，从一个新的角度来看 Maybe 类型构造子：data Maybe a = Nothing | Just a 它是两种类型的和，现在知道求和运算是具备函子性的。第一部分，Nothing 可以表示为作用于类型 a 的 Const ()（Const 的第一个类型参数是 unit），而第二部分不过是恒等函子的化名而已。在同构的意义下，我们可以将 Maybe 定义为：type Maybe a = Either (Const () a) (Identity a) 因此，Maybe 是 Const () 函子与 Indentity 函子被二元函子 Either 复合后的结果。Const 本身也是一个二元函子，只不过在这里用的是它的偏应用形式。

两个函子的复合后，其结果是一个函子。还需要做的就是描述两个函子被一个二元函子复合后如何作用于态射。对于给定的两个态射，我们可以分别用这两个函子对其进行提升，然后再用二元函子去提升这两个被提升后的态射所构成的序对。

可以在 Haskell 中表示这种复合。先定义一个由二元函子 bf 参数化的数据类型，两个函子 fu 与 gu，以及两个常规类型 a 与 b。我们将 fu 作用于 a，将 gu 作用于 b，然后将 bf 作用于 fu a 与 fu b：newtype BiComp bf fu gu a b = BiComp (bf (fu a) (gu b)) 这是对象的复合，在 Haskell 中也就是类型的复合。(在 Haskell 中，类型构造子作用于类型，就像函数作用于它的参数一样)。考虑将 BiComp 作用于 Either，Const ()，Indentity，a，b。得到的是一个裸奔版本的 Maybe b（a 被忽略了）。

如果 bf 是一个二元函子，fu 与 gu 都是函子，那么这个新的数据类型 BiComp 就是 a 与 b 之间的二元函子。编译器必须知道与 bf 匹配的 bimap 的定义，以及分别与 fu 与 gu 匹配的 fmap 的定义。在 Haskell 中，这个条件可以预先给出：一个类约束集合后面尾随一个粗箭头：

instance (Bifunctor bf, Functor fu, Functor gu) =>
  Bifunctor (BiComp bf fu gu) where
    bimap f1 f2 (BiComp x) = BiComp ((bimap (fmap f1) (fmap f2)) x)

-- x :: bf (fu a) (gu b)
-- f1 :: a -> a'
-- f2 :: b -> b'
-- bimap (fu a -> fu a') -> (gu b -> gu b') -> bf (fu a) (gu b) -> bf (fu a') (gu b')

没有必要去证明 Maybe 是一个函子，由于它是两个基本的函子求和后的结果，因此 Maybe 自然也就具备了函子性。

代数数据结构的规律性不仅适用于 Functor 的自动继承，也适合其它的类型类，例如之前提到的 Eq 类型类。

对于代数数据类型而言，Functor 实例的继承相当繁琐，这个过程有无可能由编译器自动完成？的确，编译器能做到这一点。你需要在代码的首部中启用 Haskell 的扩展：{-# LANGUAGE DeriveFunctor #-} 然后在数据结构中添加 deriving Functor： data Maybe a = Nothing | Just a deriving Functor 然后就会得到相应的 fmap 的实现

Functors in C++ - C++ 中的函子

data Tree a = Leaf a | Node (Tree a) (Tree a)
    deriving Functor

instance Functor Tree where
    fmap f (Leaf a) = Leaf (f a)
    fmap f (Node t t') = Node (fmap f t) (fmap f t')

基于dynamic_cast 替代模式匹配

template<class T>
struct Tree {
    virtual ~Tree() {}; // 为了支持动态类型转换，基类至少需要定义一个虚函数，因此将析构函数定义为虚函数（在任何情况下这都是个好主意）
};

template<class T>
struct Leaf : public Tree<T> {
    T _label;
    Leaf(T l) : _label(l) {}
};

template<class T>
struct Node : public Tree<T> {
    Tree<T> * _left;
    Tree<T> * _right;
    Node(Tree<T> * l, Tree<T> * r) : _left(l), _right(r) {}
};

template<class A, class B>
Tree<B> * fmap(std::function<B(A)> f, Tree<A> * t)
{
    Leaf<A> * pl = dynamic_cast <Leaf<A>*>(t);
    if (pl)
        return new Leaf<B>(f (pl->_label));
    Node<A> * pn = dynamic_cast<Node<A>*>(t);
    if (pn)
        return new Node<B>( fmap<A>(f, pn->_left)
                          , fmap<A>(f, pn->_right));
    return nullptr;
}

The Writer Functor - Writer 函子

在 Kleisli 范畴中，态射被表示为被装帧过的函数，返回 Writer 数据结构。type Writer a = (a, String) 这种装帧与自函子有一些关系，并且 Writer 类型构造子对于 a 具有函子性。不需要去为它实现 fmap，因为它只是一种简单的积类型。

Kleisli 范畴与一个函子之间存在什么关系呢？一个 Kleisli 范畴，作为一个范畴，它定义了复合与恒等。复合是通过小鱼运算符实现的,恒等态射是一个叫做 return 的函数

(>=>) :: (a -> Writer b) -> (b -> Writer c) -> (a -> Writer c)
m1 >=> m2 = \x -> 
    let (y, s1) = m1 x
        (z, s2) = m2 y
    in (z, s1 ++ s2)

return :: a -> Writer a
return x = (x, "")

仔细审度这两个函数的类型，结果会发现，可以将它们组合成一个函数，这个函数就是 fmap：fmap f = id >=> (\x -> return (f x))。这里，小鱼运算符组合了两个函数：一个是 id，另一个是一个匿名函数，它将 return 作用于 f x。最难理解的地方可能就是 id 的用途。小鱼运算符难道不是接受一个『常规』类型，返回一个经过装帧的类型吗？实际上并非如此。没人说 a -> Writer b 中的 a 必须是一个『常规』类型。它是一个类型变量，因此它可以是任何东西，特别是它可以是一个被装帧的类型，例如 Writer b。因此，id 将会接受 Writer a，然后返回 Writer a。小鱼运算符就会拿到 a 的值，将它作为 x 传给那个匿名函数。在匿名函数中，f 会将 x 变成 b，然后 return 会对 b 进行装帧，从而得到 Writer b。把这些放到一起，最终就得到了一个函数，它接受 Writer a，返回 Writer b，这正是 fmap 想要的结果。

上述讨论是可以推广的：你可以将 Writer 替换为任何一个类型构造子。只要这个类型构造子支持一个小鱼运算符以及 return，那么你就可以定义 fmap。因此，Kleisli 范畴中的这种装帧，实际上是一个函子。（尽管并非每个函子都能产生一个 Kleisli 范畴）

刚才定义的 fmap 是否与编译器使用 deriving Functor 自动继承来的 fmap 相同？它们是相同的。这是 Haskell 实现多态函数的方式所决定的。这种多态函数的实现方式叫做参数化多态，它是所谓的免费定理（Theorems for free）之源。这些免费的定理中有一个是这么说的，如果一个给定的类型构造子具有一个 fmap 的实现，它能维持恒等（将一个范畴中的恒等态射映射为另一个范畴中的恒等态射），那么它必定具备唯一性。

Covariant and Contravariant Functors - 协变与逆变函子

现在来回顾 Reader 函子。Reader 函子是『函数箭头』类型构造子的的偏应用（译注：函数箭头 -> 本身就是一个类型构造子，它接受两个类型参数）。(->) r 可以给它取一个类型别名：type Reader r a = r -> a 将它声明为 Functor 的实例，跟之前我们见过的类似：instance Functor (Reader r) where fmap f g = f . g

但是，函数类型构造子接受两个类型参数，这一点与序对或 Either 类型构造子相似。序对与 Either 对于它们所接受的参数具备函子性，因此它们二元函子。函数类型构造子也是一个二元函子吗？

试让函数类型构造子对于第一个参数具备函子性。为此需要再定义一个类型别名——与 Reader 相似，只是参数次序颠倒了一下：type Op r a = a -> r 将返回类型 r 固定了下来，只让参数类型是 a 可变的。与它相匹配的 fmap 的类型签名如下： fmap :: (a -> b) -> (a -> r) -> (b -> r) 只凭借 a -> b 与 a -> r 这两个函数，显然无法构造 b -> r！如果我们以某种方式将第一个函数的参数翻转一下，让它变成 b -> a，这样就可以构造 b -> r 了。虽然我们不能随便反转一个函数的参数，但是在相反的范畴中可以这样做。

对于每个范畴$C$，存在一个对偶范畴$C^{op}$，后者所包含的对象与前者相同，但是后者所有的箭头都与前者相反。假设 $C^{op}$ 与另一个范畴 $D$ 之间存在一个函子：$F :: C^{OP} \times D$ 这种函子将 $C^{OP}$ 中的一个态射 $f^{OP} :: a \rightarrow b$ 映射为 $D$ 中的一个态射 $F f^{OP} :: F a \rightarrow F b$ . 但是，态射 $f^{op}$ 在原范畴 $C$ 中与某个态射 $f :: b \rightarrow a$ 相对应，它们的方向是相反的。

F是一个常规的函子，基于F定义一个映射，这个映射不是函子，称之为G. 这个映射从C到D，映射对象时功能与F相同，作用于态射时，它会将态射的方向反转。它接受C中的一个态射$f :: b \rightarrow a$，将其映射为相反的态射 $f^{OP} :: a \rightarrow b$，然后用函子F作用于这个被反转的态射，得到 $F f^{OP} :: F a \rightarrow F b$。假设 F a与G a相同，F b 与 G b 相同，整个过程可描述为， $G f :: (b \rightarrow a) \rightarrow (G a \rightarrow G b)$。

这是一个『带有一个扭结的函子』。是范畴的一个映射，它反转了态射的方向，这种映射被称为逆变函子。注意，逆变函子只不过来自相反范畴的一个常规函子。顺便说一下，这种常规函子——我们已经碰到很多了——被称为协变函子。

下面是 Haskell 中逆变函子的类型类的定义（实际上，是逆变自函子）：

class Contravariant f where
    contramap :: (b -> a) -> (f a -> f b)

-- Op is an instance 
instance Contravariant (Op r) where
    -- (b -> a) -> Op r a -> Op r b
    contramap f g = g . f


flip :: (a -> b -> c) -> (b -> a -> c)
flip f y x = f x y

-- ==>
contramap = flip (.)

Profunctors - 副函子

已经看到了函数箭头运算符对于它的第一个参数是具有逆变函子性，而对于它的第二个参数则具有协变函子性。如果是集合范畴，这种东西叫副函子（Profunctor）。由于一个逆变函子等价于相反范畴的协变函子，因此可以这样定义一个副函子：$C^{OP} \times D \rightarrow Set$。因为 Haskell 的类型与集合差不多，所以我们可将 Profunctor 这个名字应用于一个类型构造子 p，它接受两个参数，它对于第一个参数具有逆变函子性，对于第二个参数则具有协变函子性。

class Profunctor p where
  dimap :: (a -> b) -> (c -> d) -> p b c -> p a d
  dimap f g = lmap f . rmap g
  lmap :: (a -> b) -> p b c -> p a c
  lmap f = dimap f id
  rmap :: (b -> c) -> p a b -> p a c
  rmap = dimap id

这三个函数只是默认的实现。就像 Bifunctor 那样，当声明 Profunctor 的一个实例时，你要么去实现 dimap，要么去实现 lmap。现在，我们宣称函数箭头运算符是 Profunctor 的一个实例了：

instance Profunctor (->) where
    dimap ab cd bc = cd . bc . ac
    lmap = flip (.)
    rmap = (.)

The Hom-Functor - Hom-函子

hom-set C(a, b) 是个从范畴$C^{OP} \times C$ 到集合范畴 Set 的函子。$C^{OP} \times C$中的态射是一对C上的态射 f :: a' -> a g :: b' -> b 这对态射的“提升”版本必定是集合C(a, b)到集合C(a’, b’)的态射/函数。从C(a,b)中取一个元素h h :: a -> b，然后 g ∘ h ∘ f便是集合C(a’, b’)中的元素。

如上所见，hom-函子是副函子的一个特例。

1.7 Functors - 函子

Sat, 21 Mar 2020 00:00:00 +0800

Link to Blog

<译> 函子

Functors - 函子

函子是范畴之间的映射。给定两个范畴C与D，函子F可以将C中的对象映射为D中的对象，可以将C中态射映射为D中态射，并保持其结构。若C中有对象a，它在D中的象为Fa；C中有从对象a到b的态射f，其在D中的象为Ff，从Fa到Fb。此外，态射的复合也应当符合直觉的，在范畴C中h是g与f的复合，那么在范畴D中，Fh应当是Fg与Ff的复合。最后，C中的恒等态射被映射为D中的恒等态射。$Fid_a = id_{Fa}$ (F ida = idFa) ida 是作用于对象a的恒等态射，idFa是作用于对象Fa的恒等态射。

函子比常规函数的约束更为严格，函子必须保持范畴的结构。

函子可以做折叠或嵌入的工作。所谓嵌入，就是将一个小的源范畴嵌入到更大的目标范畴中。一个极端的例子，源范畴是个单例范畴——只有一个对象与一个态射（恒等态射）的范畴，从单例范畴映射到任何其他范畴的函子，所做的工作就是在后者中选择一个对象。这完全类似于接受单例集合的态射，这个态射会从目标集合中选择元素。最巨大的折叠函子被称为常函子$\triangle_C$，它将源范畴中的每个对象映射为目标范畴中特定的对象 c，它也可以将源范畴中的每个态射映射为目标范畴中的特定的恒等态射$id_c$，它在行为上像一个黑洞，将所有东西压成一个奇点。在讨论极限与余极限时，我们再来考察这个黑洞函子。

Functors in Programming - 编程中的函子

functors that map this category into itself — such functors are called endofunctors.

函子将这个范畴映射为其自身——这样的函子被称为自函子。

Maybe Functor - Maybe 函子

Maybe 的定义就是将类型 a 映射为类型 Maybe a：data Maybe a = Nothing | Just a。

Maybe 本身不是一个类型，它是一个类型构造子（Constructor）。必须向它提供一个类型参数，例如 Int 或 Bool，然后才可以使其变成一个类型。如不果不向 Maybe 提供任何参数，那么它就是一个作用于类型的函数。

一个函子不仅仅只映射对象（在此，是类型），它也映射态射（在此，是函数）。对于任何从 a 到 b 的函数：f :: a -> b被 Maybe 函子映射为：f' :: Maybe a -> Maybe b。Haskell 以高阶函数的形式实现了一个函子的态射映射部分，这个函数叫 fmap。对于 Maybe 的情况，这个函数的签名如下：fmap :: (a -> b) -> (Maybe a -> Maybe b)。通常说fmap提升（Lift）了一个函数。被提升的函数作用于 Maybe 层次上的值。

为了说明类型构造子 Maybe 携同函数 fmap 共同形成一个函子，不得不证明 fmap 能够维持恒等态射以及态射的复合的存在。所证明的东西，叫做『函子定律』。凡是满足函子定律的函子，必定不会破坏范畴的结构。

Equational Reasoning - 等式推导

为了证明函子定律，我需要借助等式推导，这也是 Haskell 中常用的证明技巧。它利用了 Haskell 函数基于等式定义这一优势：左侧等于右侧。总是可以用其中一侧替换另一侧，只是有时变量名需要改一下以避免名字冲突。可以将这种替换视为内联一个函数，或者将一个表达式重构为一个函数。这种替换可以从两个方向进行，如果一个函数是基于模式匹配定义的，可以单独使用它的子定义。

先从证明函子对恒等态射的维持开始：fmap id = id。要考虑两种情况：Nothing 与 Just。

  fmap id Nothing 
= { definition of fmap }
  Nothing 
= { definition of id }
  id Nothing

  fmap id (Just x) 
= { definition of fmap }
  Just (id x) 
= { definition of id }
  Just x
= { definition of id }
  id (Just x)

现在来证明 fmap 能够维持态射的复合：fmap (g . f) = fmap g . fmap f

  fmap (g . f) Nothing 
= { definition of fmap }
  Nothing 
= { definition of fmap }
  fmap g Nothing
= { definition of fmap }
  fmap g (fmap f Nothing)

  fmap (g . f) (Just x)
= { definition of fmap }
  Just ((g . f) x)
= { definition of composition }
  Just (g (f x))
= { definition of fmap }
  fmap g (Just (f x))
= { definition of fmap }
  fmap g (fmap f (Just x))
= { definition of composition }
  (fmap g . fmap f) (Just x)

Optional

Maybe一般其它语言中一般是Optional来实现。给出C++中的伪实现

template<class T>
class optional {
    bool _isValid; // the tag
    T    _v;
public:
    optional()    : _isValid(false) {}         // Nothing
    optional(T x) : _isValid(true) , _v(x) {}  // Just
    bool isValid() const { return _isValid; }
    T val() const { return _v; }
};

// fmap - v1
template<class A, class B>
std::function<optional<B>(optional<A>)> 
fmap(std::function<B(A)> f) 
{
    return [f](optional<A> opt) {
        if (!opt.isValid())
            return optional<B>{};
        else
            return optional<B>{ f(opt.val()) };
    };
}

// fmap -v2
template<class A, class B>
optional<B> fmap(std::function<B(A)> f, optional<A> opt) {
    if (!opt.isValid())
        return optional<B>{};
    else
        return optional<B>{ f(opt.val()) };
}

Type Class - 类型类

Haskell使用类型类对函子进行抽象。一个类型类定义了支持一个公共接口的类型族。例如，支持相等谓词的类型类如下

1
2

class Eq a where
    (==) :: a -> a -> Bool

这个定义陈述的是，如果类型 a 支持 (==) 运算符，那么它就是 Eq 类。(==) 运算符接受两个类型为 a 的值，返回 Bool 值。如果你想告诉 Haskell 有一个特定的类型是 Eq 类，那么你不得不将其声明为这个类的一个实例，并提供 (==) 的实现。例如，一个二维 Point（两个 Float 的积类型）：data Point = Pt Float Float 需要为它定义相等谓词：

1
2

instance Eq Point where
    (Pt x y) == (Pt x' y') = x == x' && y == y'

这里将 (==) 作为中缀运算符使用，它处于 (Pt x y) 与 (Pt x’ y’) 之间，而函数体是单个 = 号后面的部分。一旦将 Point 声明为 Eq 的一个实例，你就可以直接比较点与点是否相等了。注意，与 C++ 或 Java 不同，在定义 Point 的时候不必指定它是 Eq 类（或接口）的实例——可在真正需要的时候再指定。

类型类是 Haskell 仅有的函数（运算符）重载机制。在为不同的函子重载 fmap 时需要借助类型类，尽管有一个难点：函子不能作为类型来定义，只能作为类型的映射来定义，即类型构造子。我们需要一个由类型构造子构成的族，而不是像 Eq 这样的类型族。所幸，Haskell 的类型类可以将类型构造子像类型那样来处理。因此，Functor 类的定义如下：

1
2

class Functor f where
    fmap :: (a -> b) -> f a -> f b

如果存在符合上述签名的 fmap 函数，这个类规定了 f 是一个 Functor。小写的 f 是一个类型变量，类似于类型变量 a 与 b，然而编译器能够推断出它是一个类型构造子，而不是一个类型，依据是它的用途：作用于其他类型，即 f a 与 f b。因此，要声明一个 Functor 的实例时，你不得不给它一个类型构造子，对于 Maybe 而言就是：

1
2
3

instance Functor Maybe where
    fmap _ Nothing = Nothing
    fmap f (Just x) = Just (f x)

顺便说一下，Functor 类，以及它的一些实例，这些实例是为大多数简单的数据类型而定义的，包括 Maybe，它们都是 Haskell 标准库的一部分。

Functor in C++

template<template<class> F, class A, class B>
F<B> fmap(std::function<B(A)>, F<A>);

// error! -  C++ 中是禁止模板函数的部分特化
template<class A, class B>
optional<B> fmap<optional>(std::function<B(A)> f, optional<A> opt)

// - 只能这样实现
template<class A, class B>
optional<B> fmap(std::function<B(A)> f, optional<A> opt) 
{
    if (!opt.isValid())
        return optional<B>{};
    else
        return optional<B>{ f(opt.val()) };
}

List Functor

data List a = Nil | Cons a (List a) List 是类型构造子，它将任意类型 a 映射为类型 List a。为了表明 List 是一个函子，我们不得不定义一个提升函数：接受一个 a -> b 的函数，产生一个 List a -> List b 的函数：fmap :: (a -> b) -> (List a -> List b) 列表函子的实例声明：

1
2
3

instance Functor List where
    fmap _ Nil = Nil
    fmap f (Cons x t) = Cons (f x) (fmap f t)

Reader Functor

已经对函子获得一些直觉了——例如，函子是某种容器。下面来个有点烧脑的例子，考虑一个从类型 a 到一个返回 a 的函数类型的映射。

在 Haskell 中，函数类型是使用箭头类型构造子 (->) 构造出来的，这个类型构造子接受两种类型：参数类型与返回类型。你已经见过这个类型构造子的中缀形式 a -> b，但是也可以写成前缀形式，像是被参数化了：(->) a b。就像常规的函数一样，接受多个参数的类型函数可以偏应用。因此，当我们向箭头只提供一个参数时，它依然期待另一个参数的出现。因此 (->) a也是个类型构造子。它需要一个类型 b 来产生完整的类型 a -> b。它所表示的是，它定义了一族由 a 参数化的类型构造子。

处理两个类型参数可能有点混乱，先做一些重命名的工作。在我们之前的函子定义中，我们可以将参数类型称为 r，将返回类型称为 a。因此我们的类型构造子可以接受任意类型 a，并将其映射为类型 r -> a。为了表明它是个函子，我们就需要一个函数，它可以将函数 a ->b 提升为一个从 r -> a 到 r -> b 的函数，而 r -> a 与 r -> b 就是 (->) r 这个类型构造子分别作用于 a 与 b 所产生的函数类型。以上讨论最终可归结为 fmap 的函数签名：fmap :: (a -> b) -> (r -> a) -> (r -> b) 解决一个难题：对于给定的函数 f :: a -> b 与 g :: r -> a，构造一个函数 r -> b。这是复合两个函数的唯一途径，也恰恰就是我们需要的。因此，我们需要将 fmap 的实现为：

1
2

instance Functor ((->) r) where
    fmap f g = f . g

就是我们想要的 fmap，紧凑些的表示fmap f g = (.) f g ，甚至 fmap = (.)

类型构造子 (->) r 与上面这个 fmap 组合起来所形成的函子被称为 Reader 函子。

Functors as Containers - 函子作为容器

纯函数是可以被保存下来的，函数的执行结果被扔到可检索的表中，而表是数据。 Haskell 具有惰性计算能力，一个传统的容器，譬如一个列表，实际上可以被实现为一个函数。例如，一个包含自然数的无限长的列表，可被定义为：nats :: [Integer] = [1..] 显然，一个无限长的列表是不能存储在内存中的。编译器将其实现为一个可以按需产生一组 Integer 值的函数。Haskell 有效的模糊了数据与代码的区别。可以将列表视为函数，也可以将函数视为从存储着参数与结果的表中查询数据。如果函数的定义域有界并且不太大，将函数变成表查询是完全可行的。

将函子对象（由自函子产生的类型的实例）视为包含着一个值或多个值的容器，即使这些值实际上并未出场。C++ 中的 std::future 函子在某些时间点上可以存储一个值，但是它不能担保这个值总是存在；如果你想访问这个值，可能会受阻，直到其它线程的计算过程。另一个例子是 Haskell 的 IO 对象，它包含着用户的输入，或者是我们的宇宙要显示于屏幕上的『Hello World!』的未来版本。根据这种解释，函子对象就是可以包含一个值或多个值的容器，这些值的类型参数化了函子对象。或者，函子对象可能包含产生这些值的方法。我们根本不关心能否访问这些值——这些事发生在函子作用范围之外。如果函子对象包含的值能够被访问，我们就可以看到相应的操作结果；如果它们不能被访问，我们所关心的只是操作的正确复合，以及伴随不改变任何事物的恒等函数的操作。

为了向你表明我们是如何的不关心函子对象内部的值，这里有一个类型构造子，它完全的忽略参数 a：data Const c a = Const c Const 类型构造子接受两种类型， c 与 a。就像我们处理箭头构造子那样，我们对其进行偏应用从而制造了一个函子。数据构造子（也叫 Const）仅接受 c 类型的值，它不依赖 a。与这种类型构造子相配的 fmap 类型为：fmap :: (a -> b) -> Const c a -> Const c b 因为这个函子是忽略类型参数的，所以 fmap 的实现也可以自由忽略那个函数参数——因为这个函数无事可做：

1
2

instance Functor (Const c) where
    fmap _ (Const v) = Const v

在 C++ 中可能更清晰一些，因为 C++ 中在类型参数与值之间有着明显的区别，前者出现于编译期间，后者出现于运行时：

template<class C, class A>
struct Const {
    Const(C v) : _v(v) {}
    C _v;
};

template<class C, class A, class B>
Const<C, B> fmap(std::function<B(A)> f, Const<C, A> c) {
    return Const<C, B>{c._v};
}

尽管它有些怪异，但是 Const 函子在许多结构中扮演着重要的角色。在范畴论中，它是$\triangle_C$函子的特例，后者我们在前面提到过的，就是那个黑洞函子，而 Const 是个黑洞自函子。

Functor Composition

函子的复合类似于集合之间的函数复合。两个函子的复合，就是两个函子分别对各自的对象进行映射的复合，对于态射也是这样。恒等态射穿过两个函子之后，它还是恒等态射。复合的态射穿过两个函子之后还是复合的态射。自函子很容易复合。

1
2
3

maybeTail :: [a] -> Maybe [a]
maybeTail [] = Nothing
maybeTail (x:xs) = Just xs

maybeTail 返回的结果是两个作用于 a 的函子 Maybe 与 [] 复合后的类型。这些函子，每一个都配备了一个 fmap，但是如果我们想将一个函数 f 作用于复合的函子 Maybe [] 所包含的内容，该怎么做？我们不得不突破两层函子的封装：使用 fmap 突破 Maybe，再使用 fmap 突破列表。例如，要对一个 Maybe [Int] 中所包含的元素求平方，可以这样做：

square x = x * x

mis :: Maybe [Int]
mis = Just [1, 2, 3]

mis2 = fmap (fmap square) mis

经过类型分析，对于外部的 fmap，编译器会使用 Maybe 版本的；对于内部的 fmap，编译器会使用列表版本的。于是，上述代码也可以写为：mis2 = (fmap . fmap) square mis 要记住，fmap 可以看作是只接受一个参数的函数： fmap :: (a -> b) -> (f a -> f b) 示例中，(fmap . fmap) 中的第 2 个 fmap 所接受的参数是： square :: Int -> Int 然后返回一个这种类型的函数： [Int] -> [Int] 第一个 fmap 接受这个函数，然后再返回一个函数： Maybe [Int] -> Maybe [Int] 最终，这个函数作用于 mis。因此两个函子的复合结果，依然是函子，并且这个函子的 fmap 是那两个函子对应的 fmap 的复合。

现在回到范畴论：显然函子的复合是遵守结合律的，因为对象的映射遵守结合律，态射的映射也遵守结合律。在每个范畴中也有一个恒等函子：它将每个对象都映射为其自身，将每个态射映射为其自身。因此在某个范畴中，函子具有与态射相同的性质。什么范畴会是这个样子？必须得有一个范畴，它包含的对象是范畴，它包含的态射是函子。也就是说，它是范畴的范畴。但是，所有范畴的范畴不得不包含它自身，这样我们就陷入了自相矛盾的境地，就像不可能存在集合的集合那样。然而，有一个叫做 Cat 的范畴，它包含了所有的小范畴。这个范畴是一个大的范畴，因此它就不可能是它自身的成员。所谓的小范畴，就是它包含的对象可以形成一个集合，而不是某种比集合还大的东西。请注意，在范畴论中，即使一个无限的不可数的集合也被认为是『小』的。我想我已经提到过这样的集合了，因为我们已经看过同样的结构在许多抽象层次上的重复出现。以后我们也会看到函子也能形成范畴。

Challenge

`1`	`let fmap = (<<)`

1.6 Simple Algebraic Data Types - 简单代数类型

Fri, 20 Mar 2020 00:00:00 +0800

Simple Algebraic Data Types - 简单代数类型

从很多地方看到，函数式世界里两类数据类型，和类型积类型。参考之前的视角，将编程语言的类型视为集合，类型的实例便是集合中的元素。笛卡尔积式的组合方式，便是积类型，枚举式的组合，便是和类型。（从得到的数据个数上看，积类型最终得到m*n个元素，而和类型只能得到m+n个）

Product Types - 积类型

积类型直接体现是元组/序对，元组并非严格可交换，如(Int, Bool)不能直接当(Bool, Int)来用，但这两者携带的信息是一样的。可以看作是不同格式存储了相同数据的，用swap :: (a, b) -> (b, a)可给出同构关系。

通过嵌套，可以得出((a, b), c) (a, (b, c))，这两种类型是不同的，但它们包含的元素是一一对应的，这也是同构。

在同构的条件下，不再坚持严格的相等性的话，可以揭示unit类型()类似数字乘法中的1。类型a的值与一个unit值构成的元组，除了a值之外，什么也不包含，即：(a, ())，该类型与a是同构的。可以构造同构关系rho :: (a, ()) -> a rho_inv :: a -> (a, ())。

These observations can be formalized by saying that𝐒𝐞𝐭(the category of sets)is a monoidal category. It’s a category that’s also a monoid, in the sense that you can multiplyo bjects(here,take their Cartesian product).

如果用形式化语言描述这些现象，可以说 Set（集合的范畴）是一个幺半群范畴，亦即这种范畴也是一个幺半群，这意味着你可以让对象相乘（在此，就是笛卡尔积）。

Haskell中还有更通用的办法来构造积类型，data Pair a b = P a b，Pair a b 是由 a 与 b 参数化的类型的名字；P 是数据构造子的名字。因为类型构造子与数据构造子的命名空间是彼此独立的，因此二者可以同名：data Pair a b = Pair a b

Record - 记录

可以给字段进行命名，这种构造称为记录，

如data Element = Element { name :: String , symbol :: String , atomicNumber :: Int }

Sum Types - 和类型

就像集合的范畴中的积能产生积类型那样，余积能产生和类型。

Haskell 官方实现的和类型如下：data Either a b = Left a | Right b。Either 在同构意义下是可交换的，也是可嵌套的，而且在同构意义下，嵌套的顺序不重要。因此，我们可以定义与三元组相等的和类型：data OneOfThree a b c = Sinistral a | Medial b | Dextral c

可以证明 Set 对于余积而言也是个（对称的）幺半群范畴。二元运算由不相交和（Disjoint Sum）来承担，unit 元素由初始对象来扮演。用类型术语来说，我们可以将 Either 作为幺半群运算符，将 Void 作为中立元素。也就是说，可以认为 Either 类似于运算符 +，而 Void 类似于 0。这与事实是相符的，将 Void 加到和类型上，不会对和类型有任何影响。例如：Either a Void 与 a 同构。这是因为无法为这种类型构造 Right 版本的值——不存在类型为 Void 的值。Either a Void 只能通过 Left 构造子产生值，这个值只是简单的封装了一个类型为 a 的值。这就类似于 a + 0 = a。

Haskell 中有Maybe类型data Maybe a = Nothing | Just a，表示值可能不存在。Maybe是两个类型的和。将两个构造子分开看，观察第一个，data NothingType = Nothing，它是一个叫做 Nothing 的单值的枚举。换句话说，它是一个单例，与 unit 类型 () 等价；第二个 data JustType a = Just a 的作用就是封装类型 a。于是 data Maybe a = Either () a

Haskell 中的列表类型，它被定义为一个（递归）的和类型：data List = Nil | Cons a (List a)

Algebra of Type - 类型代数

积类型与和类型，单独使用其中一个就可以定义一些有用的数据结构，但是二者组合起来或更加强大。

已经见识了类型系统中两种可交换的幺半群结构：用 Void 作为中性元素的和类型，用 () 作为中性元素的积类型。可以将这两种类型比喻为加法与乘法。在这个比喻中，Void 相当于 0，而 () 相当于 1。

现在来思考如何增强这个比喻。例如，与 0 相乘的结果为 0 么？换句话说，一个积类型中的一个成员是 Void，那么这个积类型与 Void 同构么？例如，是否存在一个 Int 与 Void 构成的序对？要创建序对，需要两个值。Int 值很容易获得，但是 Void 却没有值。因此，对于任意类型 a 而言，(a, Void) 是不存在的——它没有值——因此它等价于 Void。换句话说，a * 0 = 0。

另外加法与乘法在一起的时候，存在着分配律：a * (b + c) = a * b + a * c 那么对于积类型与和类型而言，是否也存在分配律？是的，不过一般是在同构意义下存在。上式的左半部分相当于：(a, Either b c) 右半部分相当于：Either (a, b) (a, c)，现给出能证明它们同构的转换

prodToSum :: (a, Either b c) -> Either (a, b) (a, c)
prodToSum (x, e) = 
    case e of
      Left  y -> Left  (x, y)
      Right z -> Right (x, z)

sumToProd :: Either (a, b) (a, c) -> (a, Either b c)
sumToProd e = 
    case e of
      Left  (x, y) -> (x, Left  y)
      Right (x, z) -> (x, Right z)

Mathematicians have a name for two such intertwined monoids: it’s called a semiring. It’s not a full ring, because we can’t define subtraction of types. That’s why a semiring is sometimes called a rig, which is a pun on “ring without an n” (negative).

数学家们为这种相互纠缠的幺半群取了个名字：半环（Semiring）。之所以不叫它们全环，是因为我们无法定义类型的减法。这就是为何半环有时也被称为 rig 的原因，因为『Ring without an n（negative，负数）』。在此不关心这些问题，我们关心的是怎么描述自然数运算与类型运算之间的对应关系。现列出一些对应关系

Numbers	Types
`0`	`Void`
`1`	`()`
`a + b`	`Either a b = Left a
`a * b`	`(a, b) or Pair a b = Pair a b`
`2 = 1 + 1`	`data Bool = True
`1 + a`	`data Maybe = Nothing

列表类型相当有趣，因为它被定义为一个方程的解，因为我们要定义的类型出现在方程两侧： List a = Nil | Cons a (List a) 如果将 List a 换成 x，就可以得到这样的方程： x = 1 + a * x 不能使用传统的代数方法去求解这个方程，因为对于类型，我们没有相应的减法与除法运算。不过，可以用一系列的替换，即不断的用 (1 + a*x) 来替换方程右侧的 x，并使用分配律，这样就有了下面的结果：

x = 1 + a*x
x = 1 + a*(1 + a*x) = 1 + a + a*a*x
x = 1 + a + a*a*(1 + a*x) = 1 + a + a*a + a*a*a*x
...
x = 1 + a + a*a + a*a*a + a*a*a*a...

最终是一个积（元组）的无限和，这个结果可被解释为：一个列表，要么是空的，即 1；要么是一个单例 a；要么是一个序对 a*a；要么是一个三元组 a*a*a；……以此类推

用符号变量来解方程，这就是代数！因此上面出现的这些数据类型被称为：代数数据类型。

类型代数的一个非常重要的解释。注意，类型 a 与类型 b 的积必须包含类型 a 的值与类型 b 的值，这意味着这两种类型都是有值的；两种类型的和则要么包含类型 a 的值，要么包含类型 b 的值，因此只要二者有一个有值即可。逻辑运算 and 与 or 也能形成半环，它们也能映射到类型理论：

Logic	Types
`false`	`Void`
`true`	`()`
`a
`a && b`	`(a, b)`

这是更深刻的类比，也是逻辑与类型理论之间的 Curry-Howard 同构的基础。以后在讨论函数类型时，对此再作探讨。

1.5 Products and Coproducts - 积与余积

Thu, 19 Mar 2020 00:00:00 +0800

Products and Coproducts

Link to Blog

<译> 积与余积

There is a common construction in category theory called the universal construction for defining objects in terms of their relationships. One way of doing this is to pick a pattern, a particular shape constructed from objects and morphisms, and look for all its occurrences in the category.

范畴论中有一个常见的构造，叫做泛构造（Universal Construction），它就是通过对象之间的关系来定义对象，其方式之一就是拮取一个模式——由对象与态射构成的一种特殊的形状，然后在范畴中观察它的各个方面。

Initial Object - 初始对象

把范畴想象成一张网，箭头从范畴的一端流向另一端。有序范畴中会出现这种现象，如偏序范畴。尝试将这一概念推广

We could generalize that notion of object precedence by saying that object 𝑎 is “more initial” than object 𝑏, if there is an arrow (amorphism) going from 𝑎 to 𝑏. We would then define the initial object as one that has arrows going to all other objects.

如果要说对象a比对象b更“初始”，那么必定存在一个箭头/态射是从a到b的。如果有个对象，它发出的所有箭头指向所有其它对象，那么这个对象就叫做初始对象。

对于一个给定范畴，可能无法保证初始对象一定存在，这还好说，但更麻烦的问题是，可能存在多个初始对象。考虑有序范畴，有序范畴要求任意两个对象之间最多存在一个箭头：小于或等于。基于此，给出定义：

The initial object is the object that has one and only one morphism going to any object in the category.

初始对象：这种对象有且仅有一个态射指向范畴中的任意一个对象

然而，即使这样定义初始对象也无法担它的唯一性（如果它存在），但是这个定义能担保最好的一件事是：在同构意义下，它具有唯一性。同构（Isomorphism）在范畴论中非常重要，过会儿再谈它。现在，我们只需要认定，初始对象的定义主要是为了让初始对象在同构意义下具备唯一性。

在此，给出几个与初始对象有关的例子：偏序集（通常称为 poset）的初始对象是那个最小的对象。有些偏序集没有初始对象——例如整数集。

集合范畴中，初始对象是空集。在Haskell总，空集相当于Void类型（C++中没有对应类型），而且从Void到任意类型的多态函数是唯一的，叫做absurd（absurd :: Void -> a）。这是一个态射族，由于它的存在，Void才成为类型范畴中的初始对象。

Terminal Object - 终端对象

The terminal object is the object with one and only one morphism coming to it from any object in the category.

终端对象，这种对象有且仅有一个态射来自范畴中的任意对象。

同样，终端对象在同构意义下具有唯一性。在偏序集内，如果存在着终端对象，那么它是那个最大的对象。在集合范畴中，终端对象是一个单例。我们已经讨论过单例，它们相当于 C++ 中的 void 类型，也相当于 Haskell 中的 unit 类型 ()。单例就是只有一个值的类型，在 C++ 中是隐式的，在 Haskell 中是显式的。已知，有且仅有一个纯函数，从任意类型到unit类型 unit :: a -> ()。因此，对于单例而言，终端对象的所有条件都是能够满足的。

注意，以上例子中，唯一性是非常重要的，因为有些集合（实际上是除了空集之外的所有集合）会有来自其它集合的态射。例如，有这样一个结果为bool类型的函数/谓词，yes :: a -> bool，但是bool不是一个终结对象，因为至少还存在另一个no :: a -> bool。坚持唯一性能够得到足够的精度，可以将终端对象的定义紧缩为一种类型。

Duality - 对偶

注意到初始对象和终结对象是对称的，二者之间唯一的区别的是态射的方向。事实上，对于任意范畴C，总能定义一个相反范畴 C' $C^{op}$，只需要将C中的箭头反转一下，然后重新定义一下态射的复合方式，相反的范畴能自然满足所有的范畴法则。例如，在C中，f :: a -> b，g :: b -> c，h :: a -> c = g ∘ f，那么逆向为f' :: b -> a，g' :: c -> b，h' :: c -> a = f' ∘ g'。恒等箭头保持不变（或者说反转后跟原本一样）。

对偶是范畴的一个非常重要的性质。提出的每一种构造，都有其对偶的构造；证明的每一种定义，都能免费获得一个“对偶”版。相反的范畴中的概念通常以“余”(“co”)开头，因此有了积/product和余积/coproduct，单子/monad和余单子/comonad，锥/cones和余锥/cocones等。不存在什么余余单子/cocomonad，因为反转两次之后又会变成原样。

一个范畴中的终端对象，在其相反范畴中就是初始对象。

Isomorphisms - 同构

定义相等是很难的，不管是从程序的角度来定义两个对象相等，还是从数学上定义两个东西相等。数学家也描述不了相等的意义，所以定义了很多种侧重不同视角的相等：命题相等、内涵相等、外延相等，还有拓扑类型理论中的路径相等之类。于是出现了一个弱化的概念-同构/isomorphism

直觉上，同构对象看上去是一样的，它们有着相同的形状。这意味着每个对象的每个部分与另一对象的某个部分形成一对一的映射，我们的“仪器”检测出它们是彼此的拷贝。在数学上，这意味着存在一个从a到b的映射，也存在一个从b到a的映射，这两个映射是互逆的。在范畴论中，我们用态射取代了映射。一个同构/isomorphism是一个可逆的态射/morphism；或者一对互逆的态射/morphism。

可以通过复合与恒等来理解互逆。若态射f和态射g的复合结果是恒等态射，那么g是f的逆。这体现为一下两方程，因为两态射存在两种复合形式

f :: a -> b
g :: b -> a

g . f = ida
f . g = idb

前面提到，初始/终结对象在同构意义下具有唯一性，意思就是两个初始/终结对象是同构的。考虑上面代码展示的范畴，复合g . f必定是个从a到a的态射。但是a是个初始，所以只能有一个从a到a的态射。由于是在一个范畴中，所以知道这个唯一的从a到a的态射就是恒等态射。因此，g . f等于恒等态射；同理 f . g也是恒等态射。这就证明了f和g是互逆的，因此两个初始对象就是同构的。

注意，上述证明中，我们使用的是从初始对象到它本身的态射的唯一性。也需要f和g也是唯一的，因为初始对象不仅在同构意义下具有唯一性，而且这个同构是唯一的。理论上，两个对象之间可能存在不止一种同构关系。这种“在同构意义下具有唯一性，且这个同构是唯一的”是所有泛构造的一个重要性质

Product - 积

还有一个泛构造，叫做积/Product。从积到每个成分，存在两个投影。在Haskell中，这两个函数被称为fst和snd，它们分别从元组/序对中获取第一成员和第二成员，fst :: (a, b) -> a和snd :: (a, b) -> b。

借助这些有限的前提，我们尝试定义集合范畴中对象和态射的模式，这种模式可以引导我们去构造两个集合a与b的积。这个模式由对象c和两个态射p和q构成，p与q将c分别连想a和b，p :: c -> a和q :: c -> b。所有符合这个模式的c都认为是候选积，这样的c可能有很多。

举个例子，从Haskell类型中选择Int Bool，让它们相乘，并将 Int Bool作为候选积。假设 Int是候选积，Int 能够被认为是 Int 与 Bool 相乘的候选积吗？是的，它能，因为它具有以下投影：p :: Int -> Int = \x -> x q :: Int -> Bool = _ -> True，它符合候选积的条件。

还有一个(Int, Int, Bool)的三元组，它也是个合法的候选积，因为存在p :: (Int, Int, Bool) -> Int = (x, _, _) -> x q :: (Int, Int, Bool) -> Bool = (_, _, b) -> b。注意到，第一个候选积太小了，它只覆盖了积的Int维度，第二个太大了，存在一个重复的Int维度。

我们还没有探索这个泛构造的其它部分：等级划分。我们希望比较这种模式的两个实例，也就是说对于候选积c与c’，想要进行一些比较，以便做出c比c’更好的结论。如果有个c’到c的态射m，虽然可以基于这个态射认为 c 比 c’ 更好，但是这样还是太弱了。我们还希望c的p和q比c’的p’和q’更好，这意味着可以通过态射m从p和q分别构造出p’和q’ p' :: c' -> a = p . m q' :: c' -> b = q . m。从某个角度看，有点像是m是一个公因子的感觉。

基于前面建立的直觉，现在看一下(Int, Bool)及其fst snd为何比之前我们给出的两个候选积更好

对于第一个候选积，m :: Int -> (Int, Bool) = x -> (x, True)，这个候选积的两个投影p和q可重构为p x = fst (m x) = x q = snd (m x) = True

对于第二个候选积，m :: (Int, Int, Bool) = (x, _, b) -> (x, b)

现在给出理由，为何说(Int, Bool)比前两个候选积更好，先尝试找一个m’尝试构造出p和q

对第一个例子 fst = p . m' snd = q . m' 已知q总是返回True的，但是元组自己是可以有False值的，那么构造的这个 snd 是不对的，无法构造 snd

对第二个例子，能够在 p 或 q 运行后保留足够的信息，但是对于 fst 与 snd 而言，它们存在着多种因式化方式，因为 p 与 q 会忽略三元组的第 2 个元素，这就意味着我们的 m’ 可以在第 2 个元素的位置放任意东西，例如：m' (x, b) = (x, x, b) 或者 m' (x, b) = (x, 42, b) 等。

总之，对任何给定的类型c和投影p q，存在着唯一的一个 m 可将 c 映射成笛卡尔积 (a, b)。m :: c -> (a, b) = x -> (p x, q x)。这样就决定了笛卡尔积 (a, b) 是最好的候选积，这意味着这种泛构造对于集合范畴是有效的，它涵盖了任意两个集合的积。

现在，我们忘记集合，使用相同的泛构造来定义任意范畴中两个对象的积。这样的积并非总是存在，但是一旦它存在，它就在同构意义下具有唯一性，而且这个同构是唯一的。

A product of two objects 𝑎 and 𝑏 is the object 𝑐 equipped with two projections such that for any other object 𝑐′ equipped with two projections there is a unique morphism 𝑚 from 𝑐′to 𝑐 that factorizes those projections.

对象 a 与对象 b 的积是伴随两个投影的对象 c。对于任何其他伴随两个投影的对象 c’ 而言，存在唯一的从 c’ 到 c 的态射，这个态射可以因式化这两个投影。

一个高阶函数能够生成因子 m，这个高阶函数有时被称为因子生成器。对于本文的示例中，它是这样的函数：

1
2

factorizer :: (c -> a) -> (c -> b) -> (c -> (a, b))
factorizer p q = \x -> (p x, q x)

Coproduct - 余积

同范畴论中每个构造一样，积有一个对偶，叫做余积。将积的范式中的箭头反转，就可以得到一个对象 c，它伴随两个入射 i 与 j——从 a 到 c 的态射与从 b 到 c 的态射。i :: a -> c j :: b -> c。等级也反转了，c比c’更好的条件是：存在从c到c’的态射m，可以“因式化”入射。i' = m . i j' = m . j

这个“最好”的对象就是，具有唯一的态射从其本身指向其它对象，这种对象就叫余积，并且如果它存在，那么它就在同构意义下具有唯一性，而且这个同构是唯一的。

A coproduct of two objects 𝑎 and 𝑏 is the object 𝑐 equipped with two injections such that for any other object 𝑐′ equipped with two injections there is a unique morphism 𝑚 from 𝑐 to 𝑐′ that factorizes those injections.

两个对象 a 与 b 的余积是对象 c，当且仅当 c 伴随着两个入射，而且任何一个其他的伴随两个入射的对象 c’，只存在唯一的从 c 到 c’ 的态射 m，并且 m 可以因式化这些入射。

在集合的范畴中，余积就是两个集合的不相交求并运算。集合 a 与集合 b 的不相交求并结果中的一个元素，要么是 a 中的元素，要么是 b 中的元素。

Haskell中内置的积是用元组实现，内置的余积是Either数据类型实现Either a b = Left a | Right b。

程序中的余积可以这样定义data Contact = PhoneNum Int | EmailAddr String / type Contact = PhoneNum Int | EmailAddr String

正如我们刚才所定义的积的因式生成器一样，我们也可以为余积定义一个。对于给定的候选余积 c 以及两个候选入射 i 与 j，为 Either 生成因式函数的的因式生成器可定义为：

1
2
3

factorizer :: (a -> c) -> (b -> c) -> Either a b -> c
factorizer i j (Left a)  = i a
factorizer i j (Right b) = j b

Asymmetry - 非对称

集合的范畴不会随箭头的反转而出现对称性。

Notice that while the empty set has a unique morphism to any set (the absurd function),it has no morphisms coming back. The singleton set has a unique morphism coming to it from any set, but it also has out going morphisms to every set (except for the empty one).

空集可以向任意一个集合发出唯一的态射（absurd 函数），但是它没有其他集合发来的态射。单例集合拥有任意集合发来的唯一的态射，但它也能向任一集合（除了空集）发出态射。由终端对象发出的态射在拮取其他集合中的元素方面扮演了重要的角色（空集没有元素，因此没什么东西可拮取的）。

函数是建立在它的定义域（Domain）上的（在编程中，称之为全函数），它不必覆盖余定义域（Codomain，译注：可能叫陪域更正式一些）。我们已经看到了一些极端的例子（实际上，所有定义域是空集的函数都是极端的）：定义域是单例的函数，意味着它只在余定义域上选择了一个元素。若定义域的尺度远小于余域的尺度，我们通常认为这样的函数是将定义域嵌入余定义域中了。例如，我们可以认为，定义域是单例的函数，它将单例嵌入到了余定义域中。我将这样的函数称为嵌入函数，但是数学家给从相反的角度进行命名：覆盖了余定义域的函数称为满射（Surjective）函数或映成（Onto）函数。

函数的非对称性也表现为，函数可以将定义域中的许多元素映射为余定义域上的一个元素，也就是说函数坍缩了。一个极端的例子是函数使整个集合坍缩为一个单例，unit 函数干的就是这事。这种坍缩只能通过函数的复合进行混成。两个坍缩函数的复合，其坍缩能力要强过二者单兵作战。数学家为非坍缩函数取了个名字：内射（Injective）或一对一（One-to-one）映射。

当然，有许多函数即不是嵌入的，也不是坍缩的。它们被称为双射（Bijection）函数，它们是完全对称的，因为它们是可逆的。在集合范畴中，同构就是双射的。

1.4 Kleisli Categories - Kleisli范畴

Wed, 18 Mar 2020 00:00:00 +0800

Kleisli Categories - Kleisli范畴

可以基于范畴论对副作用/非纯函数进行建模。

考虑一个跟踪程序，在命令式编程语言中，经常是以修改某些全局状态来实现，例如

string logger;
bool negate(bool b) {
    logger += "Not so!";
    return !b;
}

通过修改全局变量logger，实现对于程序运行情况的跟踪。但是现代编程语言中，一般尽可能不去修改全局状态，尤其是并发编程这一复杂情景。我们可以考虑重构以上方法，使之变成一个纯函数

1
2
3

pair<bool, string> negate(bool b, string logger) { 
    return make_pair(!b, logger + "Not so! ");
}

现在这是一个纯函数了，它没有副作用了，传入相同的参数即可得到完全相同的结果。但若是关心跟踪的详细情况，考虑到累积性，不得不收集这个函数运行情况的全部历史，每调用它一次，就产生一个结果。作为一个库函数，这是特别难用的。调用者可以随意丢掉返回值当中的字符串（若是他不关心跟踪的具体情况），可是还必须传入一个字符串参数，这用起来很不方便了。

考虑消除这些东西，将我们关心的东西分离出来。本例中，negate主要任务是将布尔值转换成另一个，至于记录运行情况，那是次要的。尽管日志信息对于这个函数而言是特定的，但是将信息汇集到一个连续的日志这一任务是可单独考虑的。我们依然想让这个函数生成日志信息，但是可以减轻一下它的负担。现在有一个折中的解决方案

1
2
3

pair<bool, string> negate(bool b) {
     return make_pair(!b, "Not so! ");
}

这样，日志信息的汇集工作就被转移至函数的当前调用之后且在下一次被调用之前的时机。

现在给出一个更现实的示例，现有一个小写转大写（字符串到字符串）和字符串分割成单词（字符串到字符串向量）的函数

string toUpper(string s) {
    string result;
    int (*toupperp)(int) = &toupper; // toupper is overloaded
    transform(begin(s), end(s), back_inserter(result), toupperp);
    return result;
}

vector<string> toWords(string s) {
    return words(s);
}

vector<string> words(string s) {
    vector<string> result{""};
    for (auto i = begin(s); i != end(s); ++i)
    {
        if (isspace(*i))
            result.push_back("");
        else
            result.back() += *i;
    }
    return result;
}

现在我们想将函数toUpper和toWords修改一下，让它们返回值肩负日志信息。

通过“修饰”两个函数的返回值，采用更泛化一些的方式，定义一个Writer模板先

1
2

template<class A>
using Writer = pair<A, string>;

然后修改两个函数

Writer<string> toUpper(string s) {
    string result;
    int (*toupperp)(int) = &toupper;
    transform(begin(s), end(s), back_inserter(result), toupperp);
    return make_pair(result, "toUpper ");
}

Writer<vector<string>> toWords(string s) {
    return make_pair(words(s), "toWords ");
}

现在想将这两函数复合，得到一个先将字符串转大写，然后将之分割成单词的函数，此外也应当记下执行跟踪信息也不能丢失，所以这样实现

Writer<vector<string>> process(string s) {
    auto p1 = toUpper(s);
    auto p2 = toWords(p1.first);
    return make_pair(p2.first, p1.second + p2.second);
}

现在已经完成了目标：日志的汇集不再由单个的函数来操心。这些函数各自产生各自的消息，然后在外部汇总为一个更大的日志。

整个程序都这么写的话，那么会有特别多重复代码，解决方式便是进行抽象。但这不是普通的抽象，是在对函数的复合本身进行抽象。由于复合是范畴论的本质，因此在动手之前，我们先从范畴的角度分析一下这个问题。

The Writer Category

对那几个函数的返回类型进行“修饰”，其意图是为了让返回类型肩负着一些有用的附加功能。这一策略相当有用，下面将给出更多的示例。起点还是常规的的类型与函数的范畴。我们将类型作为对象，与以前有所不同的是，现在将装帧过的函数作为态射了。

假设我们要修饰从int到bool的isEven函数，然后将修饰后的函数作为态射，尽管修饰后的函数返回一个元组/序对，但我们依然认为它是个从int到bool的态射。

1
2
3

pair<bool, string> isEven(int n) {
    return make_pair(n % 2 == 0, "isEven ");
}

按照范畴中态射的复合法则，应当可以与我们之前定义的negate进行复合。

1
2
3

pair<bool, string> negate(bool b) {
     return make_pair(!b, "Not so! ");
}

显然无法通过常规方式进行态射复合，因为输入输出不匹配，我们可以这样实现

pair<bool, string> isOdd(int n) {
    pair<bool, string> p1 = isEven(n);
    pair<bool, string> p2 = negate(p1.first);
    return make_pair(p2.first, p1.second + p2.second);
}

对这种新范畴中态射复合的法则进行总结：

执行与第一个态射所对应的装帧函数，得到第一个序对；
从第一个序对中取出第一个元素，将这个元素传给与第二态射对应的装帧函数，得到第二个序对；
将两个序对中的第二个元素（字符串）连接起来；
将计算结果与连接好的字符串捆绑起来作为序对返回。

若想将这种复合抽象为 C++ 中的高阶函数，必须根据与我们的范畴中的三个对象相对应的三种类型构造一个参数化模板。这个函数应该接受能遵守上述复合法则的两个可复合的装帧函数，返回第三个装帧函数：

template<class A, class B, class C>
function<Writer<C>(A)> compose(function<Writer<B>(A)> m1, 
                               function<Writer<C>(B)> m2) {

    return [m1, m2](A x) {
        auto p1 = m1(x);
        auto p2 = m2(p1.first);
        return make_pair(p2.first, p1.second + p2.second);
    };
}

使用这个函数去复合之前的toUpper和toWords

1
2
3

Writer<vector<string>> process(string s) {
    return compose<string, string, vector<string>>(toUpper, toWords)(s);
}

对于支持 C++14 的编译器，它支持具有返回类型推导功能的泛型匿名函数

auto const compose = [](auto m1, auto m2) {
    return [m1, m2](auto x) {
        auto p1 = m1(x);
        auto p2 = m2(p1.first);
        return make_pair(p2.first, p1.second + p2.second);
    };
};

用这个新的compose可以简化process

1
2
3

Writer<vector<string>> process(string s){
   return compose(toUpper, toWords)(s);
}

在这个新范畴里，我们已经定义了态射复合，但是还没有定义恒等态射。这些恒等态射肯定不是常规意义上的恒等态射！它们必须是一个从（装帧之前的）类型 A 到（装帧之后的）类型 A 的的态射，即：

`1`	`Writer<A> identity(A);`

对于复合而言，它们的行为必须像 unit。若要符合上面的态射复合的定义，那么这些恒等态射不应该修改传给它的参数，并且对于日志它们仅贡献一个空的字符串：

template<class A>
Writer<A> identity(A x) {
    return make_pair(x, "");
}

我们所定义的这个范畴是一个合法的范畴。特别是，我们所定义的态射的复合是遵守结合律的，虽然这无关紧要。如果你只关心每个序对的第一个元素，这种复合就是常规的函数复合。第二个元素会被连接起来，而字符串的连接也是遵守结合律的。

这种构造适用于任何幺半群，而不仅仅是字符串幺半群。我们可以在 compose 中使用 mappend，在 identify 中使用 mempty。

Writer in Haskell

同样的事情，在Haskell中做起来简单一些，而且也能得到编译器的很多辅助

首先定义Writer

`1`	`type Writer a = (a, String)`

声明复合操作符如下所示

`1`	`(>=>) :: (a -> Writer b) -> (b -> Writer c) -> (a -> Writer c)`

其定义如下所示

m1 >=> m2 = \x ->
    let (y, s1) = m1 x
        (z, s2) = m2 y
    in (z, s1 ++ s2)

let ( >=> ) m1 m2 = fun x ->
    let (y, s1) = m1 x
    let (z, s2) = m2 y
    (z, s1 + s2)

恒等态射

1
2

return :: a -> Writer a
return x = (x, "")

上面几个例子，用Haskell演示其实现如下所示

toUpper :: String -> Writer String
toWords :: String -> Writer [String]

process = toUpper >=> toWords

Kleisli Categories

Link to Blog

<译> Kleisli 范畴

以上示例就是在演示Kleisli范畴，这是个建立在单子（Monad）之上的范畴，此处不讨论单子，只是在演示单子能干什么。在编程中，可以这样理解，在Kleisli范畴，从A到B的态射是从A到B的派生（“装饰”后的B）的函数。每个Kleisli范畴都定义了自己的态射复合运算以及支持这种复合运算的恒等态射。（“装饰”/“装帧”是个不严谨的说法，它相当于范畴论中的自函子 endofunctor）。

以上示例中演示的是Writer单子（Writer Monad），专门用于跟踪函数执行情况。它也是纯计算过程中嵌入副作用这种一般性机制一个范例。

可以将编程语言的类型与函数构建为集合的范畴（忽略底的存在）。在本文中，我们将这个模型扩展为一个稍微有些不同的范畴，其态射是经过装帧的函数，态射的复合所做的工作不仅仅是将一个函数的输出作为另一个函数的输入，它做了更多的事。这样，我们就多了一个可以摆弄的自由度：这种复合本身。对于传统上使用命令式语言并且通过副作用实现的程序，这种复合运算能够给出简单的指称语义。

Challenge

type 'a CanBeFailed  = Success of 'a | Failed

let idc x = Success x
// >=> : ('a -> CanBeFailed<'b>) -> ('b -> CanBeFailed<'c>) -> ('a -> CanBeFailed<'c>)
let ( >=> ) f1 f2 = fun x ->
    match f1 x with
    | Failed -> Failed 
    | Success y ->
        match f2 y with
        | Failed -> Failed
        | Success z -> Success z

let safeReciprocal x =
    match x with
    | 0.0 -> Failed
    | _ -> Success (1.0/x)

let safeRoot x = 
    if x >= 0.0 then Success (sqrt x) else Failed

let safeRootReciprocal = safeRoot >=> safeReciprocal

1.3 Categories Great and Small - 范畴可大可小

Tue, 17 Mar 2020 00:00:00 +0800

Categories Great and Small - 范畴可大可小

Categories Great and Small

<译> 范畴，可大可小

No Objects - 无对象

The most trivial category is one with zero objects and, consequently, zero morphisms

存在这样一个零对象零态射的范畴。它在包含所有范畴的范畴中。这是个合理的概念，既然空集合是合理的，为何不会有空范畴呢？

Simple Graphs - 简单画图

可以仅通过箭头连接对象来构造出范畴。

这样想象，基于任何一个有向图，仅通过添加更多箭头即可让它变成一个范畴。首先给每个节点添加一个恒等箭头（恒等态射 identity arrow），然后为那些“可复合”箭头添加一个新箭头作为它俩的复合，注意添加新箭头之后可能出现新的“可复合”箭头。

重新审视这个过程，这便是在构造一个范畴。

这种由一个给定图构造的范畴称为“自由范畴”。

Orders - 序

考虑这样的范畴：它的态射表示的是两对象的关系，例如小于等于关系。我们考察一下这实质上是不是个范畴。问题1：有没有恒等态射？每个对象都小于等于它自己，OK！问题2：有没有复合关系？若a小于等于b，b小于等于c，则a小于等于c，OK！问题3：复合满足结合律吗？满足结合律！伴随这种关系的集合，叫做前序集（preorder），前序集是范畴

可以加强这一关系，加一个附加条件，若有a小于等于b及b小于等于a可得a必定与b相等，这种叫做偏序集（partial order）

若集合中任意两对象之间有这个偏序关系，那么得到了一个全序集（linear order/total order）

把这些集合描绘为范畴，对于前序集而言，两对象之间最多只有一个态射，这种范畴也叫做瘦范畴(thin category)

范畴C中，从对象a到对象b的态射的集合称为Hom-集(hom-set)，写作C(a,b) / $C(a,b)$ / $Hom_C(a,b)$。所以每个前序集的Hom-集要么是空的要么是单例的，（包括Hom-集C(a,a)，在任意前序集中，必定只包含一个从a到a的恒等态射，此Hom-集必定是单例的）。前序集中可能包含环，但是偏序集中不能包含环。

理解清楚前序集、偏序集、全序集很重要，因为排序需要它们。常见的排序算法，例如快排、冒泡、归并等等，只能在全序集上正确运行；偏序集可以用拓扑排序算法来处理。

Monoid as Set - 幺半群作为集合

Monoid is an embarrassingly simple but amazingly powerful concept. It’s the concept behind basic arithmetics: Both addition and multiplication form a monoid.

幺半群（Monoid）是一个相当简单但是功能强大的概念。它是基本算数幕后的概念：只要有加法或乘法运算就可以形成幺半群。编程中的幺半群无所不在，表现为字符串、列表、可以“折叠”的数据结构、并发编程中的future、函数式响应编程中的事件等等。

a monoid is defined as a set with a binary operation.

幺半群被定义为“一个伴有二元运算的集合”。这个二元运算必须满足结合律，集合中包含着一个特殊的元素，对于这个二元运算，该元素的行为像一个返回其自身的 unit。

例如：包含0的自然数伴随加法运算，这就形成了一个幺半群。结合律是指(a+b)+c=a+(b+c)；特殊的元素是0，0+a=a+0。（自然数加法满足交换律，但交换律并非幺半群定义所需。例如字符串有加法/连接运算，该运算不满足交换律，有特殊的“中立”元素空字符串，这依然是一个幺半群）

在Haskell中可以为幺半群定义一个类型类（type class），该类型包含一个中立元素mempty和二元运算mappend

1
2
3

class Monoid m where
    mempty :: m
    mappend :: m -> m -> m      -- currying form

注意，在 Haskell 中，无法解释 mempty 与 mappend 的幺半群性质，也就是说 mempty 是个什么样的中立者，mappend 符合怎样的结合律。因为这是程序猿的责任，毕竟 Haskell 不能未卜先知。

Haskell classes are not as intrusive as C++ classes. When you’re defining a new type, you don’t have to specify its class upfront. You are free to procrastinate and declare a given type to be an instance of some class much later.

Haskell中定义一个新的类型时，不需要声明它所属的类。可以之后再声明一个给定的类型是某个类的实例。

例如可以将String声明为一个幺半群，并为之提供mempty和mappend的实现。

1
2
3

instance Monoid String where
    mempty = ""
    mappend = (++)

Haskell中，任何中缀运算符，用括号围住，就转化成了一个接受两个参数的函数。（F#中也是如此）

注：Haskell中允许函数相等。但是从概念上讲，mappend = (++)（函数相等）与mappend s1 s2 = (++) s1 s2（相同参数产生的值相等）是不同的。前者是Hask范畴（若忽略掉表示无休止计算的底类型，是Set）中的态射相等。这样的方程更简洁，而且常被泛化到其它范畴。后者被称为外延相等（extensional equality），说的是对于任意两个输入字符串，mappend和(++)值相等。由于函数的参数值有时也被称为点（情同：f在点x处的值），外延相等也被称为point-wise相等，未指定参数的函数相等，称为point-free相等。

幺半群作为范畴

在范畴论中，我们尝试的事情是放弃集合和它们的元素，转而讨论对象和态射。转换一下视角，从范畴的角度来看作用与集合的移动或转移二元运算。

例如，有一个将自然数加5的运算，它将0映射成5，将1映射成6等，这样是自然数集上定义了一个函数，此时我们有了一个函数和一个集合。通常，对任意数字n，都有个加n的函数，“n的adder”。这些“adder”如何复合呢？加5的函数和加7的函数复合起来，可以得到加12的函数。“adder”的复合等同与加法规则。那么我们可以用函数复合来代替加法运算。当然，也有一个面向中立元素0的“adder”，这加0不改变任何东西，它是自然数集上的恒等函数。即使不以传统的加法规则作为参照，照样能给出 adder 们的复合规则。注意，adder 们的复合是符合结合律的，因为函数的复合是符合结合律的，而且我们也有个加 0 的函数作为恒等函数。

现在，忘掉我们正在处理自然数集，将它视为一个对象，它伴随这一堆态射（这些“adder”）。幺半群是一个单对象范畴。每个幺半群可以表述为有一个态射集的单对象范畴，态射集中的态射都遵守复合规则。

字符串连接是个有趣的例子，因为我们可以选择定义左连接还是右连接。这两个态射是彼此镜像的。

You might ask the question whether every categorical monoid — a one-object category — defines a unique set-with-binary-operator monoid

是否每个范畴化的幺半群都会定义一个唯一的的伴随二元运算的幺半群？事实上，我们总能从单对象范畴中抽出一个集合，这个集合是态射的集合（如前面的中的adder）。换句话说，对于只含单个对象m的范畴M，我们有一个Hom-集 M(m,m)，很容易在这个集合中定义一个二元运算：两元素相乘相当于两态射的复合。从M(m,m)中拿出两个元素f和g，它们的乘积相当与f∘g。复合总是存在的，因为这些态射的源对象和目标对象是同一个。这种乘法运算也遵循范畴论中的结合律。此外恒等态射也必定存在。因此，我们总是从幺半群范畴中复原出幺半群集合。无论从那个角度看，它们是同一个东西。

对于数学家的挑剔而言，有点小 bug：态射不必形成集合。在范畴的世界里，有比集合更大的东西。一个范畴，其中任意两个对象之间的态射们形成一个集合，这样的范畴是局部小的。不过，因为承诺不要太数学，所以我会忽略这些细枝末节，在讲 Haskell 的『记录』语法时，再谈论它们。

范畴论中大量的有趣现象都来自于：hom-集里的元素可被视为遵守复合法则的态射，也可被视为集合中的点。在此，M 中的态射的复合就会变成集合 M(m,m) 中的幺半群式的乘法运算。

1.2 Types and Functions - 类型与函数

Wed, 11 Mar 2020 00:00:00 +0800

Types and Functions - 类型与函数

Link to Blog

<译> 类型与函数

Who Need Types?

类型检查器可以基于类型信息进行对程序进行更深入的校验。

Types Are About Composability

Category theory is about composing arrows. But not any two arrows can be composed. The target object of one arrow must be the same as the source object of the next arrow.

编程实践中，两函数的输入和输出类型匹配，它们才能复合成功。当然，一般编程语言也提供了绕过类型检查的后门，例如强制类型转换、一些unsafe的库等。此外，现代编程语言的编译器也具备强大的类型推断能力，这样编写代码时可以省去一部分类型声明。

What Are Types?

The simplest intuition for types is that they are sets of values.

Sets can be finite or infinite.

类型可以认为是一些值的集合，这个集合中的元素可以是有限的，也可能是无穷的。考虑Bool类型，这是个仅有两个元素True``False的集合；而String类型，这就是个无限元素的集合。

There are problems with polymorphic functions that involve circular definitions, and with the fact that you can’t have a set of all sets.

多态函数存在循环定义问题，基于这一事实，无法获得一个所有集合的集合。

集合的范畴名字就叫做“Set”，在“Set”中，对象是集合，态射（箭头）是函数。

理想世界中，我们可以将Haskell类型视为集合，将函数视为集合间的数学函数。但这有一个问题，数学函数不执行任何代码，它只知道答案。一个Haskell函数必须执行计算然后得到答案。若是计算可以在有限步骤内完成，那么这没问题；但这个计算若是包含递归，可能永远不会结束。由于函数能否在有限步得出结果的不可预知性，所以我们也无法禁止这些无休止计算的函数。

Extend every type by one more special value called bottom and denoted by _|_. This “value” corresponds to a non-terminating computation.

引入了一个特殊的值，叫做“底”，Haskell中记作_|_，它是所有类型的子类型，它用于表示无休止计算。例如声明一个函数返回Bool，可能得到的结果是True``False``_|_，最后的值表示计算永远不会终结。

可以将这个“底”接受为类型系统的一部分，那么可以所有运行时错误视作“底”，甚至显式返回一个“底”，一般用于尚未实现。如声明 f: Bool -> Bool，那么f x = undefined 甚至 f = undefined(“底”也是Bool->Bool的子类型)

Functions that may return bottom are called partial, as opposed to total functions,which return valid results for every possible argument.

可能会返回“底”的函数是偏函数，与全函数相对，后者对于每个可能参数都会返回一个有效结果。

由于“底”的存在，因此Haskell类型与函数的范畴称为“Hask”，而不是“Set”。

Why Do We Need a Mathematical Model?

程序员一般很熟悉语言的语法。这里关注的是语言的语义，这一点很难描述。

有些形式化工具可描述语义，但是特别复杂，有一个工具叫做操作语义（operational semantic），它描述的是程序的执行机制。它定义了形式化理想化的解释器。工业级语言的语义，类似 C++，用的是非正式的操作语义，称之为『抽象机器』。使用操作语义存在的问题是要难以证明程序的正确性。要展现一个程序的性质，你只能在一个理想化的解释器中去『运行』它。

还有一种选择，它叫指称语义（Denotational semantic），是基于数学的。在指称语义中，每个编程结构都会被给出数学解释。使用它，如果你想证明程序的正确性，只需要证明一个数学定理。

Haskell 是符合指称语义的语言，考虑用 Haskell 定义一个阶乘函数：

`1`	`fact n = product [1..n]`

表达式 [1..n] 是一个从 1 到 n 的整型数列表。product 函数可以将列表中的所有元素相乘。这跟数学课本里的阶乘几乎别无二致。对比C语言的实现

int fact(int n) {
    int result = 1;
    for(int i = 2; i <= n; i++) {
        result *= i;
    }
    return result;
}

阶乘函数本身就有着明确的数学定义，所以以上代码显得差异巨大。

但是，如果这么问：从键盘读取字符或者通过网络发送数据包，它们有数学模型么？在非常漫长的时间里，此类问题一直都是很尴尬的问题，答案只能是弯弯绕的那种。似乎指称语义不能极好的应用于一些重要的任务，而编程本来就是围绕这些任务而生。操作语义很容易胜任这些任务。直到范畴论的出现才找到摆脱这种尴尬境地的突破口。Eugenio Moggi 发现可通过单子完成此类任务，这一发现不仅扭转了乾坤，使得指称语义大放异彩，并使得纯函数式程序变得更为有用，也使得传统的编程范式绽放出新的光芒。单子，我们以后在发展更多的范畴论工具时再予以探讨。

Pure and Dirty Functions

在C++或者其他命令式编程语言中的函数，和数学上的函数，不是同一个东西。数学上的韩式只是值到值的映射。

可以用编程语言实现一个数学函数。很容易就能实现一个平方函数，接受某个数，返回其平方，别的什么也没变。但是，若这个函数还有其它副作用，那这个平方函数跟数学上的平方函数就不是一回事了。

编程语言中，某个函数对于同一个输入，总是得到同一个输出，且没有其他副作用，那么就是纯函数。在纯函数式编程语言Haskell中，所有函数都是纯的。在其他编程语言中，我们可以要求自己的代码尽可能纯，用以获取更大的益处。

Examples of Types

基于类型是集合，可以考虑更生僻的类型。例如，空集这种类型是什么？在Haskell中，空集是Void，这跟C++中的void完全不是一回事。Haskell中的Void是一个完全不存储任何值的类型。我们可以定义一个接受Void的函数，但是永远无法调用它，由于调用这个函数需要提供一个Void类型的值，但这种类型的值不存在；至于返回值，可以是任何类型，反正这函数永远不会运行。Haskell中其命名为absurd:: Void -> a，这是个多态返回类型的函数。这种类型与函数，在逻辑学上有更深入的解释，它们被称为 Curry-Howard 自同态。Void 类型表示谎言，absurd 函数的类型相当于『由谎言可以推出任何结论』，也就是逻辑学中所谓的『爆炸原理』。

还一个实例相当于单例集合，这是只有一个值的类型，它实际上就是C++中的void（有些语言中称unit）。考虑哪些输入是void和返回是void的函数，输入是void的函数总能被调用，若它是纯函数，那么总能返回相同的结果。如int f44() { return 44; }。已知一个函数如果不接受任何值，那么永远不会被调用。从概念上说，这个函数接受了一个空值（很多语言中用()表示）。

注意，每个 unit 函数都等同于从目标类型中选取一个值的函数。实际上，可以将f44作为数字44的另一种表示方法。这也演示了如何通过用函数调用来代替显式拿出集合中的元素。从unit到A的函数一对一关联了集合A中的元素。

以void/unit作为返回类型的函数，在命令式编程世界中，这种函数是纯副作用的函数，跟数学函数完全不是一回事。但是在纯函数式世界中，这种函数不做任何事情，只是把接受的参数丢掉。从数学上讲，这种A -> unit的函数是将集合A中的所有元素映射成单例集合中的值。

下一个例子是二元集合，在C++中，这个集合被称为bool，在Haskell中，被称为Bool，区别是C++中这是内置的，在Haskell中可以自行定义data Bool = True | False，这个定义这样理解：Bool要么是True，要么是False。理论上，C++中也可以用枚举来定义（C++中enum类型本质为整型）。

输出Bool的函数称为“谓词”（predicate）。例如isDight这种

Challenges


let memoize f = 
    let mem = new Dictionary<_, _>()
    fun x ->
        if mem.ContainsKey(x) then mem.Item(x)
        else 
            let y = f x
            mem.Add(x, y)
            y

not :: Bool -> Bool
not True = False
not False = True

id :: Bool -> Bool
id a = a

false :: Bool -> Bool
false _ = False

true :: Bool -> Bool
true _ = True

absurd :: Void -> ()
absurd :: Void -> Bool

id :: () -> ()
true :: () -> Bool
false :: () -> Bool

discard :: Bool -> ()

id :: Bool -> Bool
not :: Bool -> Bool
true :: Bool -> Bool
false :: Bool -> Bool

1.1 Category: The Essence of Composition - 范畴：复合的本质

Tue, 10 Mar 2020 00:00:00 +0800

Category: The Essence of Composition - 范畴：复合的本质

Link to Blog

<译> 范畴：复合的本质

A category consists of objects and arrows that go between them.

“范畴”是个很简单的概念，一个“范畴”由“对象”和对象间的“箭头”组成。范畴的本质是“复合”。“箭头”是可“复合”的。若已有从对象A到B的箭头和从对象B到C的箭头，那么必然存在一个从A到C的箭头，即前两者的“复合”。

这里的“对象”并非是面向对象编程世界里的“对象”

“箭头”学名叫做“态射”。

Arrows as Functions - 箭头作为函数

Arrows also called morphisms, as functions.

可以把函数想象成箭头。假定有一函数f接受一个A类型的值，返回一个B类型的值；此外还有函数g接受B类型的值返回C类型的值。把f的返回值传给g，这样就完成了复合。

比如Unix系统中的管道ls | grep xxx，就是把前者的值作为输入传到后面。

数学中，用g ∘ f来表示函数的复合（注意顺序，复合是从右向左发生的，λx.g(f(x))，可以读作“g after f”）。编程语言中有的直接提供了操作符，例如Haskell 中的.（g . f从右向左）；F#中的>> <<（f >> g g << f前者从左向右复合，后者从右向左）。有些语言没有直接操作符支持，可以动手写出函数体形如g(f(x))，借助x进行函数复合。

f :: A -> B
g :: B -> C

g . f :: A -> C

$g \circ f = \lambda x.g \lparen f \lparen x \rparen \rparen$

Properties of Composition - 复合的性质

复合是可结合的。（结合律）

Composition is associative.

`1`	`h ∘ g ∘ f = h ∘ (g ∘ f) = (h ∘ g) ∘ f`

$h \circ \lparen g \circ f \rparen$ = $\lparen h \circ g \rparen \circ f$ = $h \circ g \circ f$

f :: A -> B
g :: B -> C
h :: C -> D

-- equality is not defined for functions
h . (g . f) == (h . g) . f == h . g . f

任一对象A，都有一个箭头，它是符合的最小单位。这个箭头从对象出发又指向对象自身。（恒等态射）

这称为$id_A$（identity on A）。在数学定义里，现有f接受A返回B，那么$f \circ id_A = f$，$id_B \circ f = f$。

在编程语言中，可以这么实现T id(T x) { return x; }，当然这里的T一般是个泛型参数，也免得为每个对象都实现一个恒等态射了。

For every object A there is an arrow which is a unit of composition.

This arrow loops from the object to itself. The unit arrow for object A is called $\bold{id} _{A}$ (identity on $A$).

In math notation, if $f$ goes from $A$ to $B$, then $f \circ \bold{id} _A = f$ and $\bold{id} _B \circ f = f$

id :: a -> a
id x = x

f . id == f
id . f == f

A category consists of objects and arrows (morphisms). Arrows can be composed, and the composition is associative. Every object has an identity arrow that servers as unit under composition.

Composition is the Essence of Programming - 复合是编程的本质

Challenges

Implement the identity function

1
2

// there is an `id` in F#
let idm x = x

Implement the composition function

// right to left
let compose g f x = g(f(x))

// in F#, there is an `>>` , compose functions left to right
let compose f g x = g(f(x))

test composition function

let f (i: int): string = string i

compose idm f

compose f idm