可折叠、Monoid 和 Monad

Question

考虑foldMap的以下签名

foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m

这与“绑定”非常相似，只是交换了参数：

(>>=) :: Monad m => m a -> (a -> m b) -> m b

在我看来，Foldable、Monoid 和Monad 之间肯定存在某种关系，但我在超类中找不到它。大概我可以将其中的一个或两个转换为另一个，但我不确定如何。

能否详细说明一下关系？

Answer 1

Monoid 和 Monad

哇，这实际上是我们可以使用引用的罕见情况之一：

monad 只是内函子范畴中的一个幺半群，[...]

让我们从一个幺半群开始。集合类别Set 中的幺半群是一组元素m，其中包含一个空元素mempty 和一个关联函数mappend，用于组合元素使得

mempty `mappend` x == x -- for any x
x `mappend` mempty == x -- for any x
-- and
a `mappend` (b `mappend` c) == (a `mappend` b) `mappend` c -- for all a, b, c

注意，一个幺半群不限于集合，在类别（monads）的类别Cat 中也存在幺半群等等。基本上任何时候你都有一个关联二元运算和它的标识。

现在一个单子，它是一个“内函子类别中的monoid”具有以下属性：

它是一个内函子，这意味着它在 Haskell 类型的 Hask 类别中具有类型 * -> *。

现在，为了更进一步，你必须了解一点范畴论，我将在这里尝试解释：给定两个函子 F 和 G，存在从 F 到 G 的自然转换存在一个函数α，这样每个F a 都可以映射到一个G a。 α 可以是多对一的，但它必须映射F a 的每个元素。粗略地说，自然变换是函子之间的函数。

现在在范畴论中，两个范畴之间可以有很多函子。在简化的视图中，可以说我们甚至不关心哪些函子从哪里映射到哪里，我们只关心它们之间的自然转换。

回到monad，我们现在可以看到“内函子范畴中的monoid”必须具有两个自然变换。让我们调用我们的 monad endofunctor M:

从身份（endo）函子到单子的自然转换：

η :: 1 -> M -- this is return

从两个单子的组合中自然转换并产生第三个：

μ :: M × M -> M

由于×是函子的组合，我们可以（粗略地说）也写成：

μ :: m a × m a -> m a
μ :: (m × m) a -> m a
μ :: m (m a) -> m a -- join in Haskell

满足这些法律：

μ . M μ == μ . μ M
μ . M η == μ . η M

因此，monad 是内函子范畴中幺半群的一个特例。你不能在普通的 Haskell 中为 monad 编写一个 monoid 实例，因为 Haskell 的组合概念太弱了（我认为；这是因为函数仅限于 Hask 并且它比 Cat 弱）。请参阅this 了解更多信息。

Foldable 呢？

现在对于Foldable：存在使用自定义二进制函数组合元素的folds 的定义。现在您当然可以提供任何函数来组合元素，或者您可以使用现有的组合元素概念，即幺半群。同样，请注意这个幺半群仅限于集合幺半群，不是幺半群的分类定义。

由于幺半群的mappend 是关联的，所以foldl 和foldr 产生相同的结果，这就是幺半群的折叠可以简化为fold :: Monoid m, Foldable t => t m -> m 的原因。这是幺半群和可折叠之间的明显联系。

@danidiaz 已经使用Const 函子Const a b = Const a 指出了Applicative、Monoid 和Foldable 之间的联系，其应用实例要求Const 的第一个参数是一个幺半群（没有@ 987654362@ 没有mempty （忽略undefined））。

在我看来，比较 monad 和 foldable 有点牵强，因为 monad 比 foldable 更强大，因为 foldable 只能根据映射函数累积列表的值，但 monad 绑定可以在结构上改变上下文(a -> m b)。

Answer 2

总结：(>>=) 和 traverse 看起来很相似，因为它们都是函子的箭头映射，而 foldMap （几乎）是专门的 traverse。

在我们开始之前，需要解释一些术语。考虑fmap：

fmap :: Functor f => (a -> b) -> (f a -> f b)

Haskell Functor 是 Hask 类别（以 Haskell 函数为箭头的类别）到其自身的函子。在范畴论术语中，我们说（专门的）fmap 是这个函子的箭头映射，因为它是函子中将箭头指向箭头的部分。 （为了完整起见：函子由箭头映射和对象映射组成。在这种情况下，对象是 Haskell 类型，因此对象映射将类型转换为类型——更具体地说， Functor 的对象映射是它的类型构造函数。）

我们还需要牢记范畴和函子定律：

-- Category laws for Hask:
f . id = id
id . f = f
h . (g . f) = (h . g) . f

-- Functor laws for a Haskell Functor:
fmap id = id
fmap (g . f) = fmap g . fmap f

接下来，我们将使用 Hask 以外的类别，以及不是 Functors 的函子。在这种情况下，我们将id 和(.) 替换为适当的标识和组合，fmap 替换为适当的箭头映射，在一种情况下，= 替换为适当的箭头相等。

