Odpowiedź znajduje się na definicji map:

def map[B, That](f : (A) => B)(implicit bf : CanBuildFrom[Repr, B, That]) : That 

Zauważ, że ma dwa parametry. Pierwsza to twoja funkcja, a druga to ukryta. Jeśli nie podasz tego dorozumianego, Scala wybierze najbardziej konkretny dostępny.

O firmie breakOut

Więc, jaki jest cel breakOut? Rozważmy przykład podany Dla pytania, bierzemy listę łańcuchów, przekształcamy każdy łańcuch w krotkę (Int, String), a następnie produkujemy a Map out of it. Najbardziej oczywistym sposobem na to jest utworzenie pośredniej kolekcji List[(Int, String)], a następnie jej przekształcenie.

Biorąc pod uwagę, że map używa Builder do wytworzenia zbioru wynikowego, czy nie byłoby możliwe pominięcie pośrednika List i zebranie wyników bezpośrednio do Map? Najwyraźniej tak. Aby to zrobić, musimy jednak przekazać odpowiednie CanBuildFrom do map i to właśnie robi breakOut.

Przyjrzyjmy się zatem definicji breakOut:

def breakOut[From, T, To](implicit b : CanBuildFrom[Nothing, T, To]) =
  new CanBuildFrom[From, T, To] {
    def apply(from: From) = b.apply() ; def apply() = b.apply()
  }

Zauważ, że {[18] } jest parametryzowana i zwraca instancję CanBuildFrom. Tak się składa, że rodzaje From, T i To zostały już wywnioskowane, ponieważ wiemy, że map oczekuje CanBuildFrom[List[String], (Int, String), Map[Int, String]]. Dlatego:

From = List[String]
T = (Int, String)
To = Map[Int, String]

Podsumowując, przyjrzyjmy się implicit otrzymanemu przez breakOut. Jest typu CanBuildFrom[Nothing,T,To]. Znamy już wszystkie te typy,więc możemy stwierdzić, że potrzebujemy implicit of type CanBuildFrom[Nothing,(Int,String),Map[Int,String]]. Ale czy jest taki definicja?

Spójrzmy na definicjęCanBuildFrom:

trait CanBuildFrom[-From, -Elem, +To] 
extends AnyRef

Więc {[27] } jest kontra-wariantem pierwszego parametru typu. Ponieważ Nothing jest klasą dolną (tzn. jest podklasą wszystkiego), oznacza to, że każda klasa może być użyta zamiast Nothing.

Ponieważ taki konstruktor istnieje, Scala może go użyć do wytworzenia pożądanego wyjścia.

O Budowniczych

Wiele metod ze zbiorów Biblioteki Scali polega na zbiór oryginalny, przetwarzając go w jakiś sposób (w przypadku map, przekształcając każdy element) i przechowując wyniki w nowym zbiorze.

Aby zmaksymalizować ponowne użycie kodu, zapisywanie wyników odbywa się za pomocą konstruktora (scala.collection.mutable.Builder), który zasadniczo obsługuje dwie operacje: dodawanie elementów i zwracanie wynikowej kolekcji. Typ tej wynikowej kolekcji będzie zależał od typu konstruktora. Tak więc, budowniczy List zwróci List, budowniczy Map zwróci Map, i tak dalej. Implementacja metody map nie musi martwić się o rodzaj wyniku: konstruktor dba o to.

Z drugiej strony, oznacza to, że map musi jakoś otrzymać tego budowniczego. Problemem przy projektowaniu kolekcji Scala 2.8 było wybranie najlepszego możliwego konstruktora. Na przykład, gdybym miał napisać Map('a' -> 1).map(_.swap), chciałbym dostać Map(1 -> 'a') z powrotem. Z drugiej strony, a Map('a' -> 1).map(_._1) nie może zwrócić a Map (zwraca Iterable).

Magia tworzenia najlepszego możliwego Builder ze znanych typów wyrażenia jest wykonywana za pomocą tego CanBuildFrom implicit.

O firmie CanBuildFrom

Aby lepiej wyjaśnić, o co chodzi, podam przykład, w którym odwzorowywana kolekcja to Map zamiast List. Wrócę do List później. Na razie rozważmy te dwa wyrażenia:

Map(1 -> "one", 2 -> "two") map Function.tupled(_ -> _.length)
Map(1 -> "one", 2 -> "two") map (_._2)

Pierwszy zwraca Map, a drugi zwraca Iterable. Magia o zwróceniu odpowiedniej kolekcji jest dziełem CanBuildFrom. Rozważmy definicję map ponownie, aby ją zrozumieć.

Metoda map jest dziedziczona z TraversableLike. Jest ona parametryzowana na B i That i wykorzystuje parametry typu A i Repr, które parametryzują klasę. Spójrzmy na obie definicje razem:

