我刚刚从 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 不具备这一点?
最佳答案
我最喜欢的例子是“纯粹适用的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
准确体现了根据参数计算中嵌入的值进行结果计算的思想。
关于haskell - Haskell 中 Monad 和 Applicative 的区别,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/23342184/