Мартин Одерски ScalaDay 2011 Пример: Уступка карты?

Я работал над анонсом 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)

... но каким-то образом пример Odersky избегает этого.

Что такое Scala магия, если таковая имеется, я не вижу здесь?

Добавление 1: Неявное преобразование? Я хотел бы добавить некоторые детали, относящиеся к комментарию Oxbow Lake (NB: мой комментарий может быть частично ошибочным, неправильно поняв, возможно, что он был получение).

Я подозревал, что происходит какое-то неявное преобразование, потому что требуется карта. Поэтому я попробовал итератор 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)

Итак, если итерированное значение происходит от карты, как-то создается карта?

Я ожидаю, что ответ должен быть понят: (а) преобразованием цикла "за" в его эквиваленты с длинными буквами (вызов/вызовы Map) и (б) понимание того, какие магические действия имплицируются.

Добавление 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

Ah, тривиально.; -)

Добавление 3: Ну, ладно, это было слишком просто, все еще. Майлз Сабин обеспечивает более правильную десурацию ниже. Еще более тривиально.;-)

Ответ 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, будет результатом типа flatMap, примененного к карте. Подпись flatMap довольно сложна,

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

поскольку он предоставляет инфраструктуру, которую компилятор Scala должен вычислить соответствующий тип результата, учитывая тип карты и тип функции (плоской) Map'd через нее.

Как уже упоминалось в другом месте, структура коллекций была разработана таким образом, что контейнеры будут (плоские) Map'd в контейнеры с одинаковой формой, где это возможно. В этом случае мы сопоставляем Map [ Char, String], поэтому его элементы эквивалентны парам (Char, String). И функция, которую мы нарисовываем, создает пары (Char, Char), которые в результате объединения могут вернуть нам карту [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]] = [email protected]

Обратите внимание, что аргумент CanBuildFrom последнего типа - Map [ Char, Char]. Это фиксирует параметр типа "Тот" в методе flatMap и дает нам тип результата для этой flatMap и, следовательно, выводимый тип charCode.

Ответ 2

charCode - это карта, потому что mnem - это карта. У вас есть выделение, потому что от 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>

Ответ 3

Магия, которую вы игнорируете, называется принципом равномерного возвращения. См. Обзор раздела API коллекций в http://www.scala-lang.org/docu/files/collections-api/collections.html. Библиотека коллекции очень тяжело возвращает наиболее специализированный тип, основанный на типе коллекции, с которой вы начинаете.

Это верно для циклов map и flatMap и for.

Магия объясняется в http://www.scala-lang.org/docu/files/collections-api/collections-impl.html, см. Факторинг общих операций.