单子只是内函子类别中的幺半群，有什么问题吗？

Question

下面这句话是谁先说的？

单子只是其中的一个幺半群 内函子的类别，是什么 有问题吗？

另一个不太重要的问题是，这是真的吗？如果是的话，您能否给出一个解释（希望没有太多 Haskell 经验的人能够理解）？

Answer 1

这个特殊的措辞是 James Iry 的，来自他非常有趣的编程语言的简短、不完整且大多错误的历史，其中他虚构地将其归因于 Philip Wadler。

原始引用来自 Saunders Mac Lane 的《工作数学家的范畴》，范畴论的基础文本之一。 这里是上下文，这可能是了解其确切含义的最佳位置。

不过，我还是会尝试一下。原句是这样的：

总而言之，X 中的单子只是 X 的内函子类别中的幺半群，其中乘积 × 被内函子的组合所取代，单位由恒等内函子设定。

X 这里是一个类别。 Endofunctor 是从一个类别到其自身的函子（就函数式程序员而言，通常是所有函子，因为他们大多只处理一个类别；类别类型 - 但我离题了）。但你可以想象另一个类别，即“X 上的endofunctors”类别。在这个范畴中，对象是内函子，态射是自然变换。

在这些内函子中，其中一些可能是单子。哪些是单子？正是那些在特定意义上幺半群。我不会详细说明从 monad 到 monoid 的精确映射（因为 Mac Lane 在这方面做得比我希望的要好得多），我只是将它们各自的定义并排放置并让您进行比较：

幺半群是...

• 一个集合, S
• 一个运算，• : S × S → S
• S 的一个元素>, e : 1 → S

...满足以下定律：

• (a • b) • c = a • (b • c) ，对于 S 中的所有 a、b 和 c
• e • a = a • e = a ，对于 S 中的所有 a，

单子是...

• 一个内函子，T : X → X （在 Haskell 中，带有 Functor 实例的 * -> * 类型构造函数）
• 自然变换，μ : T × T → T，其中 × 表示函子组合（μ 称为 join (Haskell 中)
• 自然转换，η : I → T，其中 I 是 X 上的恒等函子（η 是称为 return 在 Haskell 中）

...满足这些定律：

• μ ∘ Tμ = μ ∘ μT
• μ ∘ Tη = μ ∘ ηT = 1 （身份自然转换）

稍微眯一下眼睛，您可能会发现这两个定义都是相同的实例 抽象概念。

Answer 2

首先，我们将要使用的扩展和库：

{-# LANGUAGE RankNTypes, TypeOperators #-}

import Control.Monad (join)

其中，RankNTypes 是唯一对以下内容绝对重要的扩展和库。 我曾经写过一篇关于 RankNTypes 的解释人们似乎发现有用，所以我会参考一下。

引用 Tom Crockett 的出色回答，我们有：

单子是...

• 一个内函子，T : X -> X
• 自然变换，μ : T × T -> T，其中×表示函子组合
• 自然变换，η：I -> T，其中 I 是 X

上的恒等函子

...满足这些法律：

• μ(μ(T × T) × T)) = μ(T × μ(T × T))
• μ(η(T)) = T = μ(T(η))

我们如何将其转换为哈斯克尔代码？好吧，让我们从自然变换的概念开始：

-- | A natural transformations between two 'Functor' instances.  Law:
--
-- > fmap f . eta g == eta g . fmap f
--
-- Neat fact: the type system actually guarantees this law.
--
newtype f :-> g =
    Natural { eta :: forall x. f x -> g x }

f :->; 形式的类型。 g 类似于函数类型，但不要将其视为两个类型（类型为*）之间的函数 ，将其视为两个函子（每种* -> *）之间的态射。示例：

listToMaybe :: [] :-> Maybe
listToMaybe = Natural go
    where go [] = Nothing
          go (x:_) = Just x

maybeToList :: Maybe :-> []
maybeToList = Natural go
    where go Nothing = []
          go (Just x) = [x]

reverse' :: [] :-> []
reverse' = Natural reverse

基本上，在 Haskell 中，自然转换是从某种类型 f x 到另一种类型 g x 的函数，使得 x 类型变量“不可访问”给来电者。例如，sort :: Ord a => [一]-> [a] 无法进行自然转换，因为它对我们可以为 a 实例化的类型“挑剔”。我经常用来思考这个问题的一种直观方式如下：

