Martin Odersky 的 ScalaDay 2011 示例：生成地图？

Question

我正在处理Odersky's ScalaDays 2011 keynote talk，当我到达这一特定行时（分配charCode），他用非常少的代码行构建了一个电话号码同义词生成器：

val mnem: Map[Char, String] = // phone digits to mnemonic chars (e.g. '2' -> "ABC")
val charCode: Map[Char, Char] = for ((digit, str) <- mnem; letter <- str)
    yield (letter -> digit)   // gives ('A', '2'), ('B', '2') etc

为什么charCode 的类型是Map？

当我在其他示例中生成元组时，我只是获得了一个元组序列——而不是一个映射。例如：

scala> for (i <- 1 to 3) yield (i -> (i+1))
res16: scala.collection.immutable.IndexedSeq[(Int, Int)] = Vector((1,2), (2,3), (3,4))

使用toMap() 可以轻松地将其转换为地图，就像这样......

scala> (for (i <- 1 to 3) yield (i -> (i+1))).toMap
res17: scala.collection.immutable.Map[Int,Int] = Map(1 -> 2, 2 -> 3, 3 -> 4)

...但不知何故，奥德斯基的例子避免了这种情况。

我在这里忽略了什么 Scala 魔法（如果有的话）？

---

附录 1：隐式转换？我想补充一些与 Oxbow Lake 评论有关的细节（注意：我的评论可能有部分错误，可能有点误解了他是什么到达）。

我怀疑发生了某种隐式转换，因为需要映射。所以我在解释器中尝试了 Odersky 的迭代器，但没有提示它应该产生什么：

scala> val mnem = Map('2' -> "ABC", '3' -> "DEF", '4' -> "GHI") // leaving as a map, still
scala> for ((digit, str) <- mnem; letter <- str) yield (letter, digit)
res18: scala.collection.immutable.Map[Char,Char] = Map(E -> 3, F -> 3, A -> 2, I -> 4, G -> 4, B -> 2, C -> 2, H -> 4, D -> 3)

（请注意，我将mnem 作为地图留在这里。）

同样，告诉编译器我想要一个地图并没有改变我自己的结果：

scala> val x: Map[Int,Int] = for (i <- 1 to 3) yield (i -> (i+1))
<console>:7: error: type mismatch;
 found   : scala.collection.immutable.IndexedSeq[(Int, Int)]
 required: Map[Int,Int]
       val x: Map[Int,Int] = for (i <- 1 to 3) yield (i -> (i+1))

另一方面，按照 Eastsun 的提示（这似乎也是 OL 所说的），以下（愚蠢的）修改确实生成了一张地图：

scala> for ((i,j) <- Map(1 -> 2, 2 -> 2)) yield (i -> (i+1))
res20: scala.collection.immutable.Map[Int,Int] = Map(1 -> 2, 2 -> 3)

那么如果迭代的值来自一个映射，那么会以某种方式生成一个映射？

我希望通过以下方式来理解答案：(a) 将“for”循环转换为其普通等价物（对map 的调用/调用）和 (b) 了解正在神奇地调用什么隐式。

---

附录 2：统一返回类型：(huynhjl:) 好像是这样。我的第一个示例转换为

(1 to 3).map(i => (i, i+1)) // IndexedSeq[(Int, Int)]

而第二个变成类似于这样的东西：

Map(1 -> 2, 2 -> 2).map(i => (i._1, i._1+1)) // Map[Int,Int]

“Map.map”的类型是，那么

def map [B, That] (f: ((A, B)) ⇒ B)(implicit bf: CanBuildFrom[Map[A, B], B, That]): That   

啊，琐碎。 ;-)

---

附录 3： 好吧，那还是太简单了。 Miles Sabin 提供了一种/更正确的脱糖方法，如下所示。更琐碎。 ;-)

Answer 1

如果你对 for 理解去糖，就更容易理解为什么要返回 Map，

val charCode: Map[Char, Char] = for ((digit, str) <- mnem; letter <- str)
  yield (letter -> digit)

等价于，

val charCode = mnem.flatMap {
  case (digit, str) => str.map { letter => (letter -> digit) }
}

所以这里为 charCode 推断的类型将是 flatMap 应用于 Map 的结果类型。 flatMap 的签名相当复杂，

