scala func中处理选项未来的干净方法

Question

我有一些简单的枚举名：失败/成功的结果

sealed trait Result

case object Success extends Result

case object Fail extends Result

我有一个函数，它什么也没有得到，但返回未来的结果，

def do(): Future[Result] = {

    someService.getInfo() flatMap { responseInfo =>
      responseInfo.fold(Future.successful[Result](Result)) { info =>
       myDB.getData(info.resId) map { dbRes =>
            if (dbRes.isSomething) Fail else Success
        } recover {
           case e: NotFoundException => Fail
         }
      }
    }
}

我不喜欢我的解决方案，它看起来很凌乱，有更简单的吗？

someService.getInfo返回未来[选项[响应信息]]

我想在这里做的是，如果一些Service.getInfo返回None，那么func应该返回Future[Fail]，否则调用db，这也返回一个case类的未来，并基于响应返回Fail/Success。

但我正在寻找一种超级时尚的斯卡拉方式，让它看起来不错:)

谢谢

Answer 1

您正在创建成功和失败的新概念，scala.concurrent.Future已经有了，所以您正在做的事情毫无意义。

你有你想要的所有失败状态表示，因为在一个< code>Future里面隐藏了一个< code>scala.util.Try，所以你已经可以< code>match，< code>fold等等，任何其他正常的流控制方法都在那里。

def do(): Future[Option[DbResult]] = {

    someService.getInfo() flatMap { responseInfo =>
      responseInfo.fold(Future.successful(_)) { info =>
       myDB.getData(info.resId) map { dbRes =>
            if (dbRes.isSomething) Some(dbRes) else None
        } recover {
           case e: NotFoundException => Future.failed(e)
        }
      }
    }
}

将概念混为一谈也不是一个好主意。例如，在给定查询的数据库中“找不到”结果是一种非常有效的状态，它与你失败的未来无关。

将来的失败应该代表网络故障、格式错误的查询等，而不是数据库正确返回没有结果的有效往返。因此，您可以使用Option。

莫纳德变压器

这是一个将< code>G[F[_]]转换为< code>F[G[_]]的一般性问题，其中需要处理包装类型的有趣组合。说出< code >期货[期权[T]]到< code >期权[期货[T]]。处理这种东西的函数式方法有点麻烦，但是值得。

import cats.data.OptionT
import cats.std.future._

def do() = {
  val chain = for {
    info <- OptionT(someService.getInfo())
    data <- OptionT(myDB.getData(info.resId) map { dbRes =>
            if (dbRes.isSomething) Some(dbRes) else None
        } recover {
           case e: NotFoundException => Future.failed(e)
        })
  } yield data

  chain.value
}

它看起来与上面相似。在此处阅读有关OptionT的更多信息，但它看起来像您想要的。