gpt4 book ai didi

scala - 映射 Scala future

转载 作者:行者123 更新时间:2023-12-05 01:00:45 25 4
gpt4 key购买 nike

假设我有一个 Future[Seq[Int]],我想将其转换为 Future[Seq[String]]。目前我是这样做的:

 val futureSeqString = futureSeqInt.map( x => x.map(_.toString()))

这可行,但嵌套 map 似乎有点尴尬。 Future[Option[Int]] 的等效转换稍好一些,但我仍然觉得这不是最好的方法:

val futureOptionString = futureOptionInt.map {       
case Some(x) => x.toString();
case _ => None;
}

有没有更好的方法来处理这个问题?

最佳答案

双重嵌套需要双重映射,所以是的,在 vanilla scala 中,你所做的是正确的。

但是,如果我们稍微考虑一下理论,ListFuture 都有一个 map 操作,这使得它们 仿函数(这是一个过于简单化的问题,但请耐心等待)

两个Functor可以泛型组合,所以你可以组合FutureFunctorFunctor 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")))

关于scala - 映射 Scala future ,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/37099549/

25 4 0
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com