用于理解的Scala中的可遍历一次、未来和选项

Question

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

因为我使用的是Scala 2.9.2，所以我使用的是Twitter的core-util Future实现，但是在单子转换方面，它应该和2.10 futures完全一样。

总的概念是这样的:

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

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

为了便于理解，我尝试通过一个来实现，但是fetch返回一个Future of Option的事实使它变得模糊不清，代码无法编译:

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)
                  ^

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

Answer 1

你不能将所有不同的类型混合在一起进行理解，我发现你可以混合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)
  }
}

Answer 2

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

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

在您的例子中，您试图对< code>Option使用< code>flatMap，赋予它一个生成< code>Future的< code>f。但是在上面的签名中，< code>f应该在调用它的同一个单子中生成一些东西。

Scala在这方面不一定非常有用，因为它非常擅长转换（例如转换为＜code＞Seq＜/code＞s），让人觉得可以将任意＜code＞flatMap＜/code＞调用链接在一起，而不管容器是什么。

你可能想要的是一个“单子转换器”，它给你一些能力来组成单子。Debasish Ghosh在这里有一个关于使用Scalaz monad变形金刚的帖子。