def flatMap [B, That]
  (f: ((A, B)) => GenTraversableOnce[B])
  (implicit bf: CanBuildFrom[Map[A, B], B, That]): That

因为它提供了 Scala 编译器在给定 Map 的类型和在其上 (flat)Map'd 的函数类型的情况下计算适当结果类型所需的基础设施。

正如在其他地方提到的那样，集合框架的设计方式是容器将尽可能（平面）映射到相同形状的容器。在这种情况下，我们正在跨 Map[Char, String] 进行映射，因此它的元素等价于对 (Char, String)。我们正在映射的函数正在生成对 (Char, Char)，将它们连接起来可以返回 Map[Char, Char]。

我们可以通过查找相应的 CanBuildFrom 实例来验证编译器是否也相信这一点，

scala> import scala.collection.generic.CanBuildFrom
import scala.collection.generic.CanBuildFrom

scala> implicitly[CanBuildFrom[Map[Char, String], (Char, Char), Map[Char, Char]]]
res0: scala.collection.generic.CanBuildFrom[Map[Char,String],(Char, Char),Map[Char,Char]] = scala.collection.generic.GenMapFactory$MapCanBuildFrom@1d7bd99

注意 CanBuildFrom 的最后一个类型参数是 Map[Char, Char]。这修复了 flatMap 签名中的“That”类型参数，并为我们提供了此 flatMap 的结果类型，从而得到了 charCode 的推断类型。

Answer 2

charCode 是一个 Map，因为 mnem 是一个 Map。 你有一个序列，因为 1 到 3 是一个序列

一些有趣的例子：

EDIT：我添加了一个链接来展示 breakOut 的神奇之处。 Scala 2.8 breakOut

Welcome to Scala version 2.10.0.r25713-b20110924020351 (Java HotSpot(TM) Client VM, Java 1.6.0_26).
Type in expressions to have them evaluated.
Type :help for more information.

scala> val seq = 1 to 3
seq: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3)

scala> val seq2 = for(i <- seq) yield (i -> (i+1))
seq2: scala.collection.immutable.IndexedSeq[(Int, Int)] = Vector((1,2), (2,3), (3,4))

scala> import collection.breakOut
import collection.breakOut

scala> val map2: Map[Int,Int] = (for(i<-seq) yield(i->(i+1)))(breakOut)
map2: Map[Int,Int] = Map(1 -> 2, 2 -> 3, 3 -> 4)

scala> val list2: List[(Int,Int)] = (for(i<-seq) yield(i->(i+1)))(breakOut)
list2: List[(Int, Int)] = List((1,2), (2,3), (3,4))

scala> val set2: Set[(Int,Int)] = (for(i<-seq) yield(i->(i+1)))(breakOut)
set2: Set[(Int, Int)] = Set((1,2), (2,3), (3,4))

scala> val map = (1 to 3).zipWithIndex.toMap
map: scala.collection.immutable.Map[Int,Int] = Map(1 -> 0, 2 -> 1, 3 -> 2)

scala> val map3 = for((x,y) <- map) yield(x,"H"+y)
map3: scala.collection.immutable.Map[Int,java.lang.String] = Map(1 -> H0, 2 -> H1, 3 -> H2)

scala> val list3: List[(Int,String)] = (for((x,y) <- map) yield(x,"H"+y))(breakOut)
list3: List[(Int, String)] = List((1,H0), (2,H1), (3,H2))

scala> val set3: Set[(Int,String)] = (for((x,y) <- map) yield(x,"H"+y))(breakOut)
set3: Set[(Int, String)] = Set((1,H0), (2,H1), (3,H2))

scala> val array3: Array[(Int,String)] = (for((x,y) <- map) yield(x,"H"+y))(breakOut)
array3: Array[(Int, String)] = Array((1,H0), (2,H1), (3,H2))

scala>

Answer 3

您所忽略的魔法称为统一返回类型原则。请参阅http://www.scala-lang.org/docu/files/collections-api/collections.html 中的集合 API 概述部分。集合库非常努力地根据您开始使用的集合类型返回最专业的类型。

map 和 flatMap 和 for 循环也是如此。

http://www.scala-lang.org/docu/files/collections-api/collections-impl.html 中解释了魔法，请参阅分解常见操作。