• 函子是一种在不触及结构的情况下对某事物的内容进行操作的方式。
• 自然转换是一种在不接触或查看内容的情况下对事物的结构进行操作的方法。

现在，解决这个问题，让我们来处理定义的子句。

第一个子句是“一个endofunctor，T : X -> X”。好吧，Haskell 中的每个函子都是人们所谓的“Hask 类别”中的一个内函子，其对象是 Haskell 类型（类型为 *），其态射是 Haskell 函数。这听起来像是一个复杂的说法，但实际上是一个非常简单的说法。它的意思是函子 f :: * -> * 为您提供了为任何 a :: * 构造类型 fa :: * 和函数 fmap f :: fa -> 的方法; f b 出自任何 f :: a ->; b，并且它们遵守函子定律。

第二个子句：Haskell 中的 Identity 函子（平台附带，因此您可以导入它）是这样定义的：

newtype Identity a = Identity { runIdentity :: a }

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

所以自然变换η : I ->对于任何 Monad 实例 t，Tom Crockett 定义中的 T 可以这样写：

return' :: Monad t => Identity :-> t
return' = Natural (return . runIdentity)

第三个子句：Haskell 中两个函子的组合可以是如此定义（平台也附带）：

newtype Compose f g a = Compose { getCompose :: f (g a) }

-- | The composition of two 'Functor's is also a 'Functor'.
instance (Functor f, Functor g) => Functor (Compose f g) where
    fmap f (Compose fga) = Compose (fmap (fmap f) fga)

因此自然变换μ : T × T -> Tom Crockett 的定义中的 T 可以这样写：

join' :: Monad t => Compose t t :-> t
join' = Natural (join . getCompose)

这是 endofunctors 类别中的幺半群的陈述意味着 Compose （部分应用于其前两个参数）是关联的，Identity 是它的标识元素。即，以下同构成立：

• Compose f (Compose gh) ~= Compose (Compose fg) h
• Compose f Identity ~= f
• Compose Identity g ~= g

这些很容易证明，因为 Compose 和 Identity 都定义为 newtype，并且 Haskell Reports 定义了以下语义newtype 作为所定义的类型与 newtype 数据构造函数的参数类型之间的同构。例如，让我们证明Compose f Identity ~= f：

Compose f Identity a
    ~= f (Identity a)                 -- newtype Compose f g a = Compose (f (g a))
    ~= f a                            -- newtype Identity a = Identity a
Q.E.D.

Answer 3

这里的答案在定义幺半群和单子方面做得很好，但是，它们似乎仍然没有回答这个问题：

还有一个不太重要的问题，这是真的吗？如果是的话，您能否给出解释（希望没有太多 Haskell 经验的人能够理解）？

这里缺少的问题的关键是“幺半群”的不同概念，更准确地说是所谓的分类——幺半群在幺半群范畴中的概念。遗憾的是 Mac Lane 的书本身 让人非常困惑：

总而言之，X中的单子只是X的endofunctors类别中的幺半群，其乘积×被替换为由恒等endofunctor 设置的endofunctors 和单位。

主要困惑

为什么这会令人困惑？因为它没有定义什么是X的“endofunctors范畴中的幺半群”。相反，这句话建议将所有内函子集合内的幺半群与函子组合一起作为二元运算，将恒等函子作为幺半群单元。它工作得很好，并且将包含恒等函子并在函子组合下封闭的内函子的任何子集变成幺半群。

但这并不是正确的解释，本书当时未能明确说明这一点。 Monad f 是一个固定的endofunctor，而不是组合下封闭的endofunctor的子集。常见的构造是使用 f 通过获取所有 k 折叠组合的集合来生成一个幺半群 f^k = f f 的 (f(...)) 与其自身，包括对应于身份 f^0 = idk=0代码>.现在，所有 k>=0 的所有这些幂的集合 S 确实是一个幺半群，“乘积 × 替换为 endofunctor 的组合，单位由恒等 endofunctor 设置” 。

然而：

• 这个幺半群S可以为任何函子f定义，甚至可以为X的任何自映射定义。它是由f生成的幺半群。
• 由函子组合和恒等函子给出的 S 幺半群结构与 f 是否是单子无关。

