使用Scala期货按顺序执行依赖项

我有一个任务运行程序，如下所示

package taskman

import scala.concurrent.{Await, Future}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._

final class Task private (
    desc: String,
    dependencies: Seq[Task] = Seq.empty[Task],
    body: => Unit
) {

  def run(): Future[Unit] = Future {
//    println(s"Executing dependencies for $desc")
    Future
      .sequence(dependencies.map(_.run()))
      .map { _ => body }
  }
}

object Task {
  def task(desc: String, dependencies: Seq[Task] = List.empty[Task])(
      body: => Unit
  ): Task =
    new Task(desc, dependencies, body)
}

object taskTest extends App {
  import Task._

  val boilWater = task("Boil water") {
    println("Boiling water ")
  }

  val boilMilk = task("Boil milk") {
    println("Boiling milk")
  }

  val mixWaterAndMilk =
    task("Mix milk and water", Seq(boilWater, boilMilk)) {
      println("Mixing milk and water")
    }

  val addCoffeePowder = task("Add coffee powder", Seq(mixWaterAndMilk)) {
    println("Adding coffee powder")
  }

  val addSugar = task("Add sugar", Seq(addCoffeePowder)) {
    println("Adding sugar")
  }

  val makeCoffee = task("Make coffee", Seq(addSugar)) {
    println("Coffee is ready to serve")
  }

  Await.result(makeCoffee.run, 10.seconds)
}

我希望依赖项并行运行，完成后执行主体。但我总是把这个顺序弄错了

预期的顺序如下

package taskman

import scala.concurrent.{Await, Future}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._

final class Task private (
    desc: String,
    dependencies: Seq[Task] = Seq.empty[Task],
    body: => Unit
) {

  def run(): Future[Unit] = Future {
//    println(s"Executing dependencies for $desc")
    Future
      .sequence(dependencies.map(_.run()))
      .map { _ => body }
  }
}

object Task {
  def task(desc: String, dependencies: Seq[Task] = List.empty[Task])(
      body: => Unit
  ): Task =
    new Task(desc, dependencies, body)
}

object taskTest extends App {
  import Task._

  val boilWater = task("Boil water") {
    println("Boiling water ")
  }

  val boilMilk = task("Boil milk") {
    println("Boiling milk")
  }

  val mixWaterAndMilk =
    task("Mix milk and water", Seq(boilWater, boilMilk)) {
      println("Mixing milk and water")
    }

  val addCoffeePowder = task("Add coffee powder", Seq(mixWaterAndMilk)) {
    println("Adding coffee powder")
  }

  val addSugar = task("Add sugar", Seq(addCoffeePowder)) {
    println("Adding sugar")
  }

  val makeCoffee = task("Make coffee", Seq(addSugar)) {
    println("Coffee is ready to serve")
  }

  Await.result(makeCoffee.run, 10.seconds)
}

沸水 煮牛奶 混合牛奶和水 添加咖啡粉 加糖 咖啡可以上桌了

---

煮沸的牛奶和水可以按任何顺序进行，但其余的事情应该按顺序进行。我正在Future.sequence.map{}上执行主体，但顺序仍然不正确。这段代码肯定有问题，但我无法找出答案。

问题在于

运行中的虚假额外
将来的

def run(): Future[Unit] = Future { // <-- Not required
  Future
    .sequence(dependencies.map(_.run()))
    .map { _ => body }
}

问题在于
run
中的伪额外
Future

def run(): Future[Unit] = Future { // <-- Not required
  Future
    .sequence(dependencies.map(_.run()))
    .map { _ => body }
}

Future.sequence（dependencies.map（u.run（））
可以（应该？）替换为
Future.traverse（dependencies）（uu.run（））
尝试了遍历，它正在工作，实际上，两者都在工作，为什么建议遍历序列
Future.sequence（dependencies.map（u.run（））
可以（应该？）用
Future.traverse（dependencies）（\uu.run（））
替换。尝试了遍历，并且它正在工作，实际上，两者都在工作，为什么建议遍历序列