Klasa TraversableLike jest zdefiniowana jako:

trait TraversableLike[+A, +Repr] 
extends HasNewBuilder[A, Repr] with AnyRef

def map[B, That](f : (A) => B)(implicit bf : CanBuildFrom[Repr, B, That]) : That 

Aby zrozumieć skąd pochodzą A i Repr, rozważmy definicję Map:

trait Map[A, +B] 
extends Iterable[(A, B)] with Map[A, B] with MapLike[A, B, Map[A, B]]

Ponieważ TraversableLike jest dziedziczona przez wszystkie cechy, które rozciągają Map, A i Repr mogą być dziedziczone po każdym z nich. Ostatni dostaje preferencje. Tak więc, zgodnie z definicją niezmiennego Map i wszystkimi cechami, które łączą go z TraversableLike, mamy:

trait Map[A, +B] 
extends Iterable[(A, B)] with Map[A, B] with MapLike[A, B, Map[A, B]]

trait MapLike[A, +B, +This <: MapLike[A, B, This] with Map[A, B]] 
extends MapLike[A, B, This]

trait MapLike[A, +B, +This <: MapLike[A, B, This] with Map[A, B]] 
extends PartialFunction[A, B] with IterableLike[(A, B), This] with Subtractable[A, This]

trait IterableLike[+A, +Repr] 
extends Equals with TraversableLike[A, Repr]

trait TraversableLike[+A, +Repr] 
extends HasNewBuilder[A, Repr] with AnyRef

Jeśli przekażesz parametry typu Map[Int, String] w całym łańcuchu, okaże się, że typy przekazane do TraversableLike, a zatem używane przez map, to:

A = (Int,String)
Repr = Map[Int, String]

Going wracając do przykładu, pierwsza mapa odbiera funkcję typu ((Int, String)) => (Int, Int), a druga mapa odbiera funkcję typu ((Int, String)) => String. Używam podwójnego nawiasu, aby podkreślić, że otrzymujemy krotkę, ponieważ taki jest typ A, jak widzieliśmy.

Z tą informacją, rozważmy inne typy.

map Function.tupled(_ -> _.length):
B = (Int, Int)

map (_._2):
B = String

Widzimy, że typ zwracany przez pierwszy map to Map[Int,Int], a drugi to Iterable[String]. Patrząc na definicję map, łatwo zauważyć, że są to wartości That. Ale skąd pochodzą?

Jeśli spojrzymy wewnątrz obiektów towarzyszących zaangażowanych klas, zobaczymy pewne niejawne deklaracje je dostarczające. W obiekcie Map:

implicit def  canBuildFrom [A, B] : CanBuildFrom[Map, (A, B), Map[A, B]]  

I na obiekcie Iterable, którego klasa jest rozszerzona o Map:

implicit def  canBuildFrom [A] : CanBuildFrom[Iterable, A, Iterable[A]]  

Te definicje dostarczają fabryk parametryzowanych CanBuildFrom.

Scala wybierze najbardziej konkretny Ukryty dostępny. W pierwszym przypadku był to pierwszy CanBuildFrom. W drugim przypadku, jako pierwszy nie pasował, wybrał drugi CanBuildFrom.

Wróć do pytania

Zobaczmy kod dla pytania, List i map's definicja (ponownie), aby zobaczyć, jak typy są wnioskowane:

val map : Map[Int,String] = List("London", "Paris").map(x => (x.length, x))(breakOut)

sealed abstract class List[+A] 
extends LinearSeq[A] with Product with GenericTraversableTemplate[A, List] with LinearSeqLike[A, List[A]]

trait LinearSeqLike[+A, +Repr <: LinearSeqLike[A, Repr]] 
extends SeqLike[A, Repr]

trait SeqLike[+A, +Repr] 
extends IterableLike[A, Repr]

trait IterableLike[+A, +Repr] 
extends Equals with TraversableLike[A, Repr]

trait TraversableLike[+A, +Repr] 
extends HasNewBuilder[A, Repr] with AnyRef

def map[B, That](f : (A) => B)(implicit bf : CanBuildFrom[Repr, B, That]) : That 

Typem List("London", "Paris") jest List[String], więc typy A i Repr zdefiniowane na TraversableLike to:

A = String
Repr = List[String]

Typ dla (x => (x.length, x)) to (String) => (Int, String), więc Typ B to:

B = (Int, String)

Ostatni Nieznany typ, That jest typem wynik map, a my już to mamy:

val map : Map[Int,String] =

Więc,

That = Map[Int, String]

Oznacza to, że breakOut musi koniecznie zwrócić typ lub Podtyp CanBuildFrom[List[String], (Int, String), Map[Int, String]].