为什么fmap f xs =纯f <*> xs？

Question

class Functor f => Applicative f where
       pure :: a -> f a
       (<*>) :: f (a -> b) -> f a -> f b

“纯”扮演两个角色：
*具有0元函数时的简并情况。
* fmap f xs =纯f <*> xs

我不明白为什么

fmap f xs = pure f <*> xs

我的意思是pure应该取a并返回fa 。 但是pure f做什么？ 甚至pure (f <*> xs)对我来说也是有意义的。

Answer 1

也许一个具体的例子是说明性的。 以适用列表为准。 <*>将每个函数从其左侧操作数应用于其右侧的每个值：

fs <*> xs = [f x | f <- fs, x <- xs]

pure将值包装在单例列表中：

pure (+ 1) = [(+ 1)]

因此， pure f <*> xs = fmap f xs ，因为<*>将每个函数（恰好只有一个）应用于每个值，而fmap将一个函数应用于每个值：

pure (+ 1) <*> [1, 2, 3]
=
[(+ 1)] <*> [1, 2, 3]
=
[f x | f <- [(+ 1)], x <- [1, 2, 3]]
=
[(+ 1) x | x <- 1, 2, 3]
=
[x + 1 | x <- 1, 2, 3]
=
[2, 3, 4]


fmap (+ 1) [1, 2, 3]
=
[(+ 1) x | x <- [1, 2, 3]]
=
[x + 1 | x <- [1, 2, 3]]
=
[2, 3, 4]

这也是<$>和<*>运算符如何共同作用，以对多个操作的结果应用多参数函数，例如：

(*) <$> [1..5] <*> [1..5]
=
((*) <$> [1..5]) <*> [1..5]
=
[(1 *), (2 *), (3 *), (4 *), (5 *)] <*> [1..5]
=
[ (1 *) 1, (2 *) 1, (3 *) 1, (4 *) 1, (5 *) 1
, (1 *) 2, (2 *) 2, (3 *) 2, (4 *) 2, (5 *) 2
, (1 *) 3, (2 *) 3, (3 *) 3, (4 *) 3, (5 *) 3
, (1 *) 4, (2 *) 4, (3 *) 4, (4 *) 4, (5 *) 4
, (1 *) 5, (2 *) 5, (3 *) 5, (4 *) 5, (5 *) 5
]
=
[ 1,  2,  3,  4,  5
, 2,  4,  6,  8, 10
, 3,  6,  9, 12, 15
, 4,  8, 12, 16, 20
, 5, 10, 15, 20, 25
]

也可以将其写为pure (*) <*> [1..5] <*> [1..5] 。

<$>建立一个操作（在本例中为列表），该操作返回（包含）部分应用的函数，而<*>接受这些函数并将其应用于参数。 （并且，如果函数接受两个以上的参数，那么这还可能导致部分应用的函数，而该函数可以通过<*>另一个应用程序应用于更多的参数。）

其他“类似容器的”应用程序（例如Maybe或Either e （对于某些e ））以及“类似动作”的应用程序（例如IO ， Cont r或Async 。

Answer 2

但是pure f做什么？

给定f :: a -> b ，我们得到pure f :: f (a -> b) ，最后一个f是任何应用函子。 这将创建一个正确类型的值作为第一个参数传递给

(<*>) :: f (a -> b) -> f a -> f b

我的意思是说pure应该取a并返回fa

没错-在这种情况下， a你提到的是函数类型a -> b我上面提到的。