Costruire una LazyList
Costruisca sequenze lazy.
Costruire una LazyList è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Scala for Backend Engineering & Functional Programming, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.
Fondamenti della costruzione
Esistono diversi modi per costruire una LazyList. Il più semplice è la factory apply, proprio come per costruire una List.
La vera potenza deriva però dai costruttori che mantengono lazy la coda, che esploreremo in questa lezione.
val ll = LazyList(10, 20, 30)
println(ll.head)La LazyList vuota
LazyList.empty è il terminatore, l'equivalente lazy di Nil. Ogni LazyList finita termina con esso.
Lo si usa come caso base quando si antepongono elementi con #::.
object Demo extends App {
val empty = LazyList.empty[Int]
println(empty.isEmpty)
println(empty.toList)
}Anteporre elementi con #::
L'operatore #:: aggiunge una testa a una coda by-name. Costruisca la lista da destra a sinistra, terminando con LazyList.empty.
Poiché #:: riceve la coda in modo lazy, nulla oltre la testa viene costruito finché non viene forzato.
object Demo extends App {
val ll = 1 #:: 2 #:: 3 #:: LazyList.empty
println(ll.toList)
}Osservare la valutazione lazy
Inserisca un effetto collaterale nella coda per osservare quando viene eseguito. Solo forzando la coda lo si attiva.
Esegua questo codice: "building tail" viene stampato solo dopo l'accesso al secondo elemento, non quando viene definita la LazyList.
object Demo extends App {
val ll = 1 #:: { println("building tail"); 2 #:: LazyList.empty }
println("defined")
println(ll.head)
println(ll(1))
}Usare cons esplicitamente
Internamente #:: è LazyList.cons. Sia la testa sia la coda sono by-name in cons, offrendo il pieno controllo sulla valutazione.
È utile quando si definiscono generatori ricorsivi.
val ll = LazyList.cons(1, LazyList.cons(2, LazyList.empty))
println(ll.head)Generatori ricorsivi
Una LazyList può fare riferimento a se stessa. Definisca una funzione che produca una testa e richiami ricorsivamente se stessa per la coda.
Poiché la coda è by-name, la ricorsione non viene eseguita all'infinito: si interrompe finché non viene richiesta ciascuna cella.
def countFrom(n: Int): LazyList[Int] =
n #:: countFrom(n + 1)
println(countFrom(5).take(3).toList)Eseguire un generatore
Eseguiamo un generatore autoreferenziale e preleviamo alcuni valori. take limita il numero di celle forzate.
Senza take il ciclo sarebbe infinito, quindi limiti sempre un generatore infinito prima di forzarlo.
object Demo extends App {
def countFrom(n: Int): LazyList[Int] =
n #:: countFrom(n + 1)
println(countFrom(1).take(5).toList)
}Da un Iterator
È possibile racchiudere una collezione o un iteratore esistente. LazyList.from(start) costruisce una sequenza infinita crescente, mentre someList.to(LazyList) converte dati già noti eager.
In questo modo si ottiene una vista lazy sui dati già disponibili o descrivibili.
object Demo extends App {
val ll = List(1, 2, 3).to(LazyList)
println(ll.map(_ * 2).toList)
}LazyList.iterate
LazyList.iterate(seed)(f) applica ripetutamente f per costruire ogni elemento successivo a partire da quello precedente.
È un modo chiaro per esprimere sequenze definite da una regola di passaggio, come le potenze di due.
object Demo extends App {
val powers = LazyList.iterate(1)(_ * 2)
println(powers.take(6).toList)
}LazyList.continually
LazyList.continually(expr) ripete un'espressione all'infinito, rivalutandola per ogni elemento. È utile per stream costanti o casuali.
Lo combini con take per ottenere una porzione finita.
object Demo extends App {
val zeros = LazyList.continually(0)
println(zeros.take(4).toList)
}Scegliere un costruttore
Usi apply per liste piccole e fisse, #:: o cons per la ricorsione scritta manualmente, iterate per le regole di passaggio, from per il conteggio e continually per la ripetizione.
Tutti mantengono lazy la coda, quindi la scelta dipende dall'espressività.
Verifica rapida
Verifichi la sua comprensione della costruzione di LazyList.
Riepilogo
Ha costruito LazyList con apply, empty, #::/cons, iterate, from e continually.
La coda by-name rende sicura la definizione di generatori autoreferenziali e potenzialmente infiniti. Ora sfrutteremo questa caratteristica per creare stream davvero infiniti.
Impara Scala con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 39
- Lezioni
- 143
Domande Frequenti
La lezione «Costruire una LazyList» è gratuita?
Sì — il testo completo di «Costruire una LazyList» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Scala for Backend Engineering & Functional Programming, passa a CoddyKit PRO. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.
Cosa imparerò in «Costruire una LazyList»?
Costruisca sequenze lazy. Eserciti Scala for Backend Engineering & Functional Programming con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Scala for Backend Engineering & Functional Programming?
Non è richiesta alcuna esperienza precedente. Scala for Backend Engineering & Functional Programming su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.
Quanto tempo richiede la lezione «Costruire una LazyList»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Scala for Backend Engineering & Functional Programming?
Sì. Ogni lezione Scala for Backend Engineering & Functional Programming include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- La pigrizia spiegata
- Costruire una LazyList
- Stream infiniti
- Prelevare e filtrare in modo lazy