更令人困惑的是，“幺半群类别中的幺半群”的定义在本书后面出现，您可以从 目录。然而，理解这个概念对于理解与单子的联系绝对至关重要。

（严格）幺半群范畴

转到关于幺半群的第七章（比关于单子的第六章晚），我们发现所谓的严格幺半群范畴的定义为三重(B, * , e)，其中B是类别，*: B x B-> B 是一个 bifunctor（相对于每个组件的函子，其他组件固定），e 是 B 中的一个单位对象，满足结合律和单位定律：

(a * b) * c = a * (b * c)
a * e = e * a = a

对于 B 的任何对象 a,b,c，以及对于任何态射 a,b,c 具有相同的恒等式将e 替换为id_e，即e 的恒等态射。现在观察一下，在我们感兴趣的例子中，其中 B 是 X 的内函子类别，自然变换为态射，*函子复合和e恒等函子，所有这些定律都满足，可以直接验证。

书中接下来是“宽松”幺半群范畴的定义，其中定律仅对某些满足所谓相干关系的固定自然变换进行取模，即然而对于我们的内函子类别的例子来说并不重要。

：

最后，在第七章第 3 节“幺半群”中，给出了实际的定义

幺半群范畴 (B, *, e) 中的幺半群 c 是带有两个箭头（态射）的 B 对象 < /p>

mu: c * c -> c
nu: e -> c

使 3 个图可交换。回想一下，在我们的例子中，这些是 endofunctors 类别中的态射，它们是与 monad 的 join 和 return 精确对应的自然变换。当我们使组合 * 更加明确时，用 c^2 替换 c * c，其中 c< /code> 是我们的 monad。

最后，请注意，3 个交换图（在幺半群范畴中的幺半群定义中）是为一般（非严格）幺半群范畴编写的，而在我们的例子中，作为幺半群范畴的一部分而出现的所有自然变换实际上都是恒等式。这将使图表与单子定义中的图表完全相同，从而使对应关系完整。

结论

总之，任何 monad 根据定义都是一个 endofunctor，因此是 endofunctor 类别中的对象，其中 monadic join 和 return 运算符满足 a 的定义特定（严格）幺半群类别中的幺半群。反之亦然，根据定义，内函子幺半群类别中的任何幺半群都是由一个对象和两个箭头组成的三元组(c, mu, nu)，例如我们例子中的自然变换，满足与一个单子。

最后，请注意（经典）幺半群和幺半群类别中更一般的幺半群之间的主要区别。上面的两个箭头 mu 和 nu 不再是二元运算和集合中的单位。相反，您有一个固定的 endofunctor c。尽管书中有令人困惑的评论，但函子组合 * 和恒等函子本身并不能提供 monad 所需的完整结构。

另一种方法是与集合A的所有自映射的标准幺半群C进行比较，其中二元运算是组合，可以看出映射标准笛卡尔积 C x C 转换为 C。传递到分类幺半群，我们将笛卡尔积 x 替换为函子组合 *，并将二元运算替换为自然变换 mu > 来自
join 运算符的集合

join: c(c(T))->c(T)

c * c 到 c，这是每个对象 T 的 （在编程中键入）。经典幺半群中的恒等元素可以用固定单点集中的地图图像来识别，它被return运算符的集合所取代。

return: T->c(T) 

但是现在不再有笛卡尔积了，所以没有元素对，因此没有二元运算。

Answer 4

我写这篇文章是为了更好地理解 Mac Lane 的工作数学家的范畴论中臭名昭著的引文的推论。

在描述某事物是什么时，描述它不是什么通常同样有用。

Mac Lane 使用该描述来描述 Monad 的事实可能意味着它描述了 monad 所独有的东西。耐心听我说。为了对这个陈述有更广泛的理解，我认为需要明确的是，他并不是在描述单子所独有的东西；而是在描述单子所特有的东西。该声明同样描述了 Applicative 和 Arrows 等。出于同样的原因，我们可以在 Int 上有两个幺半群（Sum 和 Product），我们可以在 X 上的内函子类别中拥有多个幺半群。但两者还有更多相似之处。

Monad 和 Applicative 都满足标准：

• endo =>任何在同一位置开始和结束的箭头或态射
• functor =>两个类别之间的任何箭头或态射

  （例如，在日常Tree a -> List b中，但在Category Tree -> List中）< /p>

