如何解释函数实例的bind/>>>=？

我正在努力提高我的理解Applicatives and Monad通过在 Javascript 中实现其函数实例来实现。我对 Haskell 的了解有限，我希望我的问题有意义。

这是我的实现fmap, <*> and >>=为了Functor, Applicative and MonadJavascript 中的类型类：

const fmap = f => g => x => f(g(x)); // B combinator
const apply = f => g => x => f(x) (g(x)); // S combinator
const bind = f => g => x => g(f(x)) (x); // ?

我不确定是否bind是 Haskell 实现的正确翻译：

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

instance Monad ((->) r) where
f >>= k = \ r -> k (f r) r

前提是bind是正确的，如何解释？我知道一个Applicative可以进行有效的计算。我还知道一个Monad此外，您还可以根据前一个效果确定下一个效果。

我可以看到序列（Javascript 中的急切求值顺序）：

• apply: f(x) ... g(x) ... lambda(result of g)... 的结果lambda
• bind: f(x) ... g(result of f) ... lambda(x)... 的结果lambda

但是，那bind函数看起来很奇怪。为什么是f and g反过来嵌套？具体如何Monad此实现中反映的行为（根据前一个效果确定下一个效果）？实际上g(f(x)) (x)看起来像一个带有翻转参数的函数组合，其中g是二元函数。

当我申请时apply/bind对于一元和二元函数，它们产生相同的结果。这没有多大意义。

一些脚注李的回答 https://stackoverflow.com/a/40132248/2751851:

但是，那bind函数看起来很奇怪。为什么是f and g反过来嵌套？

Because bind是向后的。比较(>>=)及其翻转版本(=<<):

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

或者，在您的具体示例中：

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

而在实践中我们倾向于使用(>>=)经常多于(=<<)（因为如何(>>=)从语法上来说，从理论的角度来看，它非常适合通常用来构建的管道单子）(=<<)是最自然的书写方式。特别是，与fmap/(<$>) and (<*>)更加明显：

(<$>) :: Functor f     =>   (a -> b) -> f a -> f b
(<*>) :: Applicative f => f (a -> b) -> f a -> f b
(=<<) :: Monad f       => (a -> f b) -> f a -> f b

当我申请时apply/bind对于一元和二元函数，它们产生相同的结果。这没有多大意义。

这是关于函数实例的一个偶然事实。让我们将专门的签名并排放置：

(<*>) :: (r -> (a -> b)) -> (r -> a) -> (r -> b)
(=<<) :: (a -> (r -> b)) -> (r -> a) -> (r -> b)

Monad超越Applicative通过提供根据先前的效果确定下一个效果的方法results（与“之前的效果”相反——Applicative已经可以做到了）。在这种情况下，效果由一个函数组成，该函数根据给定类型的参数生成值r。现在，由于具有多个参数的函数（即返回函数的函数）可以翻转，因此两者之间没有显着差异(r -> (a -> b)) and (a -> (r -> b)) (flip可以轻松地将一种改变为另一种），这使得Monad实例为(->) r完全等价于Applicative one.