Haskell Monad 绑定运算符混淆

Question

好的，所以我不是 Haskell 程序员，但我对 Haskell 背后的许多想法非常感兴趣，并且正在学习它。但我被困在第一方：我似乎无法围绕 Monads，这似乎是相当基本的。我知道关于 SO 有上百万个问题要求解释 Monads，所以我将更具体地说明困扰我的问题：

我阅读了这篇出色的文章 (an introduction in Javascript)，并认为我完全理解了 Monads。然后我阅读了关于 Monads 的 Wikipedia 条目，看到了这个：

多态类型(M t)→(t→M u)→(M u)的绑定操作，Haskell用中缀运算符>>=表示。 它的第一个参数是一个单子类型的值，它的第二个参数是一个从第一个参数的基础类型映射到另一个单子类型的函数，其结果是另一个单子类型。

好的，在我引用的那篇文章中，bind 是一个只接受 一个 参数的函数。维基百科说两个。我认为我对 Monads 的理解如下：

1. Monad 的目的是获取具有不同输入和输出类型的函数并使其可组合。它通过使用单个 monadic 类型包装输入和输出类型来做到这一点。
2. Monad 由两个相互关联的函数组成：绑定和单元。 Bind 接受一个不可组合的函数 f 并返回一个新函数 g ，该函数接受单子类型作为输入并返回单子类型。 g 是可组合的。 unit 函数接受 f 期望的类型的参数，并将其包装在 monadic 类型中。然后可以将其传递给 g，或像 g 这样的任何函数组合。

但肯定有什么问题，因为我的绑定概念有一个参数：一个函数。但是（根据维基百科）Haskell 的绑定实际上需要 两个 参数！我的错在哪里？

Answer 1

请允许我推翻你对 Monads 的看法。我真诚地希望您意识到我并不是要无礼；我只是想避免口齿不清。

Monad 的目的是获取具有不同输入和输出类型的函数并使其可组合。它通过使用单个单子类型包装输入和输出类型来做到这一点。

不完全是。当你以“A Monad's purpose”开始一个句子时，你已经走错了路。单子不一定有“目的”。 Monad 只是一种抽象，一种适用于某些类型而不适用于其他类型的分类。 Monad 抽象的目的就是抽象。

Monad 由两个相互关联的函数组成：bind 和 unit。

是的，不是的。 bind 和 unit 的组合足以定义 Monad，但 join、fmap 和 unit 的组合同样足够。事实上，后者正是范畴论中描述 Monad 的典型方式。

Bind 接受一个不可组合的函数 f 并返回一个新函数 g，该函数接受单子类型作为输入并返回单子类型。

同样，不完全是。一元函数f :: a -> m b 是完全可组合的，具有某些类型。我可以用函数g :: m b -> c 后组合它得到g . f :: a -> c，或者我可以用函数h :: c -> a 预先组合它得到f . h :: c -> m b。

但是第二部分完全正确：(>>= f) :: m a -> m b。正如其他人所指出的，Haskell 的 bind 函数以相反的顺序接受参数。

g 是可组合的。

嗯，是的。如果是g :: m a -> m b，那么你可以用函数f :: c -> m a预先组合得到g . f :: c -> m b，或者你可以用函数h :: m b -> c后组合得到h . g :: m a -> c。请注意，c 可以采用 m v 的形式，其中 m 是 Monad。我想当你说“可组合”时，你的意思是说“你可以组合任意长的这种形式的函数链”，这是真的。

unit 函数接受 f 所期望的类型的参数，并将其包装在 monadic 类型中。

一种迂回的说法，但是是的，这是正确的。

这个 [将unit 应用到某个值的结果] 然后可以传递给 g，或者像 g 这样的任何函数组合。

再次，是的。虽然调用 unit（或在 Haskell 中为 return）然后将其传递给 (>>= f) 通常不是 Haskell 惯用的做法。

-- instead of
return x >>= f >>= g
-- simply go with
f x >>= g

-- instead of
\x -> return x >>= f >>= g
-- simply go with
f >=> g
-- or
g <=< f

Answer 2

你链接的文章是基于sigfpe的文章，使用了bind的翻转定义：

第一件事是我翻转了bind 的定义并将其写为单词'bind'，而通常写为运算符>>=。所以bind f x 通常写成x >>= f。

因此，Haskell bind 接受一个包含在 monad 中的值，并返回一个函数，该函数接受一个函数，然后使用提取的值调用它。我可能使用了不精确的术语，所以使用代码可能会更好。

你有：

sine x = (sin x,     "sine was called.")
cube x = (x * x * x, "cube was called.")

现在，翻译你的 JS 绑定（Haskell 会自动进行柯里化，因此调用 bind f 返回一个接受元组的函数，然后模式匹配负责将其解包为 x 和 s，我希望这是可以理解的):

bind f (x, s) = (y, s ++ t)
                where (y, t) = f x

你可以看到它工作：

*Main> :t sine
sine :: Floating t => t -> (t, [Char])
*Main> :t bind sine
bind sine :: Floating t1 => (t1, [Char]) -> (t1, [Char])
*Main> (bind sine . bind cube) (3, "")
(0.956375928404503,"cube was called.sine was called.")

现在，让我们反转bind的参数：

bind' (x, s) f = (y, s ++ t)
                 where (y, t) = f x

您可以清楚地看到它仍在做同样的事情，但语法略有不同：

*Main> bind' (bind' (3, "") cube) sine
(0.956375928404503,"cube was called.sine was called.")

现在，Haskell 有一个语法技巧，允许您将任何函数用作中缀运算符。所以你可以写：

*Main> (3, "") `bind'` cube `bind'` sine
(0.956375928404503,"cube was called.sine was called.")

现在将 bind' 重命名为 >>= ((3, "") >>= cube >>= sine)，您就得到了想要的东西。如您所见，使用此定义，您可以有效地摆脱单独的组合运算符。

将新事物翻译回 JavaScript 会产生类似这样的结果（再次注意，我只是颠倒了参数顺序）：

var bind = function(tuple) {
    return function(f) {
        var x  = tuple[0],
            s  = tuple[1],
            fx = f(x),
            y  = fx[0],
            t  = fx[1];

        return [y, s + t];
    };
};

// ugly, but it's JS, after all
var f = function(x) { return bind(bind(x)(cube))(sine); }

f([3, ""]); // [0.956375928404503, "cube was called.sine was called."]

希望这会有所帮助，而不是造成更多混乱——关键是这两个绑定定义是等价的，只是调用语法不同。

Answer 3

你没有犯错。这里要理解的关键思想是柯里化——两个参数的 Haskell 函数可以通过两种方式看到。第一个是两个参数的简单函数。例如，如果您有(+)，这通常被视为接受两个参数并将它们相加。另一种看待它的方式是作为加法机生产商。 (+) 是一个函数，它接受一个数字，比如 x，并创建一个将添加 x 的函数。

(+) x = \y -> x + y
(+) x y = (\y -> x + y) y = x + y

在处理 monad 时，有时最好考虑一下 =<<，即 >>= 的翻转版本，就像上面提到的那样。有两种方法可以查看：

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

这是一个有两个参数的函数，并且

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

如文章所述，它将输入函数转换为易于组合的版本。这些和我之前解释的(+) 是等价的。