映射Scala期货
映射Scala期货
提问于 2016-05-08 11:56:29
假设我有一个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;
}有没有更好的方法来处理这件事？
回答 2
Stack Overflow用户
回答已采纳
发布于 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")))Stack Overflow用户
发布于 2016-05-08 12:13:47
就我个人而言，我认为嵌套映射没有任何问题。您只需更好地格式化和缩进：
future.map { seq =>
seq.map(_.toString)
}有些人还发现for理解在这种情况下很有用(更重要的是，当您需要一起处理几个未来时)。
for {
seq <- future
} yield seq.map(_.toString)页面原文内容由Stack Overflow提供。腾讯云小微IT领域专用引擎提供翻译支持
原文链接：
https://stackoverflow.com/questions/37099549
复制相关文章
相似问题
腾讯云开发者
