Scala “<-” per la comprensione

Question

ho scoperto che alla Scala ha sempre una "spiegazione naturale" per nulla. Sempre qualcosa come "Ohh, ma questo è solo una funzione chiamata su questo e che oggetto con questo e quello del parametro". In un certo senso, nulla è davvero compilatore-magia così come la conosciamo da altre lingue.

La mia domanda è sul <- operatore utilizzato nel codice seguente:

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

In questo esempio posso vedere che sia riscritto per qualcosa come:

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

, ma questo non spiega come il i sono lasciato trasportare in funzione anonima all'interno della funzione foreach. Nel punto in cui si scrive i non è un oggetto, e non ancora una variabile dichiarata. Così che cosa è, e come viene trasportato verso l'interno del foreach?

La mia ipotesi è che ho finalmente scoperto qualcosa che in realtà è magia compilatore

Grazie per il vostro tempo.

Per chiarire, la mia domanda è:. Come funziona il <- lavoro dell'operatore in 1 ° riga di codice dal momento che non è un oggetto su cui può essere chiamato come una funzione

Answer 1

<- è un simbolo parola chiave lingua definita, come è => ma in netto contrasto con -> (che è un simbolo definito). Perché è parte della grammatica di base Scala, può essere utilizzato per creare attacchi (per la i nel tuo esempio), che è qualcosa che non può essere fatto da costrutti definiti dall'utente.

Answer 2

Per aumentare la risposta di Dave, ecco uno schema di traduzione per 'for-comprensioni' dal specifica del linguaggio Scala:

  

Una comprensione for (enums) yield e Esamina e espressione per ciascun legame generato dagli enumeratori enumerazioni. Una sequenza enumeratore inizia sempre con un generatore; Questo può essere seguito da ulteriori generatori, definizioni valore, o protezioni.

     

Un generatore p <- e produce binding da un e espressione che è compensata in qualche modo contro modello p. Un val p = e definizione valore associa il nome di valore p (o più nomi in un p pattern) al risultato della valutazione del e espressione. Un if e guardia contiene un'espressione booleana che limita binding enumerati.

     

Il significato preciso di generatori e guardie è definito da traduzione di invocazioni   dei quattro metodi: map, filter, flatMap e foreach. Questi metodi possono essere implementati in modo diverso per i diversi tipi di supporto.

     

Lo schema di traduzione è come segue. In una prima fase, ogni generatore p <- e, dove p non è inconfutabile (§8.1) per il tipo di e è sostituito da

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

     

Quindi, le seguenti regole vengono applicate più volte fino a quando tutte le comprensioni sono stati   eliminato.

     

  

• A per-la comprensione for (p <- e) yield e0 è tradotto in e.map { case p => e0 }.

  

• A per-la comprensione for (p <- e) e0 è tradotto in e.foreach { case p => e0 }.

  

• A per-la comprensione for (p <- e; p0 <- e0 . . .) yield e00, dove. . . è un (possibilmente vuoto) sequenza di generatori o protezioni, si traduce   a:.
  e.flatMap { case p => for (p0 <- e0 . . .) yield e00 }

  

• A per-la comprensione for (p <- e; p0 <- e0 . . .) e00 dove. . . è un (possibilmente vuoto) sequenza di generatori o protezioni sono convertiti in:   
  e.foreach { case p => for (p0 <- e0 . . .) e00 }.

  

• A p <- e generatore seguito da un if g guardia viene traslato in un unico generatore:
    p <- e.filter((x1, . . . , xn) => g )
  dove x1,. . . , xn sono le variabili libere   di p.

  

• A p <- e generatore seguita da una definizione val p0 = e0 valore viene tradotto   al seguente generatore di coppie di valori, in cui x e x0 sono nomi freschi:

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

  

Answer 3

In questo caso, è davvero un po 'di magia compilatore. La traduzione da per-la comprensione di filtro / carta / modulo flatmap è un po 'speciale di Dezuccheraggio, proprio come la conversione delle forme speciali di aggiornamento e applicare metodi.