Scala 如何将嵌套的未来排除在选项之外？

我无法专心解决

def finalFuture（）：Future[选项[（A1，选项[B1]）]]

。在下面的代码中，它返回嵌套的Future和Option，并出现以下错误：

Error:(36, 5) type mismatch;
 found   : scala.concurrent.Future[Option[scala.concurrent.Future[Option[(A1, Option[B1])]]]]
 required: scala.concurrent.Future[Option[(A1, Option[B1])]]
    res
    ^

代码：

当num为

8

时失败，即无论何时

innerFuture

失败，都会导致异常无法在monad中正确捕获：

5
None
6
Some((A1(6),None))
7
8
Some((A1(7),Some(B1(14))))
neither 6 nor 7
Exception in thread "main" java.lang.RuntimeException: neither 6 nor 7
    at NestedExample$$anonfun$innerFuture$1.apply(NestedExample.scala:30)
    at NestedExample$$anonfun$innerFuture$1.apply(NestedExample.scala:27)
    at scala.concurrent.impl.Future$PromiseCompletingRunnable.liftedTree1$1(Future.scala:24)
    at scala.concurrent.impl.Future$PromiseCompletingRunnable.run(Future.scala:24)
    at scala.concurrent.impl.ExecutionContextImpl$AdaptedForkJoinTask.exec(ExecutionContextImpl.scala:121)
    at scala.concurrent.forkjoin.ForkJoinTask.doExec(ForkJoinTask.java:260)
    at scala.concurrent.forkjoin.ForkJoinPool$WorkQueue.runTask(ForkJoinPool.java:1339)
    at scala.concurrent.forkjoin.ForkJoinPool.runWorker(ForkJoinPool.java:1979)
    at scala.concurrent.forkjoin.ForkJoinWorkerThread.run(ForkJoinWorkerThread.java:107)

对于

finalFuture1（8）

来说，结果应该是

Some（（A1（8），None））

更新2

fallbackTo

让一切顺利

  def finalFuture1(num: Int): Future[Option[(A1, Option[B1])]] = {
    val f1 = outerFuture(num)
    val res = f1 flatMap { aOpt =>
      val x = aOpt.map { a =>
        val f2 = innerFuture(a.id)
        val q = f2.map { bOpt =>
          val w: Option[(A1, Option[B1])] = bOpt.map(x => (a, Some(x)))
          val e = w.orElse(Some((a, None)))
          e
        }
        q.fallbackTo(Future(Some((a, None))))
      }
      x.getOrElse(Future.successful(None))
    }
    res.fallbackTo(Future(None))
  }


  def finalFuture2(num: Int): Future[Option[(A1, Option[B1])]] = {
    val f1 = for {
      o1 <- outerFuture(num)
      o2 <- {
        o1 match {
          case Some(a) =>
            innerFuture(a.id)
              .map(b => Some(a, b))
              .fallbackTo(Future(Some((a, None))))
          case None => Future(None)
        }
      }
    } yield o2
    f1.fallbackTo(Future(None))
  }

def finalFuture1（num:Int）：未来[选项[（A1，选项[B1]）]={
val f1=外部未来（num）
val res=f1平面图{aOpt=>
valx=aOpt.map{a=>
val f2=内部未来（a.id）
valq=f2.map{bOpt=>
val w:Option[（A1，Option[B1]）]=bOpt.map（x=>（a，Some（x）））
val e=w.orElse（部分（（a，无）））
E
}
q、 回退到（未来（一些（（a，无）））
}
x、 getOrElse（Future.successful（无））
}
res.fallbackTo（未来（无））
}
def finalFuture2（num:Int）：未来[选项[（A1，选项[B1]）]={
val f1=用于{
o1部分（a，b））
.fallbackTo（未来（一些（（a，无）））
案例无=>未来（无）
}
}
}产氧量
f1.回退（未来（无））
}

---

但是我想知道它是否能变得更漂亮？

也许这就是你想要做的：

def finalFuture(): Future[Option[(A1, Option[B1])]] = 
  for (
    o1 <- outerFuture();
    o2 <- o1 match {
      case Some(a) => innerFuture(a.id).map(b => Some(a, b))
      case _ => Future(None)
      }
  ) yield o2

def finalFuture（）：未来[选项[（A1，选项[B1]）]=
为了(
o1部分（a，b））
案例=>未来（无）
}
)产氧量

