如何展平使用 I/O 的嵌套 For Compriion？

Question

我无法将嵌套的 For 生成器展平为单个 For 生成器。

我创建了 MapSerializer 来保存和加载地图。

MapSerializer.scala 列表：

import java.io.{ObjectInputStream, ObjectOutputStream}

object MapSerializer {
  def loadMap(in: ObjectInputStream): Map[String, IndexedSeq[Int]] =
    (for (_ <- 1 to in.readInt()) yield {
      val key = in.readUTF()
      for (_ <- 1 to in.readInt()) yield {
        val value = in.readInt()
        (key, value)
      }
    }).flatten.groupBy(_ _1).mapValues(_ map(_ _2))

  def saveMap(out: ObjectOutputStream, map: Map[String, Seq[Int]]) {
    out.writeInt(map size)
    for ((key, values) <- map) {
      out.writeUTF(key)
      out.writeInt(values size)
      values.foreach(out.writeInt(_))
    }
  }
}

修改 loadMap 以在生成器内分配 key 会导致它失败：

def loadMap(in: ObjectInputStream): Map[String, IndexedSeq[Int]] =
  (for (_ <- 1 to in.readInt();
        key = in.readUTF()) yield {
    for (_ <- 1 to in.readInt()) yield {
      val value = in.readInt()
      (key, value)
    }
  }).flatten.groupBy(_ _1).mapValues(_ map(_ _2))

这是我得到的堆栈跟踪：

java.io.UTFDataFormatException
    at java.io.ObjectInputStream$BlockDataInputStream.readWholeUTFSpan(ObjectInputStream.java)
    at java.io.ObjectInputStream$BlockDataInputStream.readOpUTFSpan(ObjectInputStream.java)
    at java.io.ObjectInputStream$BlockDataInputStream.readWholeUTFSpan(ObjectInputStream.java)
    at java.io.ObjectInputStream$BlockDataInputStream.readUTFBody(ObjectInputStream.java)
    at java.io.ObjectInputStream$BlockDataInputStream.readUTF(ObjectInputStream.java:2819)
    at java.io.ObjectInputStream.readUTF(ObjectInputStream.java:1050)
    at MapSerializer$$anonfun$loadMap$1.apply(MapSerializer.scala:8)
    at MapSerializer$$anonfun$loadMap$1.apply(MapSerializer.scala:7)
    at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:194)
    at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:194)
    at scala.collection.immutable.Range.foreach(Range.scala:76)
    at scala.collection.TraversableLike$class.map(TraversableLike.scala:194)
    at scala.collection.immutable.Range.map(Range.scala:43)
    at MapSerializer$.loadMap(MapSerializer.scala:7)

我想要将加载代码扁平化为单个“用于理解”，但我收到错误，表明它要么以不同的顺序执行，要么重复我不希望它重复的步骤。

为什么将key的分配移动到生成器中会导致生成器失败？

我可以将其扁平化为单个生成器吗？如果是这样，那个发电机会是什么？

Answer 1

感谢您在问题中提供自包含的编译代码。我认为你不想压平循环，因为结构不平坦。然后，您需要使用groupBy来恢复结构。此外，如果您将“zero -> Seq()”作为映射的元素，它也会丢失。使用这个简单的映射可以避免 groupBy 并保留映射到空序列的元素：

def loadMap(in: ObjectInputStream): Map[String, IndexedSeq[Int]] = {
  val size = in.readInt
  (1 to size).map{ _ =>
    val key = in.readUTF
    val nval = in.readInt
    key -> (1 to nval).map(_ => in.readInt)
  }(collection.breakOut)
}

我使用 breakOut 生成正确的类型，否则我认为编译器会抱怨泛型 Map 和不可变的 Map 不匹配。您还可以使用Map() ++ (...)。

注意：我通过对 for 循环感到困惑并开始使用 flatMap 和 map 进行重写来找到此解决方案：

val tuples = (1 to size).flatMap{ _ =>
  val key = in.readUTF
  println("key " + key)
  val nval = in.readInt
  (1 to nval).map(_ => key -> in.readInt)
}

我认为在 for 循环中，当您不使用某些生成器时会发生某些情况。我认为这相当于：

val tuples = for {
  _ <- 1 to size
  key = in.readUTF
  nval = in.readInt
  _ <- 1 to nval
  value = in.readInt
} yield { key -> value }

但事实并非如此，所以我认为我在翻译中遗漏了一些东西。

编辑：找出单个 for 循环的问题所在。简短的故事：for 循环中定义的翻译导致在执行内部循环之前连续调用 key = in.readUTF 语句。要解决此问题，请使用 view 和 force：

val tuples = (for {
  _ <- (1 to size).view
  key = in.readUTF
  nval = in.readInt
  _ <- 1 to nval
  value = in.readInt
} yield { key -> value }).force

可以使用这段代码更清楚地演示该问题：

val iter = Iterator.from(1)
val tuple = for {
  _ <- 1 to 3
  outer = iter.next
  _ <- 1 to 3
  inner = iter.next
} yield (outer, inner)

它返回 Vector((1,4), (1,5)、(1,6)、(2,7)、(2,8)、(2,9)、(3,10)、(3,11)、(3,12)) 表明所有外部值都在内部值之前计算。这是因为它或多或少是翻译的类似于：

for { 
  (i, outer) <- for (i <- (1 to 3)) yield (i, iter.next)
  _ <- 1 to 3
 inner = iter.next
} yield (outer, inner)

这首先计算所有外部 iter.next 。回到最初的用例，所有 in.readUTF 值都将在 in.readInt 之前连续调用。

Answer 2

这是我最终部署的 @huynhjl 答案的压缩版本：

def loadMap(in: ObjectInputStream): Map[String, IndexedSeq[Int]] =
  ((1 to in.readInt()) map { _ =>
    in.readUTF() -> ((1 to in.readInt()) map { _ => in.readInt()) }
  })(collection.breakOut)

这个版本的优点是没有直接分配。