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所说的），以下（dorky）修改生成地图：

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）理解神奇地调用哪些含义。< / p>

附录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提供了一个更正确的desugaring，下面。更琐碎。 ;-)

Answer 1

如果你厌倦了理解，你会更容易理解为什么你会得到一张地图，

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推断的类型将是应用于Map的flatMap的结果类型。 flatMap的签名非常复杂，

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

因为它提供了Scala编译器在给定Map的类型和函数类型（平面）的情况下计算适当结果类型所需的基础结构。

正如其他地方所提到的，集合框架的设计方式使得容器可以（平面）映射到可能的相同形状的容器。在这种情况下，我们映射Map [Char，String]，因此它的元素相当于pair（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是一张地图，因为mnem是一张地图。你有一个序列，因为1到3是一个序列

一些有趣的例子：

编辑：我添加了一个链接，以显示 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中解释，请参阅分解常见操作。

Martin Odersky的ScalaDay 2011年示例：产生一张地图？

3 个答案: