如何简化Akka/Futures中的未来结果处理？

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global

val future1 = Future { /* some computation */ }
val future2 = future1.map { result =>
  // process result
}

val combinedFuture = for {
  result1 <- future1
  result2 <- future2(result1)
} yield result2

val futureWithErrorHandling = future1.recover {
  case e: Exception => // handle exception
}

import scala.concurrent.Promise

val promise = Promise[Int]()
val future = promise.future

// somewhere else in the code
promise.success(42)

import akka.actor.ActorSystem
import akka.stream.ActorMaterializer
import akka.stream.scaladsl._

implicit val system = ActorSystem()
implicit val materializer = ActorMaterializer()

val source = Source(1 to 10)
val flow = Flow[Int].map(_ * 2)
val sink = Sink.foreach[Int](println)

source.via(flow).runWith(sink)