Sequenze pigre

pigra(percorribile)#

Rende pigra una lista, un intervallo, un testo, un dizionario o un canale.

Non copia niente subito: gli elementi arrivano mentre percorri. Serve per concatenare mappa/filtra/prendi senza costruire liste in mezzo.

pigra(1..1000000).mappa(quadrato).prendi(5).a_lista()

numeri_infiniti(inizio = 0, passo = 1)#

I numeri inizio, inizio+passo, inizio+2*passo, ... SENZA fine.

È pigra: non finisce mai da sola, quindi usala con prendi(n) o finche(...).

stampa(numeri_infiniti(1).prendi(5).a_lista())

[1, 2, 3, 4, 5]

genera_sequenza(stato, passo)#

Costruisci una sequenza pigra passo dopo passo, partendo da stato.

A ogni passo chiama passo(stato): se dà nulla la sequenza finisce; altrimenti deve dare una lista [valore, nuovo_stato]: valore entra nella sequenza e nuovo_stato è lo stato del passo dopo.

genera_sequenza([0, 1], funzione (s) restituisci [s[0], [s[1], s[0] + s[1]]] fine)

ripeti_valore(valore, volte = nulla)#

Una sequenza pigra con lo stesso valore ripetuto.

Con volte lo ripete quel numero di volte; senza volte lo ripete SENZA fine (usala con prendi).

stampa(ripeti_valore("ciao", 3).a_lista())

["ciao", "ciao", "ciao"]

.a_lista()#

Percorre tutta la sequenza e ne fa una lista vera.

ATTENZIONE: su una sequenza senza fine non termina mai. Usa prima prendi(n) o finche(...).

stampa(numeri_infiniti(1).prendi(3).a_lista())

[1, 2, 3]

.con_indice(da = 0)#

Una nuova sequenza di coppie [indice, elemento] (pigra).

Comoda con per ogni i, x in sequenza.con_indice() fai.

stampa(pigra(["a", "b"]).con_indice().a_lista())

[[0, "a"], [1, "b"]]

.conta()#

Quanti elementi ha la sequenza (la percorre tutta).

ATTENZIONE: su una sequenza senza fine non termina mai. Usa prima prendi(n) o finche(...).

stampa(numeri_infiniti(1).prendi(100).conta())

100

.filtra(funzione)#

Una nuova sequenza con solo gli elementi per cui la funzione dà vero (pigra).

numeri_infiniti(1).filtra(funzione (x) restituisci x % 2 == 0 fine)

.finche(funzione)#

Elementi dall'inizio FINCHÉ la funzione dà vero, poi si ferma (pigra).

Appena un elemento dà falso, la sequenza finisce (quello e i successivi non ci sono).

numeri_infiniti(1).finche(funzione (x) restituisci x < 100 fine)

.mappa(funzione)#

Una nuova sequenza con la funzione applicata a ogni elemento (pigra).

numeri_infiniti(1).mappa(funzione (x) restituisci x * x fine)

.per_ciascuno(funzione)#

Chiama la funzione su ogni elemento (per gli effetti, es. stampare).

ATTENZIONE: su una sequenza senza fine non termina mai. Non dà un risultato (nulla).

pigra([1, 2, 3]).per_ciascuno(stampa)

1
2
3

.prendi(quanti)#

Una nuova sequenza con solo i primi quanti elementi.

È il modo normale per "chiudere" una sequenza senza fine.

stampa(numeri_infiniti(1).prendi(3).a_lista())

[1, 2, 3]

.primo(predefinito = nulla)#

Il primo elemento, o predefinito se la sequenza è vuota.

Calcola solo il primo elemento (il resto no).

stampa(numeri_infiniti(10).primo())

10

.riduci(funzione, iniziale)#

Combina tutti gli elementi in un solo valore (percorre tutta la sequenza).

La funzione riceve il risultato "fin qui" e l'elemento successivo.

stampa(numeri_infiniti(1).prendi(4).riduci(funzione (t, x) restituisci t + x fine))

10

.salta(quanti)#

Una nuova sequenza senza i primi quanti elementi.

stampa(numeri_infiniti(1).salta(2).prendi(3).a_lista())

[3, 4, 5]

.salta_finche(funzione)#

Salta gli elementi iniziali FINCHÉ la funzione dà vero, poi dà il resto (pigra).

stampa(pigra([1, 2, 10, 3]).salta_finche(funzione (x) restituisci x < 5 fine).a_lista())

[10, 3]

.trova(funzione, predefinito = nulla)#

Il primo elemento per cui la funzione dà vero.

Si ferma appena lo trova (gli elementi dopo non vengono calcolati). Se non c'è, dà predefinito.

stampa(numeri_infiniti(1).trova(funzione (x) restituisci x * x > 50 fine))

8

.unisci(altra)#

Una nuova sequenza con prima questi elementi e poi quelli di altra (pigra).

altra può essere un'altra sequenza pigra o una lista/intervallo/testo.

stampa(numeri_infiniti(1).prendi(2).unisci([9, 8]).a_lista())

[1, 2, 9, 8]