如何使用 Applicative 进行并发？

Question

这是我之前的question 的后续。我从Haxl复制了下面的示例

假设我正在从博客服务器获取数据以呈现博客页面，其中包含最近的帖子、热门帖子和帖子主题。

我有以下数据获取 API：

val getRecent  : Server => Seq[Post] = ...
val getPopular : Server => Seq[Post] = ...
val getTopics  : Server => Seq[Topic] = ...

现在我需要组合它们来实现一个新功能getPageData

val getPageData: Server => (Seq[Post],  Seq[Post], Seq[Topic])

Haxl 建议使用新的 monad Fetch 使 API 可组合。

val getRecent  : Fetch[Seq[Posts]] = ...
val getPopular : Fetch[Seq[Posts]] = ...
val getTopics  : Fetch[Seq[Topic]] = ...

现在我可以用 monadic 组合定义我的getPageData: Fetch[A]

val getPageData = for {
  recent  <- getRecent
  popular <- getPopular
  topics  <- getTopics
} yield (recent, popular, topics)

但它不会同时运行 getRecent、getPopular 和 getTopics。

Haxl 建议使用 applicative 组合 <*> 组合“并发”函数（即可以同时运行的函数）。所以我的问题是：

• 假设Fetch[A] 是Applicative，如何实现getPageData？
• 如何将Fetch 实现为Applicative 而不是Monad？

Answer 1

假设 Fetch[A] 是一个 Applicative ，如何实现 getPageData ？

我们需要做的就是放弃一元绑定>>=，转而使用应用<*>。所以不是

val getPageData = for {
  recent  <- getRecent
  popular <- getPopular
  topics  <- getTopics
} yield (recent, popular, topics)

我们会写一些类似的东西（用 Haskell 语法；抱歉，我不能在头脑中使用 Scala）：

getPageData = makeTriple <$> getRecent <*> getPopular <*> getTopics
  where
    makeTriple x y z = (x, y, z)

但这是否达到预期的效果取决于第二个问题！

如何将 Fetch 实现为 Applicative 而不是 Monad？

monadic 和 applicative 排序之间的主要区别在于，monadic 可以依赖于 monadic 值中的值，而 applicative <*> 不能。请注意上面getPageData 的一元表达式如何在到达getTopics 之前绑定名称recent 和popular。这些名称​​可以用于更改表达式的结构，例如在recent 为空的情况下获取其他数据源。但是对于应用表达式，getRecent 和getPopular 的结果不是表达式本身结构的因素。这个属性允许我们同时触发应用表达式中的每个项，因为我们静态地知道表达式的结构。

因此，使用上面的观察结果，显然是 Fetch 数据类型的特殊形状，我们可以为<*> 提出一个合适的定义。我认为以下内容说明了总体思路：

data Fetch a = Fetch { runFetch :: IO a }

fetchF <*> fetchX = Fetch $ do
  -- Fire off both IOs concurrently.
  resultF <- async $ runFetch fetchF
  resultX <- async $ runFetch fetchX
  -- Wait for both results to be ready.
  f <- wait resultF
  x <- wait resultX
  return $ f x

为了比较，假设我们尝试使用并发评估进行单子绑定：

fetchF >>= fetchK = Fetch $ do
  resultF <- async $ runFetch fetchF
  -- Oh no, we need resultF in order to produce the next
  -- Fetch value! We just have to wait...
  f <- wait resultF
  fetchX <- async $ runFetch (fetchK f)
  x <- wait $ runFetch fetchX
  return $ f x