• monoid =>单个对象；即，单一类型，但在这种情况下，仅涉及外部层；所以，我们不能有Tree ->列表，仅列表->列表。

该语句使用“类别...”这定义了该语句的范围。例如，函子类别描述了 f * -> 的范围。 g *，即任何函子 ->任何函子，例如，Tree * ->列表 * 或 树 * ->树*。

分类语句未指定的内容描述了允许任何事物。

在这种情况下，在函子内部，* -> * 又名 a -> b 未指定，这意味着 Anything ->任何东西，包括任何其他东西。当我的想象力跳到 Int -> String，还包括Integer ->也许是 Int，甚至是 也许是 Double -> String Int where a :: Maybe Double; b :: 要么是 String Int。

因此该语句组合如下：

• functorscope :: fa -> g b （即任何参数化类型到任何参数化类型）
• endo + functor :: fa -> f b （即，任何一个参数化类型到相同的参数化类型）...换句话说，
• endofunctor 类别中的幺半群

那么，这个构造的威力在哪里？为了理解完整的动态，我需要看到幺半群的典型绘图（带有单位箭头的单个对象，:: single object -> single object）未能说明这一点我可以使用由 Monoid 中允许的 one 类型对象中任意数量的 monoid 值参数化的箭头。等价的 endo, ~ 恒等箭头定义忽略函子的类型值以及最内部“有效负载”层的类型和值。因此，在函子类型匹配的任何情况下，等价都会返回 true（例如，Nothing -> Just * -> Nothing 相当于 Just * -> ; 只是 * -> 只是 * 因为它们都是也许 -> 也许）。

侧边栏：~outside 是概念性的，但它是 f a 中最左边的符号。它还描述了“Haskell”首先读入的内容（大图）；因此，类型相对于类型值而言是“外部”的。编程中各层（引用链）之间的关系不容易在类别中关联起来。 Set 的类别用于描述类型（Int、Strings、Maybe Int 等），其中包括 Functor 的类别（参数化类型）。引用链：函子类型、函子值（函子集合的元素，例如 Nothing、Just），以及每个函子值指向的其他所有内容。在类别中，关系的描述不同，例如，return :: a -> m a 被认为是从一个 Functor 到另一个 Functor 的自然转换，与迄今为止提到的任何内容都不同。

回到主线程，总而言之，对于任何定义的张量积和中性值，该语句最终描述了一个源自其悖论结构的极其强大的计算构造：

• 在外部，它显示为单个对象（例如，:: 列表);静态
• 但内部允许大量动态
  • 任意数量的相同类型的值（例如，Empty | ~NonEmpty）作为任意数量函数的素材。张量积会将任意数量的输入减少为单个值...对于外部层（~fold 未提及有效负载）
  • 最内层的类型和值的范围无限

在 Haskell 中，澄清该语句的适用性非常重要。这种结构的力量和多功能性与单子本身完全无关。换句话说，该构造不依赖于单子的独特性。

当试图弄清楚是否使用共享上下文构建代码来支持相互依赖的计算，而不是可以并行运行的计算时，这个臭名昭著的陈述，尽管它描述了很多，并不是以下选择之间的对比应用性、箭头和单子，而是对它们有多少相同的描述。对于手头的决定，该声明没有实际意义。

这常常被误解。该语句继续描述 join :: m (ma) -> m a 作为幺半群内函子的张量积。然而，它没有阐明在该声明的上下文中如何选择(<*>)。这确实是“六合一，六合一”的例子。组合值的逻辑完全相同；相同的输入会生成相同的输出（与 Int 的 Sum 和 Product monoids 不同，因为它们在组合 Int 时生成不同的结果）。

因此，回顾一下：endofunctors 类别中的幺半群描述：

 ~t :: m * -> m * -> m *
 and a neutral value for m *
    

(<*>) 和 (>>=) 都提供对两者的同时访问m 值以计算单个返回值。用于计算返回值的逻辑完全相同。如果不是因为它们参数化的函数形状不同（f :: a -> b 与 k :: a -> m b）以及具有相同计算返回类型的参数（即分别为 a -> b -> b 与 b -> a -> b） ，我怀疑我们可以参数化幺半群逻辑，即张量积，以便在两个定义中重用。作为阐明这一点的练习，尝试并实现 ~t，最终得到 (<*>) 和 (>>= ) 取决于您决定如何为所有 a b 定义它。

