Scala 扁平化未来[EitherT[Future，A，B]]

正如标题所提到的

使用

EitherT[Future，A，B]

完成许多操作。有时我希望通过另一个具有签名

A=>Future[C]

的操作向左或向右映射。另一种情况是，

EitherT[Future，A，B]

对未来的映射结果产生

Future[EitherT[Future，A，B]

如何优雅地展平类型，如：

EitherT[Future，Future[A]，Future[B]

和

Future[EitherT[Future，A，B]

---

提前谢谢。

在所有情况下，您都可以使用

EitherT#flatMap

（或

EitherT#flatMapF

），并将一些值提升到

EitherT

（或与

flatMapF

的析取（

\//code>）


将a
B=>F[C]
映射到a
EitherT[F，a，B]
：

flatMap
+lift

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

import scalaz._, Scalaz._

def f(i: Int): Future[Double] = Future.successful(i.toDouble)
val r = EitherT.right[Future, String, Int](Future.successful(1))

r.flatMap(i => EitherT.right(f(i)))
// or
r.flatMapF(i => f(i).map(_.right))

def g(s: String): Future[Int] = Future.successful(s.length)

val l = EitherT.left[Future, String, Int](Future.successful("error"))

l.swap.flatMap(s => EitherT.right(g(s))).swap
// or
l.swap.flatMap(s => EitherT.left[Future, Int, Int](g(s)))
// or
l.swap.flatMapF(s => g(s).map(_.left))


将a=>F[C]

映射到a

EitherT[F，a，B]

：

swap

+

flatMap

+lift

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

import scalaz._, Scalaz._

def f(i: Int): Future[Double] = Future.successful(i.toDouble)
val r = EitherT.right[Future, String, Int](Future.successful(1))

r.flatMap(i => EitherT.right(f(i)))
// or
r.flatMapF(i => f(i).map(_.right))

def g(s: String): Future[Int] = Future.successful(s.length)

val l = EitherT.left[Future, String, Int](Future.successful("error"))

l.swap.flatMap(s => EitherT.right(g(s))).swap
// or
l.swap.flatMap(s => EitherT.left[Future, Int, Int](g(s)))
// or
l.swap.flatMapF(s => g(s).map(_.left))

将

A=>F，B，C]

之一映射到

F[A]

：

升降机+

flatMap

def h(i: Int): EitherT[Future, String, Int] = 
  EitherT.right(Future.successful(i + 1))

val fut = Future.successful(1)

// mapping gives us Future[EitherT[Future, String, Int]]
fut.map(h)                    

// lifting to EitherT and flatMap gives us EitherT[Future, String, Int]
EitherT.right(fut).flatMap(h)