Scala 2.8 breakOut

Die Antwort findet sich in der Definition von map:

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

Beachten Sie, dass es zwei Parameter hat. Der erste ist Ihre Funktion und der zweite ist ein impliziter. Wenn Sie diesen impliziten Wert nicht angeben, wählt Scala) den spezifischsten verfügbaren Wert aus.

Über breakOut

Also, was ist der Zweck von breakOut? Betrachten Sie das für die Frage gegebene Beispiel: Sie nehmen eine Liste von Zeichenfolgen, transformieren jede Zeichenfolge in ein Tupel (Int, String) Und erzeugen daraus ein Map. Der naheliegendste Weg, dies zu tun, besteht darin, eine zwischengeschaltete List[(Int, String)]-Auflistung zu erstellen und diese anschließend zu konvertieren.

Angesichts der Tatsache, dass map eine Builder verwendet, um die resultierende Sammlung zu erstellen, wäre es nicht möglich, den Vermittler List zu überspringen und die Ergebnisse direkt in einer Map? Offensichtlich ist es das. Dazu müssen wir jedoch ein richtiges CanBuildFrom an map übergeben, und genau das tut breakOut.

Schauen wir uns nun die Definition von breakOut an:

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

Beachten Sie, dass breakOut parametrisiert ist und eine Instanz von CanBuildFrom zurückgibt. Zufällig wurden die Typen From, T und To bereits abgeleitet, da wir wissen, dass mapCanBuildFrom[List[String], (Int, String), Map[Int, String]] erwartet. Deshalb:

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

Lassen Sie uns abschließend das von breakOut selbst empfangene Implizit untersuchen. Es ist vom Typ CanBuildFrom[Nothing,T,To]. Wir kennen alle diese Typen bereits, sodass wir feststellen können, dass wir ein Implizit vom Typ CanBuildFrom[Nothing,(Int,String),Map[Int,String]] benötigen. Aber gibt es eine solche Definition?

Schauen wir uns die Definition von CanBuildFrom an:

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

Also ist CanBuildFrom für seinen ersten Typparameter eine Gegenvariante. Da Nothing eine untergeordnete Klasse ist (dh eine Unterklasse von allem), bedeutet dies, dass jede Klasse an Ort und Stelle verwendet werden kann von Nothing.

Da es einen solchen Builder gibt, kann Scala) damit die gewünschte Ausgabe erzeugen.

Über Builder

Viele Methoden aus der Collections-Bibliothek von Scala bestehen darin, die ursprüngliche Collection zu übernehmen, sie irgendwie zu verarbeiten (im Fall von map, jedes Element zu transformieren) und die Ergebnisse in einer neuen Collection zu speichern.

Um die Wiederverwendung von Code zu maximieren, erfolgt diese Speicherung der Ergebnisse über einen Builder (scala.collection.mutable.Builder), Der grundsätzlich zwei Operationen unterstützt: Anhängen von Elementen, und Zurücksenden der resultierenden Sammlung. Der Typ dieser resultierenden Auflistung hängt vom Typ des Builders ab. Ein Builder List gibt also einen Builder List zurück, ein Builder Map gibt einen Builder Map zurück, und so weiter. Die Implementierung der map -Methode muss sich nicht mit der Art des Ergebnisses befassen: Der Builder kümmert sich darum.

Andererseits bedeutet das, dass map diesen Builder irgendwie empfangen muss. Das Problem beim Entwerfen von Scala 2.8 Sammlungen war, wie man den bestmöglichen Builder auswählt. Wenn ich zum Beispiel Map('a' -> 1).map(_.swap) schreibe, möchte ich eine Map(1 -> 'a') zurückbekommen kann eine Map('a' -> 1).map(_._1) kein Map zurückgeben (es gibt ein Iterable zurück).

Die Magie, aus den bekannten Ausdruckstypen das bestmögliche Builder zu erzeugen, wird durch dieses CanBuildFrom implizit ausgeführt.

Über CanBuildFrom

Um besser zu erklären, was los ist, werde ich ein Beispiel geben, in dem die zuzuordnende Sammlung ein Map anstelle eines List ist. Ich gehe später zurück zu List. Betrachten Sie vorerst diese beiden Ausdrücke:

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

Der erste gibt ein Map und der zweite ein Iterable zurück. Die Magie der Rückgabe einer passenden Sammlung ist die Arbeit von CanBuildFrom. Betrachten wir die Definition von map noch einmal, um sie zu verstehen.

Die Methode map wird von TraversableLike geerbt. Es wird auf B und That parametrisiert und verwendet die Typparameter A und Repr, die die Klasse parametrisieren. Lassen Sie uns beide Definitionen zusammen sehen:

Die Klasse TraversableLike ist definiert als:

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

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

Um zu verstehen, woher A und Repr kommen, betrachten wir die Definition von Map selbst:

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

Da TraversableLike von allen Merkmalen geerbt wird, die Map erweitern, können A und Repr von jedem von ihnen geerbt werden. Der Letzte bekommt allerdings die Vorliebe. Nach der Definition des unveränderlichen Map und aller Merkmale, die es mit TraversableLike verbinden, haben wir also:

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

Übergeben Sie die Typparameter von Map[Int, String] In der gesamten Kette, stellen wir fest, dass die an TraversableLike übergebenen und daher von map verwendeten Typen wie folgt lauten :

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

Zurück zum Beispiel, die erste Karte empfängt eine Funktion vom Typ ((Int, String)) => (Int, Int) Und die zweite Karte empfängt eine Funktion vom Typ ((Int, String)) => String. Ich verwende die doppelte Klammer, um zu betonen, dass ein Tupel empfangen wird, da dies die Art von A ist, wie wir gesehen haben.

Betrachten wir anhand dieser Informationen die anderen Typen.

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

map (_._2):
B = String

Wir können sehen, dass der vom ersten map zurückgegebene Typ Map[Int,Int] Und der zweite Iterable[String] Ist. Anhand der Definition von map ist leicht zu erkennen, dass dies die Werte von That sind. Aber woher kommen sie?

Wenn wir in die Begleitobjekte der beteiligten Klassen schauen, sehen wir einige implizite Deklarationen, die sie bereitstellen. Auf Objekt Map:

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

Und auf Objekt Iterable, dessen Klasse um Map erweitert ist:

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

Diese Definitionen stellen Fabriken für parametrisierte CanBuildFrom bereit.

Scala wählt das spezifischste verfügbare Implizit aus. Im ersten Fall war es das erste CanBuildFrom. Im zweiten Fall wurde der zweite CanBuildFrom gewählt, da der erste nicht übereinstimmte.

Zurück zur Frage

Schauen wir uns den Code für die Frage an, die Definition von List und map (noch einmal), um zu sehen, wie die Typen abgeleitet werden:

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 

Der Typ von List("London", "Paris") ist List[String]. Die Typen A und Repr, die für TraversableLike definiert wurden, sind also:

A = String
Repr = List[String]

Der Typ für (x => (x.length, x)) Ist (String) => (Int, String), Daher ist der Typ von B:

B = (Int, String)

Der letzte unbekannte Typ, That, ist der Typ des Ergebnisses von map, und das haben wir auch schon:

val map : Map[Int,String] =

So,

That = Map[Int, String]

Das bedeutet, dass breakOut notwendigerweise einen Typ oder Untertyp von CanBuildFrom[List[String], (Int, String), Map[Int, String]] zurückgeben muss.