如果我的最后一点至少在概念上是正确的，那么它就解释了 Applicative 和 Monad 之间精确且唯一的计算差异：它们参数化的函数。换句话说，差异是这些类型类的实现的外部。

总之，根据我自己的经验，Mac Lane 臭名昭著的引言提供了一个很棒的“goto”模因，它是我在浏览类别时可以参考的指南，以更好地理解 Haskell 中使用的惯用语。它成功地捕获了 Haskell 中可以轻松访问的强大计算能力的范围。

然而，具有讽刺意味的是，我第一次误解了该声明在 monad 之外的适用性，以及我希望在这里传达的内容。它所描述的一切都被证明是 Applicative 和 Monad（以及 Arrows 等）之间的相似之处。它没有说的恰恰是它们之间微小但有用的区别。

Answer 5

注意：不，这不是真的。在某个时候，丹·皮波尼本人对这个答案发表了评论，说这里的因果关系完全相反，他写这篇文章是为了回应詹姆斯·艾里的俏皮话。但它似乎已经被删除了，也许是被一些强迫性的整理者删除了。

以下是我原来的回答。

---

Iry 很可能读过 从 Monoid 到 Monads，一篇文章，其中 Dan Piponi (sigfpe) 从 Haskell 中的幺半群派生出 monad，其中对范畴论进行了大量讨论，并明确提到了“Hask" 。无论如何，任何想知道单子作为内函子类别中的幺半群意味着什么的人可能会从阅读这个推导中受益。

Answer 6

这是另一个使用 monad IO 的显式示例。

可能的混淆1：A Monad 不是 Monoid！

在 Haskell 文档中 在上面的 Monoid 中，你可以看到源代码是

class Semigroup a => Monoid a where
    ⟨additional conditions⟩

这样写的：“Define Monoid to be a typeclass: a type a is a 幺半群如果它是半群和⟨附加条件⟩”。

您在 Monad。因为 Monad 不是 Haskell 幺半群。

为什么？ “monoid”这个词有 2 个含义：

• 抽象代数中的幺半群：一个集合 S配备●：S × S → S 和e ∈ S，
• 范畴论中的幺半群。

Haskell 中的类型类 Monoid 是抽象代数意义上的幺半群。

特别是，

• 单子不由一组对象组成。 （IO 当然不包含像 ℕ 那样的内容。）
• monad 的二元运算不会接受两个对象并返回一个。 （+ 接受两个整数并返回一个，但是 join 不接受两个任何东西 --- IO 内部没有任何东西可以拿！）

可能的混淆2：monad（category_theory）不是Haskell Monad

不同概念之间的关系：

1. 抽象代数中的幺半群是抽象代数中的幺半群（范畴论） >集合类别。

   这是一个等价——集合范畴中的幺半群是抽象代数中的幺半群。

2. 单子是内函子类别中的幺半群（范畴论）。

   这也是等价的。

3. Haskell 中的 Monad 是一个 monad。例如，IO 是一个 monad。

   这不是等价！并非所有 monad 都是 Haskell monad。

范畴论中的幺半群是什么？

需要澄清的是，这里滥用了术语。当我们说

ℤ是一个环

ℤ 是我们实际上指的

(ℤ, +, 0, ×, 1) 是一个环

当然，使用哪些运算符通常是隐式的。

同样，当我们说

ℕ 是一个幺半群

我们所说的

幺半群

(ℕ, +, 0) 是一个幺半群。

另一方面，(ℕ, ×, 1) 也是一个幺半群。

当我们说

X 是类别 Y

中的幺半群

这里同样存在符号滥用。它实际上意味着

(X, μ, η) 是类别 (Y, *, e)

中的幺半群

，或者

X 是类别 Y 中的对象，且 (X, μ, η) 满足幺半群公理

或, 更短,

X 是类别 Y 中关于 (μ, η, *, e) 的幺半群对象代码>.

_{（我将在这里使用 η (eta)。其他一些答案使用 ν (nu)。）}

示例

考虑上面的 ℕ 示例。我们想说

(ℕ, +, ⟨• → 0⟩) 是类别 (Sets, ×, {•}) 中的幺半群。

