Scala „<-“ für das Verständnis

Question

Ich habe festgestellt, dass Scala hat immer eine „natürliche Erklärung“ zu nichts. Immer so etwas wie „ohh, aber das ist nur eine Funktion auf diesem und das Objekt mit diesem und jenem Parameter aufgerufen wird“. In gewissem Sinne ist nichts wirklich Compiler-Magie, wie wir sie aus anderen Sprachen kennen.

Meine Frage ist auf der Seite <- Operator wie in dem folgenden Code verwendet:

for(i <- 0 to 10) println(i)

In diesem Beispiel kann ich sehe es so etwas neu geschrieben werden:

0.to(10).foreach((i:Int)=>println(i))

, aber das erklärt nicht, wie die i wurde innerhalb der foreach-Funktion in die anonyme Funktion ausgeführt. An dem Punkt, wo Sie schreiben i es ist kein Objekt, und noch nicht eine deklarierte Variable. Also, was ist es, und wie wird sie an der Innenseite der foreach übertragen werden?

Meine Vermutung ist, dass ich endlich etwas gefunden, die in der Tat ist Compiler Magie

Vielen Dank für Ihre Zeit.

Um zu klären, ist meine Frage. Wie funktioniert die <- Operator Arbeit in der ersten Zeile des Codes, da ich kein Objekt auf das er als Funktion aufgerufen werden

Answer 1

<- ist eine Sprache definierten Schlüsselwort Symbol, wie => ist aber in deutlichem Gegensatz zu -> (die ein definiertes Symbol ist). Da es Teil des Grundes Scala Grammatik ist, kann es verwendet wird Bindungen zu erstellen (für den i in Ihrem Beispiel), das etwas ist, das nicht durch benutzerdefinierte Konstrukte durchgeführt werden kann.

Answer 2

Um Dave Antwort zu ergänzen, hier ist ein Übersetzungsschema für 'for-Comprehensions' von Scala Sprache Spezifikation:

Ein Verständnis for (enums) yield e auswertet Ausdruck e für jede von den Aufzählungen Aufzählungen erzeugt Bindung. Eine Enumerator Sequenz beginnt immer mit einem Generator; dies kann durch weitere Generatoren, Wertdefinitionen oder Wache folgen.

Ein Generator erzeugt p <- e Bindungen aus einem Ausdruck e, die in irgendeiner Art und Weise gegen p Muster abgestimmt ist. Ein Wert Definition val p = e bindet den Wert Namen p (oder mehrere Namen in einem Muster p) mit dem Ergebnis des Ausdruck e auswertet. Ein Wächter if e enthält einen Booleschen Ausdruck, die aufgezählt Bindungen beschränkt.

Die genaue Bedeutung von Generatoren und Wachen durch Übersetzung Anrufungen definiert von vier Methoden: map, filter, flatMap und foreach. Diese Methoden können auf unterschiedliche Weise für verschiedene Trägertypen implementiert werden.

Das Übersetzungsschema folgt wie. In einem ersten Schritt wird jeder Generator p <- e, wobei p nicht unwiderlegbare (§8.1) für die Art des e ist durch

ersetzt

 p <- e.filter { case p => true; case _ => false }

Dann werden die folgenden Regeln angewendet wiederholt, bis alle Comprehensions gewesen eliminiert.

• A für Verständnis for (p <- e) yield e0 zu e.map { case p => e0 } übersetzt wird.

• A für Verständnis for (p <- e) e0 zu e.foreach { case p => e0 } übersetzt wird.

• A für Verständnis for (p <- e; p0 <- e0 . . .) yield e00, wo. . . ist eine (möglicherweise leere) -Sequenz von Generatoren oder Schutzvorrichtungen, übersetzt zu:.
  e.flatMap { case p => for (p0 <- e0 . . .) yield e00 }

• A für Verständnis for (p <- e; p0 <- e0 . . .) e00 wo. . . eine (möglicherweise leere) Folge von Generatoren oder Wachen, wird übersetzt:
  e.foreach { case p => for (p0 <- e0 . . .) e00 }.

• Ein Generator p <- e von einer Wache if g folgt auf einen einzigen Generator übersetzt:
  p <- e.filter((x1, . . . , xn) => g )
  wo x1. . . , xn sind die freien Variablen von p.

• Ein Generator p <- e gefolgt von einem Wert Definition val p0 = e0 übersetzt den folgenden Generator von Wertepaaren, wo x und x0 sind frisch Namen:

  val (p, p0) <- 
    for(x@p <- e) yield { val x0@p0 = e0; (x, x0) }
  

Answer 3

In diesem Fall ist es wirklich ein bisschen Compiler Magie. Die Übersetzung aus dem für Verständnis auf Filter / map / flatmap Form ist ein besonderes Stück Zu, ähnlich wie die Umwandlung der Sonderformen der Aktualisierung und Methoden anwenden.