Пример Мартина Одерского ScalaDay 2011 года: получить карту?

Question

Я работал над Основной доклад Одерского 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)

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

Какую магию Скалы, если таковая имеется, я пропускаю здесь?

---

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

Я подозревал, что какое-то неявное преобразование происходило, потому что требовалась карта. Поэтому я попробовал итератор Одерского в интерпретаторе, без намеков на то, что он должен производить:

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))

С другой стороны, следуя намекам Иццуна (и это похоже на то, что говорил и ОЛ), следующая (тупая) модификация создает карту:

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)

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

Я ожидаю, что ответ должен быть понят (а) преобразованием цикла "for" в его длинные эквиваленты (вызов / вызовы 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   

Ах, банально. ; -)

---

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

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

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

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

Как уже упоминалось в другом месте, структура коллекций была разработана таким образом, что контейнеры будут (плоскими) отображаться в контейнеры той же формы, где это возможно.В этом случае мы сопоставляем карту [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, и это дает нам тип результата для этого flatMap и, следовательно, предполагаемый тип charCode.

Answer 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>

Answer 3

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

Это верно для map и flatMap и for петель.

Волшебство объясняется в http://www.scala -lang.org / documents / files / collection-api / collection-impl.html , см. Выделение общих операций .