您可以检查事物的类型：

• ℕ是集合类别中的对象。
• + 是从 ℕ × ℕ 到 ℕ 的集合的态射。
• ⟨• → 0⟩ 是从单例集 {•} 到 ℕ 的集合态射，发送唯一的元素 • 到 0。
• × 是一个 Sets2 → Sets 函子，ℕ × ℕ 是 Sets,
• {•} 是类别 Sets 中的单例集。

那么什么是 Haskell monad？

Hask 类别是其中

• 对象是 Haskell 中的类型（例如 String、Integer 等）的类别，
• 态射是 Haskell 函数（例如(+ 1) :: Integer -> Integer，read :: String -> Integer）。

对于任何两个类别 A 和 B，我们都有函子类别，这里表示为 Fun(A, B)，其中

• 对象是函子在 A 和 B 之间，
• 态射是两个这样的函子之间的自然变换。

（如果您不知道函子和自然变换是什么，请阅读它们。）

具体来说，如果 A = B，则类别 Fun(A, A) code> 是A 的endofunctors 类别。

将这些拼凑在一起，

Haskell Monad 是幺半群范畴 (Fun(Hask, Hask), Compose, Identity) 中的幺半群（范畴论）。

这里，

• Compose 是一个 Fun(Hask, Hask)2 → Fun(Hask, Hask) 函子，Compose IO IO是将 String 发送到 IO (IO String) 的 endofunctor，
• Identity 是 Fun(Hask, Hask) 类别中的对象，身份字符串等于字符串。

例子

IO 是一个 Haskell Monad

这意味着：

• IO 是 Fun(Hask, Hask) 类别中的对象代码>:

  • Hask 类别中的每个对象，IO 将其发送到另一个对象。

    例如，从String，您将获得IO String。 （请注意，String 是一种类型，但在 Hask 类别中，它是一个对象。）

  • 对于 Hask 类别中的每个态射，IO 将其发送到另一个态射。

    例如从 read :: String ->整数，它被映射到fmap read :: IO String -> IO 整数.

• return 是类别 Fun(Hask, Hask) 中的态射。

  • 也就是说，它是从函子 Identity 到函子 IO 的自然转换。

    这是一些图表。

    

• join 是类别 Fun(Hask, Hask) 中的态射。

  • 也就是说，它是从函子 Compose IO IO 到函子 IO 的自然转换。

    （函子 Compose IO IO 是什么？它只接受 String 并返回 IO (IO String)）。

• ((IO, fmap), join, return) 满足幺半群公理。

这不是定义吗？

事实上，有两种等效的方法来定义 monad。

• Haskell 方式：(IO, bind, return) --- 其中 bind 写为 >>=。
• 对应范畴论中幺半群的方式：(IO, fmap, join, return)。

它们是可以互换的：

• bind 可以通过 fmap 和 join 实现，如下所示：

  -- a :: IO x 例如 getLine :: IO String
  --f::x-> IO y 例如 putStrLn :: String -> IO（）
  -- 绑定 af::IO y 例如 getLine>>= putStrLn::IO ()
  绑定 af = 加入 (fmap fa)
  

• join 和 fmap 可以通过 bind 实现，如下所示：

  -- x :: IO (IO y) 例如 fmap putStrLn getLine :: IO (IO String)
  -- 加入 x :: IO y
  连接 x = x >>= (\ioY -> ioY)
  --f::a->乙
  -- fmap f::IO a --> IOb
  fmap f ioA = ioA >>= (返回 .f)
  

  或者在 Haskell 语法糖中（do 符号去糖到 return 和 bind）：

  加入 x = do
     ioY <- x -- ioY :: IO ()
     -- 如果你调用 `join (fmap putStrLn getLine)`
     -- 那么 `ioY` 的值为 `putStrLn "⟨the input⟩"`
     结果<-ioY
     返回结果
  fmap f ioA = do
     x <- ioA -- x :: a
     y = fx -- y :: ioB
     返回y
  

  可以缩短为

  加入 x = do
     ioY＜-x
     IOY
  fmap f ioA = do
     x＜-ioA
     返回效果
  

参考文献

• https://stackoverflow .com/a/11241990/5267751
• Monad 连接函数
• https://math.stackexchange.com/q/3237942
• 此页面上的其他答案。