假设我有一个Future[Seq[Int]]
,我想将它转换为Future[Seq[String]]
。现在我是这样做的
val futureSeqString = futureSeqInt.map( x => x.map(_.toString()))
这是可行的,但嵌套映射似乎有点尴尬。对于Future[Option[Int]]
的等效转换稍微好一点,但仍然觉得我做的不是最好的方法:
val futureOptionString = futureOptionInt.map {
case Some(x) => x.toString();
case _ => None;
}
有没有更好的方法来处理这件事?
发布于 2016-05-08 12:13:53
双嵌套需要双重映射,所以是的,在vanilla中,您所做的是正确的。
然而,如果我们再考虑一下这个理论,List
和Future
都有一个map
操作,这使它们成为Functors
(这是一个过度简化,但请原谅我)。
两个Functors
可以通用地组成,因此您可以组合Functor
of Future
和Functor
of List
来实现“联合”map
操作。
下面是一个使用cats
的示例
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import cats._
import cats.std.future._
import cats.std.list._
// create a `Functor[Future[List]`
val futureListF = Functor[Future].compose(Functor[List])
val data = Future.successful(List(1, 2, 3))
// only one map!
futureListF.map(data)(_.toString) // Future(List("1", "2", "3"))
当然,您也可以对Option
进行同样的操作。
val futureOptionF = Functor[Future].compose(Functor[Option])
val data = Future.successful(Option(42))
futureOptionF.map(data)(_.toString) // Future(Some("42"))
此外,无论嵌套的深度如何,您都可以使用相同的技术:
type ListOption[+A] = List[Option[A]]
implicit val listOptionF = Functor[List].compose(Functor[Option])
val futureListOptionF = Functor[Future].compose(Functor[ListOption])
// the above three lines could just be
// val futureListOptionF = Functor[Future].compose(Functor[List].compose(Functor[Option]))
// if only SI-2712 were fixed
val data = Future.successful(List(Some(42), None, Some(2)))
// triple nesting? Still a single map!
futureListOptionF.map(data)(_.toString) // Future(List(Some("42"), None, Some("2")))
发布于 2016-05-08 12:13:47
就我个人而言,我认为嵌套映射没有任何问题。您只需更好地格式化和缩进:
future.map { seq =>
seq.map(_.toString)
}
有些人还发现for
理解在这种情况下很有用(更重要的是,当您需要一起处理几个未来时)。
for {
seq <- future
} yield seq.map(_.toString)
https://stackoverflow.com/questions/37099549
复制相似问题