以函数式方式进行多个 API 调用

Question

使用 Scala 和 Cats（或者可能是另一个专注于范畴论和/或函数式编程的库）以最实用（代数）的方式解决这个问题的最佳方法是什么？

资源

如果我们有以下方法来执行 REST API 调用以检索单条信息？

type FutureApiCallResult[A] = Future[Either[String, Option[A]]]

def getNameApiCall(id: Int): FutureApiCallResult[String]
def getAgeApiCall(id: Int): FutureApiCallResult[Int]
def getEmailApiCall(id: Int): FutureApiCallResult[String]

如您所见，它们会产生异步结果。 Either monad 用于在 API 调用期间返回可能的错误，Option 用于在 API 未找到资源时返回 None（这种情况不是错误，而是可能的和期望的结果类型）。

以函数方式实现的方法

case class Person(name: String, age: Int, email: String)

def getPerson(id: Int): Future[Option[Person]] = ???

此方法应使用上面定义的三个 API 调用方法异步组合并返回 Person 或 None 如果任何 API 调用失败或任何 API 调用返回 None（整个 Person 实体无法组合）

要求

出于性能原因，所有 API 调用都必须以并行方式完成

我的猜测

我认为最好的选择是使用 Cats Semigroupal Validated，但是在尝试处理 Future 和这么多嵌套的 Monad 时我迷路了：S

谁能告诉我你将如何实现这个（即使改变方法签名或主要概念）或指向正确的资源？我对 Cats 和 Algebra 在编码方面很陌生，但我想学习如何处理这种情况，以便我可以在工作中使用它。

Answer 1

这里的关键要求是必须并行完成。这意味着使用 monad 的明显解决方案已经出局，因为 monadic bind 是阻塞的（它需要结果以防它必须在其上分支）。所以最好的选择是使用applicative。

我不是 Scala 程序员，所以我无法向您展示代码，但其想法是应用函子可以提升多个参数的函数（常规函子使用 map 提升单个参数的函数）。在这里，您将使用类似map3 的东西来提升Person 的三参数构造函数以处理三个FutureResults。搜索“在 Scala 中应用的未来”会返回一些命中。 Either 和 Option 也有应用程序实例，并且与 monad 不同，应用程序可以轻松组合在一起。希望这会有所帮助。

Answer 2

您可以使用cats.Parallel 类型类。这使得一些非常简洁的组合器与EitherT 并行运行时会累积错误。所以最简单和最简洁的解决方案是这样的：

type FutureResult[A] = EitherT[Future, NonEmptyList[String], Option[A]]

def getPerson(id: Int): FutureResult[Person] = 
  (getNameApiCall(id), getAgeApiCall(id), getEmailApiCall(id))
    .parMapN((name, age, email) => (name, age, email).mapN(Person))

有关Parallel的更多信息，请访问cats documentation。

编辑：这是没有内部Option的另一种方式：

type FutureResult[A] = EitherT[Future, NonEmptyList[String], A]

def getPerson(id: Int): FutureResult[Person] = 
  (getNameApiCall(id), getAgeApiCall(id), getEmailApiCall(id))
    .parMapN(Person)

Answer 3

这是我遇到的唯一解决方案，但仍然不满意，因为我觉得它可以以更清洁的方式完成

import cats.data.NonEmptyList
import cats.implicits._

import scala.concurrent.Future

case class Person(name: String, age: Int, email: String)

type FutureResult[A] = Future[Either[NonEmptyList[String], Option[A]]]

def getNameApiCall(id: Int): FutureResult[String] = ???
def getAgeApiCall(id: Int): FutureResult[Int] = ???
def getEmailApiCall(id: Int): FutureResult[String] = ???

def getPerson(id: Int): FutureResult[Person] =
(
  getNameApiCall(id).map(_.toValidated),
  getAgeApiCall(id).map(_.toValidated),
  getEmailApiCall(id).map(_.toValidated)
).tupled // combine three futures
  .map {
    case (nameV, ageV, emailV) =>
      (nameV, ageV, emailV).tupled // combine three Validated
        .map(_.tupled) // combine three Options
        .map(_.map { case (name, age, email) => Person(name, age, email) })   // wrap final result
  }.map(_.toEither)

Answer 4

就我个人而言，我更喜欢将所有不成功的条件都归结为 Future 的失败。这确实简化了错误处理，例如：

val futurePerson = for {
  name  <- getNameApiCall(id)
  age   <- getAgeApiCall(id)
  email <- getEmailApiCall(id)
} yield Person(name, age, email)

futurePerson.recover {
  case e: SomeKindOfError => ???
  case e: AnotherKindOfError => ???
}

请注意，这不会并行运行请求，为此您需要将未来的创建移到 for 理解之外，例如：

val futureName = getNameApiCall(id)
val futureAge  = getAgeApiCall(id)
val futureEmail = getEmailApiCall(id)

val futurePerson = for {
  name  <- futureName
  age   <- futureAge
  email <- futureEmail
} yield Person(name, age, email)