映射列表的Scala未来

我有一个未来列表，我想一个接一个地转换：

def foo(x: A): Future[B] = {...}
def mapFutures(xs: Future[List[A]]): Future[List[B]]

---

函数

mapfourtures

应该使用

foo

转换列表的每个元素，并返回列表的未来。最好的方法是什么？

您应该可以这样做（注意，我将类型A和B指定为Int和String，以便于理解）：

然后可以这样使用：

val futs = Future(List(1,2,3))
val mappedFuts = mapFutures(futs, foo)

def foo(x: Int): Future[String] = Future(x.toString) 

def mapFutures[A,B](xs: Future[List[A]], f:A => Future[B]): Future[List[B]]  = {
  for{
    list <- xs
    mapped <- Future.sequence(list map f)
  } yield mapped
}

编辑

现在，如果foo返回一个

Future

，您可以这样做：

val futs = Future(List(1,2,3))
val mappedFuts = mapFutures(futs, foo)

def foo(x: Int): Future[String] = Future(x.toString) 

def mapFutures[A,B](xs: Future[List[A]], f:A => Future[B]): Future[List[B]]  = {
  for{
    list <- xs
    mapped <- Future.sequence(list map f)
  } yield mapped
}

def foo（x:Int）：Future[String]=Future（x.toString）
def mapFutures[A，B]（xs:Future[List[A]]，f:A=>Future[B]）：Future[List[B]={
为了{
列出只需描绘未来：

val futureList = Future.successful(List(1, 2, 3))
val mappedList = futureList map { _ map { _ + 1 } }    

对于您的具体示例：

def foo(x: Int): String = x.toString
val fooList = fxs map { _ map foo }



编辑（基本上与cmbaxter的方法相同；只是没有用于理解的方法）

对于未来，您希望平面映射序列。序列将未来列表转换为列表的未来

val fxs = Future(List(1, 2, 3))
def foo(x: Int): Future[String] = Future(x.toString)
val fooList = fxs flatMap { l => Future.sequence(l map foo) }

您可以使用隐式类将
flatMapSeq
扩展方法添加到
Future[List[A]]

implicit class RichFutureSeq[A](val future: Future[List[A]]) extends AnyVal {
  // def mapSeq[B](f: A => B): Future[List[B]] = future.map(_.map(f))
  def flatMapSeq[B](f: A => Future[B]): Future[List[B]] = future.flatMap(Future.traverse(_)(f))
}

然后在你的客户，你可以这样使用它

// import the implicit if necessary
def foo(x: Int): Future[String] = Future.successful(x.toString)
val f : Future[List[Int]] = Future.successful(List(1, 2))
val fs: Future[List[String]] = f.flatMapSeq(foo)
def mapFutures(xs: Future[List[Int]])(f: Int => Future[String]): Future[List[String]] = xs.flatMapSeq(f)

你说你想映射一个未来列表，但这是一个列表的未来。你的意思是什么？后者-谢谢你的澄清。不完全是-foo应该返回一个未来[B]，而不仅仅是B。在你的情况下，这使得mapFutures[a，B]具有返回类型future[list[future[B]]@thomson_matt，很抱歉我错过了这一部分，我更新了我的解决方案。不完全是-foo应该返回未来的[String]，而不仅仅是String。