我想这个应该可以用，因为当你使用Option.map（Future[]]时，如果没有，它的类型可能会变得疯狂

这应该行得通

import scala.concurrent._
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._

case class A1(val id: Int)

case class B1(val id: Int)

object NestedExample {

  def outerFuture(): Future[Option[A1]] = {
    Future {
      Some(A1(id = 0))
    }
  }

  def innerFuture(num: Int): Future[Option[B1]] = {
    Future {
      if (num < 10) Some(B1(0)) else None
    }
  }

  def finalFuture(): Future[Option[(A1, Option[B1])]] = {
    val f1 = outerFuture()

    val res = f1.flatMap(o1 => {
      o1.map { a =>
        val f2 = innerFuture(a.id)
        val q = f2.map { bOpt =>
          val w:Option[(A1, Option[B1])] = bOpt.map(x => (a, Some(x)))
          val e = w.orElse(Some((a, None)))
          e
        }
        q
      }.getOrElse(Future.successful(None))
    })

    res
  }

  def main(args: Array[String]): Unit = {
    val ff = finalFuture()
    ff.onSuccess { case x => println(x) }
    ff.onFailure { case x => println(x) }
    Await.result(ff, 5 seconds)
  }

导入scala.concurrent_
导入scala.concurrent.ExecutionContext.Implicits.global
导入scala.concurrent.duration_
案例类别A1（val id:Int）
案例类别B1（val id:Int）
对象嵌套示例{
def outerFuture（）：未来[选项[A1]={
未来{
一些（A1（id=0））
}
}
def innerFuture（num:Int）：未来[选项[B1]={
未来{
如果（num<10）一些（B1（0））其他无
}
}
def finalFuture（）：未来[选项[（A1，选项[B1]）]={
val f1=外部未来（）
val res=f1.flatMap（o1=>{
o1.map{a=>
val f2=内部未来（a.id）
valq=f2.map{bOpt=>
val w:Option[（A1，Option[B1]）]=bOpt.map（x=>（a，Some（x）））
val e=w.orElse（部分（（a，无）））
E
}
Q
}.getOrElse（Future.successful（无））
})
物件
}
def main（参数：数组[字符串]）：单位={
val ff=最终未来（）
ff.onSuccess{case x=>println（x）}
ff.onFailure{case x=>println（x）}
等待结果（ff，5秒）
}

让你走的代码，嗯？你可能应该表达你在尝试什么，因为代码看起来有点凌乱。请检查更新的代码。我从你的解决方案中得到了很好的指导。你的解决方案对于快乐的道路来说非常酷。但是我不确定它是否能正确地适用于悲伤的道路，即未来不成功的时候。这适用于e快乐的路径，但不是悲伤的路径。如果innerFuture失败，解决方案是不正确的。感谢您的解决方案。是的，应该有恢复，但参数不匹配应该得到修复。类型不匹配得到修复，您的解决方案给了我很好的提示：-）

def finalFuture(): Future[Option[(A1, Option[B1])]] = 
  for (
    o1 <- outerFuture();
    o2 <- o1 match {
      case Some(a) => innerFuture(a.id).map(b => Some(a, b))
      case _ => Future(None)
      }
  ) yield o2

import scala.concurrent._
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._

case class A1(val id: Int)

case class B1(val id: Int)

object NestedExample {

  def outerFuture(): Future[Option[A1]] = {
    Future {
      Some(A1(id = 0))
    }
  }

  def innerFuture(num: Int): Future[Option[B1]] = {
    Future {
      if (num < 10) Some(B1(0)) else None
    }
  }

  def finalFuture(): Future[Option[(A1, Option[B1])]] = {
    val f1 = outerFuture()

    val res = f1.flatMap(o1 => {
      o1.map { a =>
        val f2 = innerFuture(a.id)
        val q = f2.map { bOpt =>
          val w:Option[(A1, Option[B1])] = bOpt.map(x => (a, Some(x)))
          val e = w.orElse(Some((a, None)))
          e
        }
        q
      }.getOrElse(Future.successful(None))
    })

    res
  }

  def main(args: Array[String]): Unit = {
    val ff = finalFuture()
    ff.onSuccess { case x => println(x) }
    ff.onFailure { case x => println(x) }
    Await.result(ff, 5 seconds)
  }