Scala Future[A] 和 Future[Option[B]] 组合

Question

我有一个管理Items 的应用程序。当客户端通过一些info 查询项目时，应用程序首先尝试使用该信息在数据库中查找现有项目。如果没有，应用程序会

1. 检查info 是否有效。这是一项代价高昂的操作（比数据库查找要贵得多），因此应用仅在数据库中不存在现有项目时执行此操作。

2. 如果info 有效，则将新的Item 插入到带有info 的数据库中。

还有两个类，ItemDao 和 ItemService：

object ItemDao {
  def findByInfo(info: Info): Future[Option[Item]] = ...

  // This DOES NOT validate info; it assumes info is valid
  def insertIfNotExists(info: Info): Future[Item] = ...
}

object ItemService {
  // Very expensive
  def isValidInfo(info: Info): Future[Boolean] = ...

  // Ugly
  def findByInfo(info: Info): Future[Option[Item]] = {
    ItemDao.findByInfo(info) flatMap { maybeItem =>
      if (maybeItem.isDefined)
        Future.successful(maybeItem)
      else
        isValidInfo(info) flatMap {
          if (_) ItemDao.insertIfNotExists(info) map (Some(_))
          else Future.successful(None)
        }
    }
  }
}

ItemService.findByInfo(info: Info) 方法非常丑陋。我一直在尝试清理它一段时间，但这很困难，因为涉及三种类型（Future[Boolean]、Future[Item] 和Future[Option[Item]]）。我尝试使用scalaz 的OptionT 来清理它，但非可选的Futures 也不太容易。

关于更优雅的实现有什么想法吗？

Answer 1

扩展我的评论。

既然您已经表示愿意沿着单子转换器的路线走下去，那么这应该可以满足您的需求。不幸的是，由于 Scala 在这里的类型检查不那么出色，因此存在相当多的线路噪音，但希望您发现它足够优雅。

import scalaz._
import Scalaz._

object ItemDao {
  def findByInfo(info: Info): Future[Option[Item]] = ???

  // This DOES NOT validate info; it assumes info is valid
  def insertIfNotExists(info: Info): Future[Item] = ???
}

object ItemService {
  // Very expensive
  def isValidInfo(info: Info): Future[Boolean] = ???

  def findByInfo(info: Info): Future[Option[Item]] = {
    lazy val nullFuture = OptionT(Future.successful(none[Item]))
    lazy val insert = ItemDao.insertIfNotExists(info).liftM[OptionT]
    lazy val validation = 
      isValidInfo(info)
        .liftM[OptionT]
        .ifM(insert, nullFuture)
    val maybeItem = OptionT(ItemDao.findByInfo(info))
    val result = maybeItem <+> validation
    result.run
  }
}

关于代码的两个cmets：

• 我们在这里使用OptionT monad 转换器来捕获Future[Option[_]] 的东西和任何存在于Future[_] 中的东西，我们是liftMing，直到我们的OptionT[Future, _] monad。
• <+> 是MonadPlus 提供的操作。简而言之，顾名思义，MonadPlus 捕捉到了 monad 通常具有直观组合方式的直觉（例如List(1, 2, 3) <+> List(4, 5, 6) = List(1, 2, 3, 4, 5, 6)）。在这里，我们使用它在findByInfo 返回Some(item) 时进行短路，而不是在None 上进行短路的通常行为（这大致类似于List(item) <+> List() = List(item)）。

其他小提示，如果你真的想走 monad 转换器路线，通常你最终会在你的 monad 转换器中构建所有东西（例如ItemDao.findByInfo 会返回一个OptionT[Future, Item]），这样你就没有多余的东西了OptionT.apply 调用，然后.run 结束。

Answer 2

你不需要 scalaz 。只需将您的 flatMap 分为两个步骤： 首先，查找并验证，然后在必要时插入。像这样的：

ItemDao.findByInfo(info).flatMap { 
    case None => isValidInfo(info).map(None -> _)
    case x => Future.successful(x -> true)
}.flatMap { 
  case (_, true) => ItemDao.insertIfNotExists(info).map(Some(_))
  case (x, _) => Future.successful(x)
}  

看起来还不错吧？如果您不介意与检索并行运行验证（资源虎钳稍微贵一些，但平均而言可能更快），您可以像这样进一步简化它：

ItemDao
  .findByInfo(info)
  .zip(isValidInfo(info))
  .flatMap {
    case (None, true) => ItemDao.insertIfNotExists(info).map(Some(_))
    case (x, _) => x
  }

另外，如果项目确实存在，insertIfNotExists 会返回什么？如果它返回现有项目，事情可能会更简单：

 isValidInfo(info)
   .filter(identity)
   .flatMap { _ => ItemDao.insertIfNotExists(info) }
   .map { item => Some(item) }  
   .recover { case _: NoSuchElementException => None }

Answer 3

如果您对依赖路径的类型和更高类型的类型感到满意，那么类似以下的解决方案可能是一个优雅的解决方案：

type Const[A] = A

sealed trait Request {
  type F[_]
  type A
  type FA = F[A]

  def query(client: Client): Future[FA]
}

case class FindByInfo(info: Info) extends Request {
  type F[x] = Option[x]
  type A = Item

  def query(client: Client): Future[Option[Item]] = ???
}

case class CheckIfValidInfo(info: Info) extends Request {
  type F[x] = Const[x]
  type A = Boolean

  def query(client: Client): Future[Boolean] = ???
}

class DB {
  private val dbClient: Client = ???
  def exec(request: Request): request.FA = request.query(dbClient)
}

这基本上是对包装类型（例如Option[_]）和内部类型进行抽象。对于没有包装类型的类型，我们使用Const[_] 类型，它基本上是一个标识类型。

在 Scala 中，许多类似的问题都可以使用代数数据类型及其高级类型系统（即路径相关类型和更高种类的类型）优雅地解决。请注意，现在我们有了单点入口 exec(request: Request) 来执行数据库请求，而不是像 DAO 这样的东西。