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

Question

我正在通过Odersky的ScalaDays 2011主题演讲,当我到达这个特定的行(分配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)理解神奇地调用哪些含义.

---

附录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是一个Map,因为mnem是一个Map.你有一个序列,因为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中解释,请参阅分解常见操作.