Scala 使用类似的形状运行顺序期货，用于理解

其中，

T

只是一个特定类型，并且该类型对于两个函数都是相同的。现在func2取决于first

func

未来的成功。因此，只有在

func

成功完成后，才能按顺序运行

func2

。我想要一个

，用于理解类似于下面一行的内容（以下是无效的可编译代码），并返回
Future[\/[Throwable，Unit]]

def func1(list : List[T]) : Future[\/[Throwable,Unit] ]
def func2(list : List[T]) : Future[List[\/[Throwable,Unit]]]

def func3组合器（列表）：未来[\/[Throwable，Unit]]=for{
u因为期货要么包含一个值，要么包含一个例外，你就不需要这个值（或者你有其他理由使用它吗？）。
运行此代码将有助于您（以及阅读）：

导入scala.concurrent_
导入ExecutionContext.Implicits.global
def f1（l:List[Int]）：Future[Int]=Future{println（“f1”）；l head}
def f2（l:List[Int]）：Future[Int]=Future{println（“f2”）；抛出新异常（“bang”）}
def f3（l:List[Int]）：Future[Int]=Future{println（“f3”）；l last}
val result1=用于{
x1
def func3 combiner(list) : Future[\/[Throwable,Unit] ] = for{
  u <- func1(list)
  us <- u
  d <- func2(list)
}yield

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

def f1(l: List[Int]): Future[Int] = future { println("f1"); l head }
def f2(l: List[Int]): Future[Int] = future { println("f2"); throw new Exception("bang") }
def f3(l: List[Int]): Future[Int] = future { println("f3"); l last }

val result1 = for {
  x1 <- f2(List(1, 2))
  x2 <- f1(List(1, 2)) // f1 is not run
} yield x2

val result2 = for {
  x1 <- f1(List(1, 2))
  x3 <- f3(List(1, 2))
} yield x3

result1.onComplete(res => println("result1 = " + res))
result2.onComplete(res => println("result2 = " + res))