ответ находится на определение 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 до 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]

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

на С:

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

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

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

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

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

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

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

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

о CanBuildFrom

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

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

первый возвращает a 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.

Скала подберет для вас наиболее конкретные неявные. В первом случае, это был первый 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") и List[String], чтобы A и Repr определен TraversableLike являются:

A = String
Repr = List[String]

тип (x => (x.length, x)) и (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]].