(=

从答案中更熟悉的部分开始，对于给定的 monad m，a -> m b 函数（也称为 Kleisli 箭头）形成一个类别（m 的 Kleisli 类别），与 return作为身份和(<=<) 作为组合。三类法则，在这种情况下，就是the monad laws：

f <=< return = return
return <=< f = f
h <=<  (g <=<  f) = (h <=<  g) <=<  f

现在，您问的是翻转绑定：

(=<<) :: Monad m => (a -> m b) -> (m a -> m b)

原来(=<<) 是从m 的 Kleisli 范畴到 Hask 的函子的箭头映射。应用于(=<<) 的函子定律相当于两个单子定律：

return =<< x = x -- right unit
(g <=< f) =<< x = g =<< (f =<< x) -- associativity 

遍历

接下来，我们需要绕道Traversable（答案末尾提供了本节结果证明的草图）。首先，我们注意到 all 应用函子 f 的 a -> f b 函数一次获取（而不是每次一个，如指定 Kleisli 类别时）形成一个类别，@987654355 @ 作为身份，Compose . fmap g . f 作为组合。为此，我们还必须采用更宽松的箭头等式，它忽略了Identity 和Compose 样板（这只是必要的，因为我是用伪Haskell 编写的，而不是正确的数学符号） .更准确地说，我们将考虑使用Identity 和Compose 同构的任何组合作为相等箭头可以相互转换的任何两个函数（或者，换句话说，我们不会区分a 和Identity a ，也不在f (g a)和Compose f g a之间）。

让我们将该类别称为“可遍历类别”（因为我现在想不出更好的名称）。在具体的 Haskell 术语中，此类别中的箭头是一个函数，它在任何先前现有层的“下方”添加了一个额外的 Applicative 上下文层。现在，考虑traverse：

traverse :: (Traversable t, Applicative f) => (a -> f b) -> (t a -> f (t b))

给定一个可遍历容器的选择，traverse 是函子从“可遍历类别”到自身的箭头映射。它的函子定律相当于可遍历定律。

简而言之，(=<<) 和 traverse 对于涉及 Hask 之外的类别的函子来说都是 fmap 的类似物，因此它们的类型有点相似也就不足为奇了其他。

折叠地图

我们仍然需要解释所有这些与foldMap 有什么关系。答案是foldMap 可以从traverse 恢复（参见danidiaz's answer——它使用traverse_，但由于应用函子是Const m，结果基本相同）：

-- cf. Data.Traversable
foldMapDefault :: (Traversable t, Monoid m) => (a -> m) -> (t a -> m)
foldMapDefault f = getConst . traverse (Const . f)

感谢const/getConst 同构，这显然等同于：

foldMapDefault' :: (Traversable t, Monoid m)
                => (a -> Const m b) -> (t a -> Const m (t b))
foldMapDefault' f = traverse f

这只是 traverse 专用于 Monoid m => Const m 应用函子。尽管Traversable 不是Foldable 并且foldMapDefault 不是foldMap，这为foldMap 的类型类似于traverse 的类型以及传递性地类似于(=<<) 的类型提供了一个很好的理由。

作为最后的观察，请注意带有应用函子 Const m 的“可遍历类别”的箭头对于某些 Monoid m 确实不形成子类别，因为没有身份除非Identity 是应用函子的可能选择之一。这可能意味着从这个答案的角度来看，关于foldMap 没有什么值得说的了。提供子类别的应用函子的唯一单一选择是Identity，这并不奇怪，因为在容器上使用Identity 的遍历相当于fmap。

附录

这是推导traverse 结果的粗略草图，从我几个月前的笔记中抽出，并进行了最少的编辑。 ~ 表示“等于（某些相关的）同构”。

-- Identity and composition for the "traversable category".
idT = Identity
g .*. f = Compose . fmap g . f

-- Category laws: right identity
f .*. idT ~ f
f .*. idT
Compose . fmap f . idT
Compose . fmap f . Identity
Compose . Identity . f
f -- using getIdentity . getCompose 

-- Category laws: left identity
idT .*. f ~ f
idT .*. f
Compose . fmap Identity . f
f -- using fmap getIdentity . getCompose

-- Category laws: associativity
h .*. (g .*. f) ~ (h .*. g) .*. f
h .*. (g .*. f) -- LHS
h .*. (Compose . fmap g . f)
Compose . fmap h . (Compose . fmap g . f)
Compose . Compose . fmap (fmap h) . fmap g . f
(h .*. g) .*. f -- RHS
(Compose . fmap h . g) .*. f
Compose . fmap (Compose . fmap h . g) . f
Compose . fmap (Compose . fmap h) . fmap g . f
Compose . fmap Compose . fmap (fmap h) . fmap g . f
-- using Compose . Compose . fmap getCompose . getCompose
Compose . Compose . fmap (fmap h) . fmap g . f -- RHS ~ LHS

-- Functor laws for traverse: identity
traverse idT ~ idT
traverse Identity ~ Identity -- i.e. the identity law of Traversable

-- Functor laws for traverse: composition
traverse (g .*. f) ~ traverse g .*. traverse f
traverse (Compose . fmap g . f) ~ Compose . fmap (traverse g) . traverse f 
-- i.e. the composition law of Traversable

Answer 3

当容器为Foldable时，foldMap和Applicative之间存在关系（Monad的超类）。

Foldable 有一个名为traverse_ 的函数，带有签名：

traverse_ :: Applicative f => (a -> f b) -> t a -> f ()

Applicative 可能是Constant。要成为 Applicative，它需要“累加器”参数为 Monoid：

newtype Constant a b = Constant { getConstant :: a } -- no b value at the term level!

Monoid a => Applicative (Constant a)

例如：

gchi> Constant (Sum 1) <*> Constant (Sum 2) :: Constant (Sum Int) whatever
Constant (Sum {getSum = 3})

我们可以用traverse_和Constant这样定义foldMap：

foldMap' :: (Monoid m, Foldable t) => (a -> m) -> t a -> m
foldMap' f = getConstant . traverse_ (Constant . f)

我们用traverse_遍历容器，用Constant累加值，然后我们用getConstant去掉newtype。