Haskell/应用函子
在介绍重要的 Functor 和 Monad 类型类时，我们略过了第三个类型类：Applicative，即应用函子的类。与单子一样，应用函子是带有额外定律和操作的函子；事实上，Applicative 是 Functor 和 Monad 之间的中间类。Applicative 是一个广泛使用的类，拥有丰富的应用。它使同名的应用风格成为可能，这是一种构建函子计算的便捷方式，并且还提供了表达多种重要模式的方法。
我们将从快速回顾函子类章节开始。Functor 的特征是 fmap 函数
class Functor f where
fmap :: (a -> b) -> f a -> f b
如果一个类型是 Functor 的实例，您可以使用 fmap 将函数应用于其中的值。描述 fmap 的另一种方式是说它提升函数以作用于函子值。为了确保 fmap 正常工作，Functor 的任何实例都必须符合以下两条定律
fmap id = id -- 1st functor law
fmap (g . f) = fmap g . fmap f -- 2nd functor law
例如，Maybe 具有 Functor 实例，因此我们可以轻松地修改其内部的值...
Prelude> fmap negate (Just 2)
Just (-2)
...当然，只要它存在。
Prelude> fmap negate Nothing
Nothing
fmap 有一个中缀同义词，(<$>)。它通常有助于可读性，并且还表明如何将 fmap 看作一种不同类型的函数应用。
Prelude> negate <$> Just 2
Just (-2)
| 练习 |
|---|
|
为以下类型定义
|
fmap 虽然有用，但如果我们想将一个有两个参数的函数应用于函子值，它就无能为力了。例如，我们如何将 Just 2 和 Just 3 相加？蛮力方法是将值从 Maybe 包装器中提取出来。但是，这意味着必须对 Nothing 进行繁琐的检查。更糟糕的是：在不同的 Functor 中，提取值甚至可能不是一种选择（想想 IO）。
我们可以使用 fmap 将 (+) 部分应用于第一个参数
Prelude> :t (+) <$> Just 2
(+) <$> Just 2 :: Num a => Maybe (a -> a)
但现在我们被卡住了：我们有一个函数和一个值都封装在 Maybe 中，并且无法将一个应用于另一个。我们能最接近期望的 Just 5 的方法可能是这个
Prelude> (<$> Just 3) <$> ((+) <$> Just 2)
Just (Just 5)
（注意 (+) <$> Just 2 是 Just (2+)）。
我们想要的是一个类型类似于 f (a -> b) -> f a -> f b 的运算符，以便在函子的上下文中应用函数。如果该运算符被称为 (<*>)，我们就可以写
(+) <$> Just 2 <*> Just 3
瞧，这有效！
Prelude> (+) <$> Just 2 <*> Just 3
Just 5
(<*>) 的类型是
Prelude> :t (<*>)
(<*>) :: Applicative f => f (a -> b) -> f a -> f b
(<*>) 是 Applicative 的方法之一，Applicative 是应用函子的类型类 - 支持在其上下文中应用函数的函子。诸如 (+) <$> Just 2 <*> Just 3 之类的表达式被称为以应用风格编写，这在我们使用函子工作时最接近常规函数应用。如果你暂时假装 (<$>)、(<*>) 和 Just 不存在，我们的示例看起来就像 (+) 2 3。
Applicative 的定义是
class (Functor f) => Applicative f where
pure :: a -> f a
(<*>) :: f (a -> b) -> f a -> f b
除了 (<*>) 之外，该类还具有第二个方法 pure，它将任意值带入函子。例如，让我们看一下 Maybe 实例
instance Applicative Maybe where
pure = Just
(Just f) <*> (Just x) = Just (f x)
_ <*> _ = Nothing
它没有做任何令人惊讶的事情：pure 使用 Just 包装值；(<*>) 将函数应用于值（如果两者都存在），否则会产生 Nothing。
注意
由于缺乏更好的简写，在下文中，我们将使用术语态射来指代位于 (<*>) 左侧的值，它们符合类型 Applicative f => f (a -> b)；也就是说，插入应用函子的类函数的东西。“态射”是一个来自范畴论的术语，它有更广泛的含义，但我们现在不必关心它。
就像 Functor 一样，Applicative 也有一组合理的实例应该遵循的定律。它们是
pure id <*> v = v -- Identity
pure f <*> pure x = pure (f x) -- Homomorphism
u <*> pure y = pure ($ y) <*> u -- Interchange
pure (.) <*> u <*> v <*> w = u <*> (v <*> w) -- Composition
这些定律有点拗口。如果你将 pure 视为以默认的、无特征的方式将值注入函子的方法，这样结果尽可能接近普通值，那么它们就更容易理解了。因此
- 恒等定律指出，应用
pure id态射不会做任何事情，就像使用普通的id函数一样。 - 同态定律指出，将“纯”函数应用于“纯”值与以正常方式将函数应用于值，然后对结果使用
pure相同。从某种意义上说，这意味着pure保留了函数应用。 - 交换定律指出，将态射应用于“纯”值
pure y与将pure ($ y)应用于态射相同。这没什么奇怪的 - 正如我们在高阶函数章节中所见，($ y)是一个函数，它将y作为参数提供给另一个函数。 - 组合律指出，
pure (.)对态射的组合方式类似于(.)对函数的组合方式：将组合态射pure (.) <*> u <*> v应用于w，所得结果与先将v应用于w，再将u应用于结果相同。[1]
关于 fmap 和 (<*>) 之间的关系，还有一个额外定律。
fmap f x = pure f <*> x -- fmap
使用 (<*>) 应用一个 “纯” 函数，等同于使用 fmap。这个定律是其他定律的推论，所以在编写 Applicative 的实例时，无需费心证明它。
| 练习 |
|---|
|
似曾相识
[edit | edit source]pure 是否让你想起了什么？
pure :: Applicative f => a -> f a
它与……
return :: Monad m => a -> m a
… 的唯一区别是类约束。pure 和 return 具有相同的目的，即把值带入函子。这种不可思议的相似之处并没有就此停止。在关于 State 的章节中，我们提到了一个名为 ap 的函数……
ap :: (Monad m) => m (a -> b) -> m a -> m b
… 它可以用来让处理具有多个参数的函数在单子代码中变得不那么痛苦。
allTypes :: GeneratorState (Int, Float, Char, Integer, Double, Bool, Int)
allTypes = liftM (,,,,,,) getRandom
`ap` getRandom
`ap` getRandom
`ap` getRandom
`ap` getRandom
`ap` getRandom
`ap` getRandom
ap 看起来很像 (<*>)。
当然，这些都不是巧合。Monad 继承自 Applicative …
Prelude> :info Monad
class Applicative m => Monad (m :: * -> *) where
--etc.
… 因为 return 和 (>>=) 足以实现 pure 和 (<*>)。[2]
pure = return
(<*>) = ap
ap u v = do
f <- u
x <- v
return (f x)
许多其他单子函数都有更通用的 Applicative 版本。以下是其中几个。
| 单子 | Applicative | 模块 (在哪里可以找到 Applicative 版本) |
|---|---|---|
(>>) |
(*>) |
Prelude (GHC 7.10+)；Control.Applicative |
liftM2 |
liftA2 |
Control.Applicative |
mapM |
traverse |
Prelude (GHC 7.10+)；Data.Traversable |
sequence |
sequenceA |
Data.Traversable |
forM_ |
for_ |
Data.Foldable |
| 练习 |
|---|
|
ZipList
[edit | edit source]列表也是 Applicative 函子。专门针对列表，(<*>) 的类型变为……
[a -> b] -> [a] -> [b]
… 因此 (<*>) 将一个函数列表应用于另一个列表。但究竟是如何实现的呢？
列表的标准 Applicative 实例（源自 Monad 实例）将每个函数应用于每个元素，就像一个爆炸版的 map。
Prelude> [(2*),(5*),(9*)] <*> [1,4,7]
[2,8,14,5,20,35,9,36,63]
有趣的是，还有另一种合理的函数列表应用方法。与其使用每个函数和值的组合，我们可以将每个函数与另一个列表中对应位置的值进行匹配。Prelude 中可以用于此目的的函数是 zipWith。
Prelude> :t zipWith
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
Prelude> zipWith ($) [(2*),(5*),(9*)] [1,4,7]
[2,20,63]
当对于同一个类型存在两种有用的可能实例时，可以通过创建 newtype 来实现其中之一来解决困境。在本例中，我们有 ZipList，它位于 Control.Applicative 中。
newtype ZipList a = ZipList { getZipList :: [a] }
我们已经了解了 <*> 对于 zip 列表应该是什么样子；只需要添加 newtype 包装器。
instance Applicative ZipList where
(ZipList fs) <*> (ZipList xs) = ZipList (zipWith ($) fs xs)
pure x = undefined -- TODO
至于 pure，使用 pure x = ZipList [x] 很诱人，遵循标准列表实例。然而，我们无法这样做，因为它违反了 Applicative 定律。根据恒等律
pure id <*> v = v
替换 (<*>) 和建议的 pure，我们得到
ZipList [id] <*> ZipList xs = ZipList xs
ZipList (zipWith ($) [id] xs) = ZipList xs
现在，假设 xs 是无限列表 [1..]
ZipList (zipWith ($) [id] [1..]) = ZipList [1..]
ZipList [1] = ZipList [1..]
[1] = [1..] -- Obviously false!
问题在于 zipWith 生成的列表长度等于作为参数传递的最短列表的长度，因此 (ZipList [id] <*>) 将在第一个元素之后截断其他 zip 列表中的所有元素。确保 zipWith ($) fs 永远不会删除元素的唯一方法是让 fs 成为无限列表。正确的 pure 来自此结论
instance Applicative ZipList where
(ZipList fs) <*> (ZipList xs) = ZipList (zipWith ($) fs xs)
pure x = ZipList (repeat x)
ZipList Applicative 实例为 Data.List 中的所有 zipN 和 zipWithN 函数提供了一种替代方案，可以扩展到任意数量的参数。
>>> import Control.Applicative
>>> ZipList [(2*),(5*),(9*)] <*> ZipList [1,4,7]
ZipList {getZipList = [2,20,63]}
>>> (,,) <$> ZipList [1,4,9] <*> ZipList [2,8,1] <*> ZipList [0,0,9]
ZipList {getZipList = [(1,2,0),(4,8,0),(9,1,9)]}
>>> liftA3 (,,) (ZipList [1,4,9]) (ZipList [2,8,1]) (ZipList [0,0,9])
ZipList {getZipList = [(1,2,0),(4,8,0),(9,1,9)]}
效果的排序
[edit | edit source]正如我们所见，列表的标准 Applicative 实例将一个列表中的每个函数应用于另一个列表中的每个元素。然而，这并不能明确地指定 (<*>)。为了理解这一点，尝试在不查看上面的示例或下面的答案的情况下，猜一下 [(2*),(3*)]<*>[4,5] 的结果。
Prelude> [(2*),(3*)] <*> [4,5]
--- ...
[8,10,12,15]
除非你非常专注，或者已经分析过 (<*>) 的实现，否则你猜对的可能性大约是 50%。另一种可能性是 [8,12,10,15]。区别在于，对于第一个（也是正确的）答案，结果是通过取第一个列表的骨架，并将每个元素替换为与第二个列表中的元素的所有可能组合来获得的，而对于另一个可能性，起点是第二个列表。
更一般地说，这两个实现之间的区别在于 效果的排序。在这里，效果指的是函子上下文，而不是函子中的值（一些示例：列表的骨架、IO 中执行的现实世界中的动作、Maybe 中值的存在）。对于列表存在两个合法 (<*>) 实现，它们仅在效果排序方面有所不同，这表明 [] 是一个非交换 Applicative 函子。相反，交换 Applicative 函子在效果排序方面不会留下任何歧义。更正式地说，交换 Applicative 函子满足以下条件
liftA2 f u v = liftA2 (flip f) v u -- Commutativity
或者，等效地，
f <$> u <*> v = flip f <$> v <*> u
顺便说一句，如果你在 Haskell 中听说过 交换单子，那么涉及的概念是相同的，只是专门针对 Monad。
交换性（或缺乏交换性）也会影响其他从 (<*>) 派生的函数。(*>) 就是一个明显的例子
(*>) :: Applicative f => f a -> f b -> f b
(*>) 组合效果，同时只保留第二个参数的值。对于单子，它等效于 (>>)。以下是用 Maybe（它是交换的）演示它。
Prelude> Just 2 *> Just 3
Just 3
Prelude> Just 3 *> Just 2
Just 2
Prelude> Just 2 *> Nothing
Nothing
Prelude> Nothing *> Just 2
Nothing
交换参数不会影响效果（即包装值的存亡）。但是，对于 IO，交换参数会重新排序效果
Prelude> (print "foo" *> pure 2) *> (print "bar" *> pure 3)
"foo"
"bar"
3
Prelude> (print "bar" *> pure 3) *> (print "foo" *> pure 2)
"bar"
"foo"
2
在 Haskell 中，惯例是始终使用从左到右的排序来实现 (<*>) 和其他 Applicative 运算符。尽管这个惯例有助于减少混淆，但它也意味着外表有时会具有误导性。例如，(<*) 函数不是 flip (*>)，因为它像 (*>) 一样从左到右排序效果
Prelude> (print "foo" *> pure 2) <* (print "bar" *> pure 3)
"foo"
"bar"
2
出于同样的原因，来自 Control.Applicative 的 (<**>) :: Applicative f => f a -> f (a -> b) -> f b 也不是 flip (<*>)。这意味着它提供了一种反转排序的方法
>>> [(2*),(3*)] <*> [4,5]
[8,10,12,15]
>>> [4,5] <**> [(2*),(3*)]
[8,12,10,15]
另一种选择是来自 transformers 的 Control.Applicative.Backwards 模块，它提供了一个 newtype 用于翻转效果的顺序
newtype Backwards f a = Backwards { forwards :: f a }
>>> Backwards [(2*),(3*)] <*> Backwards [4,5]
Backwards [8,12,10,15]
| 练习 |
|---|
|
Functor，Applicative，Monad。三个密切相关的函子类型类；Haskell 中最重要的三个类。尽管我们已经看到了许多Functor和Monad的使用示例，以及一些Applicative的示例，但我们还没有将它们进行正面比较。如果我们暂时忽略pure/return，这三个类的特征方法是
fmap :: Functor f => (a -> b) -> f a -> f b
(<*>) :: Applicative f => f (a -> b) -> f a -> f b
(>>=) :: Monad m => m a -> (a -> m b) -> m b
虽然这些类型看起来不同，但我们可以通过一些美观的调整来改变这种局面。让我们用它的中缀同义词(<$>)替换fmap；用它的反转版本(=<<)替换(>>=)；并整理一下签名
(<$>) :: Functor t => (a -> b) -> (t a -> t b)
(<*>) :: Applicative t => t (a -> b) -> (t a -> t b)
(=<<) :: Monad t => (a -> t b) -> (t a -> t b)
突然之间，相似之处令人注目。fmap，(<*>)和(=<<)都是将函数映射到Functor上[3]。它们之间的区别在于每种情况下映射的内容
fmap将任意函数映射到函子上。(<*>)将t (a -> b)态射映射到（应用）函子上。(=<<)将a -> t b函数映射到（单子）函子上。
Functor，Applicative和Monad在日常使用中的差异源于这三个映射函数的类型允许你做什么。当你从fmap移动到(<*>)，然后移动到(>>=)时，你会获得更多力量、多功能性和控制，但代价是结果的保证。我们现在将沿着这个尺度滑动。在这样做的过程中，我们将使用对比的术语值和上下文来分别指代函子中的普通值和它们周围的一切。
fmap的类型以及与之相关的两个定律确保无论给它什么函数，都无法用它来改变上下文。在(a -> b) -> t a -> t b中，(a -> b)函数与t a函子值的t上下文无关，因此应用它不会影响上下文。因此，如果你对某个列表xs执行fmap f xs，列表的元素个数永远不会改变。
Prelude> fmap (2*) [2,5,6]
[4,10,12]
这可以被视为一项安全保证，也可以被视为不幸的限制，这取决于你的意图。无论如何，(<*>)显然能够改变上下文
Prelude> [(2*),(3*)] <*> [2,5,6]
[4,10,12,6,15,18]
t (a -> b)态射本身带有上下文，该上下文与t a函子值的上下文相结合。然而，(<*>)受到更微妙的限制。虽然t (a -> b)态射带有上下文，但其中有普通(a -> b)，它们仍然无法修改上下文。这意味着(<*>)对上下文执行的更改完全由其参数的上下文决定，而值对结果上下文没有影响。
Prelude> (print "foo" *> pure (2*)) <*> (print "bar" *> pure 3)
"foo"
"bar"
6
Prelude> (print "foo" *> pure 2) *> (print "bar" *> pure 3)
"foo"
"bar"
3
Prelude> (print "foo" *> pure undefined) *> (print "bar" *> pure 3)
"foo"
"bar"
3
因此，使用列表(<*>)，你知道结果列表的长度将是原始列表长度的乘积，使用IO (<*>)，你知道只要评估终止，所有真实世界的效果都会发生，等等。
然而，使用Monad，我们参与的是一场非常不同的游戏。(>>=)采用a -> t b函数，因此它能够从值中创建上下文。这意味着很大的灵活性
Prelude> [1,2,5] >>= \x -> replicate x x
[1,2,2,5,5,5,5,5]
Prelude> [0,0,0] >>= \x -> replicate x x
[]
Prelude> return 3 >>= \x -> print $ if x < 10 then "Too small" else "OK"
"Too small"
Prelude> return 42 >>= \x -> print $ if x < 10 then "Too small" else "OK"
"OK"
然而，利用额外的灵活性可能意味着对某些方面有更少的保证，例如你的函数是否能够意外地删除病态输入的数据结构的部分，或者你的应用程序中的控制流是否保持清晰。在某些情况下，也可能存在性能影响，因为单子代码可能导致复杂的数据依赖关系，这可能会阻止有用的重构和优化。总而言之，最好只使用完成手头任务所需的权力。如果你确实需要Monad的额外功能，那就继续使用它；然而，通常值得检查Applicative或Functor是否足够。
| 练习 |
|---|
|
接下来的几个练习涉及以下树数据结构
|
回到理解单子，我们看到了如何使用(>=>)或join而不是(>>=)来指定Monad类。以类似的方式，Applicative也有一个替代表示法，可以通过以下类型类实现
class Functor f => Monoidal f where
unit :: f ()
(*&*) :: f a -> f b -> f (a,b)
在名称“单子”背后有深刻的理论原因[4]。无论如何，我们可以非正式地说它看起来非常像一个幺半群：unit提供一个默认的函子值，其上下文不包含任何有趣的内容，(*&*)通过将值配对并将效果组合来组合函子值。Monoidal公式更清楚地展示了Applicative如何操作函子上下文。当然，unit和(*&*)可以用来定义pure和(<*>)，反之亦然。
Applicative定律等效于以下定律集，这些定律是用Monoidal表示的
fmap snd $ unit *&* v = v -- Left identity
fmap fst $ u *&* unit = u -- Right identity
fmap asl $ u *&* (v *&* w) = (u *&* v) *&* w -- Associativity
-- asl (x, (y, z)) = ((x, y), z)
($)左侧的函数只是将等效类型（例如b和((), b)）相互转换的样板。如果你忽略它们，这些定律比通常的Applicative公式中的定律不那么不透明。顺便说一句，就像Applicative一样，还有一个额外的定律，它保证在 Haskell 中成立
fmap (g *** h) (u *&* v) = fmap g u *&* fmap h v -- Naturality
-- g *** h = \(x, y) -> (g x, h y)
| 练习 |
|---|
|
注意
- ↑
(.)和普通函数的对应属性是(u . v) w = u (v w)。 - ↑ 如果
Monad实例遵循单子定律，那么生成的pure和(<*>)将自动遵循应用定律。 - ↑ 这不仅仅是类型签名彼此相似的问题：这种相似性具有理论基础。连接的一个方面是，所有三个类型类都具有恒等式和组合定律绝非偶然。
- ↑ 有关更多详细信息，请关注Typeclasseopedia 中相应部分和Edward Z. Yang 的博客文章的线索，该文章启发了它。