Scala « <- » pour la compréhension

Question

J'ai trouvé que Scala a toujours une « explication naturelle » à quoi que ce soit. Toujours quelque chose comme « ohh, mais qui est juste une fonction appelée à cet égard et cet objet avec cela et ce paramètre ». Dans un sens, rien est vraiment le compilateur magique que nous connaissons d'autres langues.

Ma question est sur la <- opérateur utilisé dans le code suivant:

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

Dans cet exemple, je peux le voir réécrite à quelque chose comme:

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

mais cela n'explique pas comment le i dans la suis emballé fonction anonyme dans la fonction foreach. Au moment où vous écrivez i il est pas un objet, et non encore une variable déclarée. Alors, quel est-il, et comment est-il reporté à l'intérieur de foreach?

Je suppose que j'ai finalement découvert quelque chose qui est en fait magic compilateur

Merci pour votre temps.

Pour clarifier, ma question est:. Comment le <- le travail de l'opérateur dans la 1ère ligne de code car i n'est pas un objet sur lequel il peut être appelé en fonction

Answer 1

<- est un symbole mot-clé défini par la langue, comme => mais contraste nettement avec -> (qui est un symbole défini). Parce qu'il fait partie de la grammaire Scala de base, il peut être utilisé pour créer des liaisons (pour le i dans votre exemple) qui est quelque chose qui ne peut être fait par des constructions définies par l'utilisateur.

Answer 2

Pour augmenter la réponse de Dave, voici un schéma de traduction pour 'for-compréhensions' de la spécification de langage Scala:

  

Une compréhension for (enums) yield e évalue l'expression e pour chaque liaison généré par les énumérations des enquêteurs. Une séquence d'recenseur commence toujours par un générateur; ceci peut être suivi par d'autres générateurs, des définitions de valeur ou gardes.

     

Un générateur p <- e produit des liaisons à partir d'un e d'expression qui est adaptée d'une manière quelconque à l'encontre motif p. Une définition de valeur val p = e lie le nom de valeur p (ou plusieurs noms dans un motif p) à la suite de l'évaluation de l'expression e. Un if e de garde contient une expression booléenne qui limite les liaisons dénombrées.

     

La signification précise des générateurs et des gardes est définie par traduction invocations   de quatre méthodes: map, filter, flatMap et foreach. Ces méthodes peuvent être mises en œuvre de différentes manières pour différents types de supports.

     

Le système de traduction suit comme. Dans une première étape, chaque générateur p <- e, où p est pas irréfutable (§8.1) pour le type de e est remplacé par

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

     

Ensuite, les règles suivantes sont appliquées à plusieurs reprises jusqu'à ce que tous les compréhensions ont été   éliminé.

     

  

• A pour la compréhension-for (p <- e) yield e0 est traduit à e.map { case p => e0 }.

  

• A pour la compréhension-for (p <- e) e0 est traduit à e.foreach { case p => e0 }.

  

• A for (p <- e; p0 <- e0 . . .) yield e00 pour-compréhension, où. . . est un (éventuellement vide) séquence des générateurs ou des gardiens, se traduit   à:.
  e.flatMap { case p => for (p0 <- e0 . . .) yield e00 }

  

• A pour la compréhension-for (p <- e; p0 <- e0 . . .) e00 où. . . est une séquence (éventuellement vide) des générateurs ou des gardiens, se traduit à:   
  e.foreach { case p => for (p0 <- e0 . . .) e00 }.

  

• Un p <- e générateur suivi d'un if g de garde est traduit en un seul générateur:
    p <- e.filter((x1, . . . , xn) => g )
  où x1,. . . , xn sont les variables libres   de p.

  

• Un p <- e générateur suivi d'une définition valeur val p0 = e0 est traduit   au générateur suivant de paires de valeurs, où x et x0 sont nouveaux noms:

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

  

Answer 3

Dans ce cas, il est vraiment un peu de magie du compilateur. Une traduction pour-compréhensibilité filtre / carte / forme flatmap est un peu spécial de désucrage, tout comme la conversion des formes spéciales de mise à jour et appliquer des méthodes.