haskell - Haskell 中 Monad 和 Applicative 的区别

Question

我刚刚从 typeclassopedia 读到以下内容关于 Monad 和 Applicative 之间的区别。我可以理解，Applicative 中没有 join 。但下面的描述对我来说看起来很模糊，我无法弄清楚一元计算/ Action 的“结果”到底是什么意思。那么，如果我将一个值放入 Maybe 中，这会生成一个 monad，那么这个“计算”的结果是什么？

Let’s look more closely at the type of (>>=). The basic intuition is that it combines two computations into one larger computation. The first argument, m a, is the first computation. However, it would be boring if the second argument were just an m b; then there would be no way for the computations to interact with one another (actually, this is exactly the situation with Applicative). So, the second argument to (>>=) has type a -> m b: a function of this type, given a result of the first computation, can produce a second computation to be run. ... Intuitively, it is this ability to use the output from previous computations to decide what computations to run next that makes Monad more powerful than Applicative. The structure of an Applicative computation is fixed, whereas the structure of a Monad computation can change based on intermediate results.

是否有一个具体的示例来说明“能够使用先前计算的输出来决定下一步要运行哪些计算”，而 Applicative 不具备这一点？

Answer 1

我最喜欢的例子是“纯粹适用的Either”。我们将首先分析 Either 的基本 Monad 实例

instance Monad (Either e) where
  return = Right
  Left e  >>= _ = Left e
  Right a >>= f = f a

这个实例嵌入了一个非常自然的短路概念:我们从左到右进行，一旦单个计算“失败”到Left然后其他人也这样做。还有自然的Applicative任何 Monad 的实例有

instance Applicative (Either e) where
  pure  = return
  (<*>) = ap

哪里ap无非是在 return 之前从左到右排序。 :

ap :: Monad m => m (a -> b) -> m a -> m b
ap mf ma = do 
  f <- mf
  a <- ma
  return (f a)

<小时/>

现在有麻烦了 Either当您想要收集计算中任何地方发生的错误消息并以某种方式生成错误摘要时，实例就会出现。这与短路是相悖的。它也与 (>>=) 的类型背道而驰。

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

如果我们想到m a作为“过去”和 m b那么 (>>=) 就是“ future ”只要它可以运行“步进器”(a -> m b)，就可以从过去产生 future 。 。这个“步进器”要求 a 的值 future 确实存在...而这对于 Either 来说是不可能的。因此(>>=) 要求短路。

因此我们将实现 Applicative不能有相应的 Monad 的实例.

instance Monoid e => Applicative (Either e) where
  pure = Right

现在执行(<*>)是值得仔细考虑的特殊部分。它在前 3 个案例中执行了一定量的“短路”，但在第四个案例中做了一些有趣的事情。

  Right f <*> Right a = Right (f a)     -- neutral
  Left  e <*> Right _ = Left e          -- short-circuit
  Right _ <*> Left  e = Left e          -- short-circuit
  Left e1 <*> Left e2 = Left (e1 <> e2) -- combine!

再次注意，如果我们将左侧参数视为“过去”，将右侧参数视为“ future ”，则 (<*>)与(>>=)相比很特别因为它可以并行“打开” future 和过去，而不一定需要“过去”的结果来计算“ future ”。

这意味着，我们可以直接使用我们的纯 Applicative Either收集错误，忽略 Right s(如果有)Left链中存在s

> Right (+1) <*> Left [1] <*> Left [2]
> Left [1,2]

<小时/>

所以让我们颠覆这种直觉。我们不能用纯粹的应用来做什么Either ？好吧，由于它的运作取决于在运行过去之前检查 future ，因此我们必须能够在不依赖于过去的值的情况下确定 future 的结构。换句话说，我们不能写

ifA :: Applicative f => f Bool -> f a -> f a -> f a

满足以下方程

ifA (pure True)  t e == t
ifA (pure False) t e == e

虽然我们可以写ifM

ifM :: Monad m => m Bool -> m a -> m a -> m a
ifM mbool th el = do
  bool <- mbool
  if bool then th else el

这样

ifM (return True)  t e == t
ifM (return False) t e == e

出现这种不可能的原因是 ifA准确体现了根据参数计算中嵌入的值进行结果计算的思想。