8

我有一个代表数据库记录的字符串 id 列表。我想从数据库异步加载它们，然后将每条记录异步上传到远程服务器，然后当所有上传完成后，记录上传记录的 ID。

由于我使用的是 Scala 2.9.2，因此我使用的是 Twitter 的 core-util Future 实现，但它在 Monadic 转换方面应该与 2.10 的 future 完全一样。

一般概念是这样的：

def fetch(id: String): Future[Option[Record]]
def upload(record: Record): Future[String]
def notifyUploaded(ids: Seq[String]): Unit

val ids: Seq[String] = ....

我试图通过理解来做到这一点，但 fetch 返回选项的未来这一事实使它变得模糊并且代码无法编译：

for {
  id <- ids
  maybeRecord <- fetch(id)
  record <- maybeRecord
  uploadedId <- upload(record)
} yield uploadedId

编译它会导致以下错误：

scala: type mismatch;
found   : com.twitter.util.Future[String]
required: Option[?]
    uploadedId <- upload(record)
                  ^

我错过了什么？为什么编译器期望 uploadId 是一个选项？有什么漂亮的方法可以解决这个问题吗？

4

2 回答 2

6

考虑flatMap（或绑定）函数的签名：

trait Monad[M[_]] {
  def flatMap[A](a : M[A], f : A => M[B]) : M[B]
  ....

在您的情况下，您尝试flatMap在 an 上使用Option，给它一个f生成一个Future. 但就像上面的签名一样，f应该在调用它的同一个 monad 中生成一些东西。

Scala 在这方面不一定很有帮助，因为它非常擅长转换周围的事物（Seq例如，转换为 s），这样您就可以将任意flatMap调用链接在一起，而不管容器如何。

你可能想要的是一个“Monad 转换器”，它可以让你有一些编写 monad 的能力。Debasish Ghosh 在这里有一篇关于使用 Scalaz monad 转换器的文章。

于 2013-03-01T09:59:36.260 回答
0

您不能将所有不同的类型混合在一起以进行理解，我发现您可能会混合 Seq 和 Option 并且结果将是 Seq 或 Option 取决于首先是什么。不能混合 Future 和 Seq 或 Option。如果您想使用理解功能，则必须将它们级联一些。在这种情况下，使用 map/flatMap 可能会更好。我以两种方式实现了您的问题，并向少数中间结果添加了类型，以便您看到在使用所有不同类型时创建的混乱。

object TestClass {

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

  case class Record(id: String)


  def fetch(id: String): Future[Option[Record]] = Future {
    Thread.sleep(1000);
    Some(Record(id))
  }

  def upload(record: Record): Future[String] = Future {
    Thread.sleep(3000);
    record.id + "_uploaded"
  }

  def notifyUploaded(ids: Seq[String]): Unit = println("notified" + ids)

  val ids: Seq[String] = Seq("a", "b", "c")

  def main(args: Array[String]): Unit = {
    forComprehensionImpl()
    mapAndFlatMapImpl()
  }

  def forComprehensionImpl() = {
    val result: Seq[Future[Option[Future[String]]]] = for {
      id <- ids
    } yield {
      for {
        maybeRecord <- fetch(id)
      } yield {
        for {
          record <- maybeRecord
        } yield {
          for {
            uploadedId <- upload(record)
          } yield uploadedId
        }
      }
    }
    val result2: Future[Seq[Option[Future[String]]]] = Future.sequence(result)
    val result3: Future[Unit] = result2.flatMap { x: Seq[Option[Future[String]]] =>
      Future.sequence(x.flatten).map(notifyUploaded)
    }
    Await.result(result3, Duration.Inf)
  }


  def mapAndFlatMapImpl() = {
    val res: Seq[Future[Iterable[String]]] = ids.map { id =>
      fetch(id).flatMap { maybeRecord =>
        val res1: Option[Future[Seq[String]]] = maybeRecord.map { record =>
          upload(record) map (Seq(_))
        }
        res1 match {
          case Some(a) => a
          case None => Future(Seq())
        }
      }
    }
    val res3: Future[Unit] = Future.sequence(res) map (a => notifyUploaded(a.flatten))
    Await.result(res3, Duration.Inf)
  }
}
于 2016-09-22T17:55:14.670 回答