为什么绑定运算符（>>=）按原样定义？

Question

我已经学习 Haskell 几个星期了（只是为了好玩），刚刚看了 Brian Beckman 的精彩 video introducing monads。他激励 monads 需要创建一个更通用的组合运算符。按照这个思路，如果我有两个功能：

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

合成运算符应满足

h = g . f :: a -> c

由此我可以推断出. 运算符的正确类型：

(.) : (b -> c) -> (a -> b) -> (a -> c)

说到 monad，假设我有两个函数：

f :: a -> m b
g :: b -> m c

在我看来，自然的选择是定义一个通用的组合运算符，其工作原理如下：

h = f >>= g :: a -> m c

在这种情况下，>>= 运算符的类型签名为：

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

但实际上操作符似乎是这样定义的

h a = (f a) >>= g :: m c

因此

(>>=) : m b -> (b -> m c) -> m c

有人可以解释选择绑定定义背后的原因吗？我认为这两种选择之间存在一些简单的联系，其中一种可以用另一种来表达，但我目前还没有看到。

Answer 1

您可以搜索您的运营商on Hoogle，并看到它被称为(>=>)。它在(>>=) 方面的定义是quite simple：

f >=> g = \x -> f x >>= g

从某种意义上说，(>=>) 更好地反映了泛化组合的想法，但我认为(>>=) 作为原始运算符更有效，因为它在更多情况下更实用，并且更容易与 do-notation 相关联。

Answer 2

有人可以解释选择绑定定义背后的原因吗？

当然，这与您的推理几乎完全相同。只是……我们想要一个更通用的 application 运算符，而不是更通用的组合运算符。如果你做过很多（任何）无点编程，你会立即明白原因：与有点程序相比，无点程序很难编写，而且难以阅读。例如：

h x y = f (g x y)

使用函数应用程序，这完全是直截了当的。只使用函数组合的版本是什么样的？

h = (f .) . g

如果您在第一次看到这个时不必停下来凝视一两分钟，那么您实际上可能是一台计算机。

因此，无论出于何种原因：我们的大脑天生就可以更好地使用开箱即用的名称和功能应用程序。所以这就是你论证的其余部分的样子，但是用应用代替了组合。如果我有一个函数和一个参数：

f :: a -> b
x :: a

应用运营商应满足

h = x & f :: b

由此我可以推断出& 运算符的正确类型：

(&) :: a -> (a -> b) -> b

说到 monad，假设我的函数和参数是 monadic：

f :: a -> m b
x :: m a

自然的选择是定义一个通用的应用运算符，其工作方式如下：

h = x >>= f :: m b

在这种情况下，>>= 运算符的类型签名为：

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

Answer 3

我同意以( >=> ) :: ( a -> m b ) -> ( b -> m c ) -> ( a -> m c) 的方式思考通常感觉更自然，因为它更接近通常的功能组合，事实上它是 Kleisli 类别中的组合。从这个角度来看，Haskell 的许多 monad 实例实际上更容易理解。

Haskell 选择( >>= ) :: m a -> ( a -> m b) -> m b 的一个原因可能是这个定义在某种程度上是最通用的。 >=> 和join :: m ( m x ) -> m x 都可以简化为>>=：

( >=> ) f g x = f x >>= g

join mmx = mmx >>= id

如果将return :: x -> m x 添加到组合中，还可以导出fmap :: ( a -> b ) -> m a -> m b（函子）和( <*> ) :: m ( a -> b ) -> m a -> m b（应用程序）：

fmap f ma = ma >>= ( return . f )

( <*> ) mab ma =
    mab >>= \f ->
    ma  >>= \a ->
    return ( f a )

Answer 4

(>>=) 不是组合运算符。它是一个应用程序运算符。

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

还有(=<<)（来自Control.Monad），对应更常用的应用运算符($)：

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

对于组合，我们有(<=<) 和(>=>)（同样来自Control.Monad，第一个与(.) 完全相同：

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

（(>=>) 只是 (<=<)，其参数被翻转；(>=>) = flip (<=<)）

---

在我们比较类型时，您可能想看看 fmap 是如何适应的。

($)   ::              (a ->   b) ->   a ->   b
fmap  :: Functor f => (a ->   b) -> f a -> f b
(=<<) :: Monad m   => (a -> m b) -> m a -> m b

($) 和 fmap 采用相同类型的函数，但将其应用于不同类型的参数。

fmap 和 (=<<) 采用不同类型的函数，但将它们都应用于相同类型的参数（尽管方式不同）。