ответ находится на определении map:

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

обратите внимание, что он имеет два параметра. Первая-это ваша функция, а вторая-неявная. Если вы не предоставите это неявное, Scala выберет самое конкретные один доступный.

о breakOut

Итак, какова цель breakOut? Рассмотрим пример, приведенный для вопроса, Вы берете список строк, преобразуете каждый строка в кортеж (Int, String), а затем производят Map из него. Самый очевидный способ сделать это-произвести посредника List[(Int, String)] сбор, а затем преобразовать его.

учитывая, что map использует Builder чтобы произвести результирующую коллекцию, не было бы возможно пропустить посредника List и получать результаты непосредственно в Map? Очевидно, да. Для этого, однако, нам нужно пройти правильный CanBuildFrom to map, а именно breakOut делает.

давайте посмотрим на определение 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()
  }

обратите внимание, что breakOut параметризован и возвращает экземпляр CanBuildFrom. Как это бывает, типы From, T и To уже были выведены, потому что мы знаем, что map ждет CanBuildFrom[List[String], (Int, String), Map[Int, String]]. Таким образом:

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

в заключение рассмотрим неявное, полученное . Это тип CanBuildFrom[Nothing,T,To]. Мы уже знаем все эти типы, поэтому мы можем определить, что нам нужен неявный тип CanBuildFrom[Nothing,(Int,String),Map[Int,String]]. Но существует ли такое определение?

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

так CanBuildFrom является contra-variant для параметра первого типа. Потому что Nothing является нижним классом (т. е. это подкласс всего), что означает любой класс может использоваться вместо Nothing.

поскольку такой строитель существует, Scala может использовать его для создания желаемый результат.

Про Строителей

многие методы из библиотеки коллекций Scala состоят в том, чтобы взять исходную коллекцию, обработать ее каким-то образом (в случае map, Преобразуя каждый элемент) и сохраняя результаты в новой коллекции.

чтобы максимизировать повторное использование кода, это хранение результатов осуществляется с помощью строитель (scala.collection.mutable.Builder), который в основном поддерживает две операции: добавление элементов, и возвращаем полученную коллекцию. Тип этой результирующей коллекции будет зависеть от типа построителя. Таким образом,List builder вернет List, a Map builder вернет Map и так далее. Реализация map метод не должен беспокоиться о типе результата: строитель заботится о нем.

с другой стороны, это означает, что map должен получить этот строитель как-то. Проблема, возникшая при проектировании Scala 2.8 Коллекции - это как выбрать лучшего строителя. Например, если бы я написал Map('a' -> 1).map(_.swap), я хотел бы получить Map(1 -> 'a') обратно. С другой стороны,Map('a' -> 1).map(_._1) не могу вернуть Map (она возвращает Iterable).

магия производя самые лучшие Builder из известных типов выражения выполняется через это CanBuildFrom неявные.

о CanBuildFrom

чтобы лучше объяснить, что происходит, я дам пример, где сопоставляемая коллекция является Map вместо List. Я вернусь в List позже. Теперь рассмотрим два выражения:

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

первый возвращает Map и второй возвращает Iterable. Магия возвращения подходящей коллекции-это работа CanBuildFrom. Рассмотрим определение map снова, чтобы понять это.

метод map наследуется от TraversableLike. Он параметризован на B и That, и использует параметры типа A и Repr, которые параметризуют класс. Давайте посмотрим оба определения вместе:

класс TraversableLike определено как:

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

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

чтобы понять, где A и Repr исходите из, давайте рассмотрим определение :

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

, потому что TraversableLike наследуется всеми признаками, которые расширяются Map, A и Repr может быть унаследован от любого из них. Но предпочтение отдается последнему. Итак, следуя определению неизменяемого Map и все черты, которые связывают его с TraversableLike мы:

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

если вы передаете параметры типа Map[Int, String] на всем пути вниз по цепочке мы обнаруживаем, что типы переданы TraversableLike, и, таким образом, используется map, являются:

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

возвращаясь к примеру, первая карта получает функцию типа ((Int, String)) => (Int, Int) и вторая карта получает функцию тип ((Int, String)) => String. Я использую двойную скобку, чтобы подчеркнуть, что это кортеж, получаемый, так как это тип A как мы видели.

с этой информацией, давайте рассмотрим другие типы.

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

map (_._2):
B = String

мы видим, что тип, возвращаемый первым map и Map[Int,Int], а второй Iterable[String]. Глядя на mapопределение, легко увидеть, что это значения That. Но откуда они берутся?

если мы посмотрим внутри сопутствующих объектов вовлеченных классов мы видим некоторые неявные объявления, предоставляющие их. На объекте Map:

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

и на объект Iterable, чей класс расширен на Map:

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

эти определения предоставляют фабрики для параметризованных CanBuildFrom.

Scala выберет наиболее конкретный неявный доступный. В первом случае, это был первый CanBuildFrom. Во втором случае, поскольку первый не соответствовал, он выбрал второй CanBuildFrom.

вернемся к вопросу

давайте посмотрим код для вопроса,Listи mapопределение (снова), чтобы увидеть, как выводятся типы:

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 

тип List("London", "Paris") is List[String], чтобы A и Repr определен TraversableLike являются:

A = String
Repr = List[String]

тип (x => (x.length, x)) is (String) => (Int, String), так типа B - это:

B = (Int, String)

последние неизвестный тип, That тип результата map, и у нас уже есть это:

val map : Map[Int,String] =

и

That = Map[Int, String]

что означает breakOut обязательно должен возвращать тип или подтип CanBuildFrom[List[String], (Int, String), Map[Int, String]].