Programmazione avanzata

Verifiche e test#

Un test è un pezzo di codice che controlla che un altro pezzo di codice faccia la cosa giusta. In Leo i test si scrivono dentro il programma, con verifica "nome" fai … fine, e dentro si dice che cosa ci si aspetta con aspettati.

funzione doppio(n)    restituisci n * 2fine funzione voto_valido(testo_voto)    variabile v = intero(testo_voto)    se v < 0 o v > 10 allora        lancia ErroreValore("voto fuori scala")    fine    restituisci vfine verifica "doppio di un numero" fai    aspettati doppio(21) == 42    aspettati doppio(0) == 0fine verifica "un voto non valido" fai    aspettati errore ErroreValore fai        voto_valido("trenta")    fine    aspettati errore fai        voto_valido("11")    finefine

voti.leo
  ok  doppio di un numero
  ok  un voto non valido

2 verifiche: 2 riuscite.

Quando esegui il programma normalmente, i blocchi verifica non partono. Li esegue il comando leo verifica voti.leo (o leo verifica cartella, per tutti i file), che stampa un rapporto: ok in verde per le verifiche riuscite e, per le altre, la riga, il valore atteso e quello ottenuto.

funzione triplo(n)    restituisci n * 2        # errore: dovrebbe essere n * 3fine verifica "triplo" fai    aspettati triplo(3) == 9fine

sbagliato.leo
  NO  triplo  (riga 6)
      aspettati triplo(3) == 9
      Aspettativa non rispettata: 6 == 9 è falso.
      atteso:   9
      ottenuto: 6

1 verifica: 0 riuscite, 1 non riuscita.

• aspettati condizione controlla un valore; con un confronto il rapporto mostra atteso e ottenuto;
• aspettati errore TipoErrore fai … fine: il codice dentro deve dare quell'errore (senza tipo: un errore qualunque);
• ogni verifica ha le sue variabili; chiedi non si può usare;
• leo verifica esce con 0 se tutto è verde, 1 altrimenti: comodo negli script automatici.

Temporizzatori: ogni e dopo#

ogni ripete un blocco a intervalli regolari; dopo lo esegue una volta sola, più tardi. Nel frattempo il programma va avanti.

variabile secondi = 0ogni 1 secondo fai    secondi += 1    stampa("{secondi}...")finedopo 3.5 secondi fai    ferma_temporizzatori()    stampa("Tempo scaduto!")fine

1...
2...
3...
Tempo scaduto!

• le unità sono secondi (o s), millisecondi (o ms) e minuti: ogni secondo fai, dopo 300ms fai;
• un programma testuale resta vivo finché ci sono temporizzatori attivi; ferma_temporizzatori() li ferma tutti;
• nei programmi con le finestre il corpo gira come un gestore quando e l'interfaccia resta viva. In alternativa c'è il controllo Timer con l'evento scatto.

Lavori lunghi: in parallelo#

Un calcolo lungo può partire in parallelo mentre il programma continua. aspetta(lavoro) ne dà il risultato (quello di restituisci).

funzione conta_primi(fino_a)    restituisci lunghezza(primi_fino_a(fino_a))fine variabile lavoro = in parallelo fai    restituisci conta_primi(2000000)finestampa("Sto contando...")stampa("Primi fino a due milioni: {aspetta(lavoro):migliaia}")

Sto contando...
Primi fino a due milioni: 148.933

• lavoro.finito() dice se ha finito; aspetta(lavoro, 5) aspetta al massimo 5 secondi; aspetta([l1, l2]) aspetta più lavori;
• se il lavoro dà un errore, aspetta lo ripete, così lo puoi gestire con prova;
• un lavoro in parallelo non tocca i controlli delle finestre e non usa messaggio o chiedi: mostra il risultato dopo aspetta, oppure controlla lavoro.finito() con un ogni.

Modelli di testo#

Un modello descrive una forma di testo, per cercare «tutti i numeri», «tutte le email», «le date». Leo ha scorciatoie leggibili come <cifre>, <numero>, <parola>, <spazi>, <email>, <data>, <ora>, e dei modelli pronti con modello("codice fiscale").

variabile testo_mail = "Scrivete ad ada@esempio.it o a bruno@scuola.it entro il 30/09/2026"stampa(trova_tutti("3 gatti e 12 pesci", "<cifre>"))stampa(trova_tutti(testo_mail, "<email>"))stampa(trova_primo(testo_mail, "<data>"))stampa(corrisponde("12345", "<cifre>"), corrisponde("12a45", "<cifre>"))stampa(sostituisci_modello("Tel. 06 1234 5678", "<cifre>", "#"))stampa(sostituisci_con_gruppi("Rossi Mario", "(\\w+) (\\w+)", "$2 $1"))

["3", "12"]
["ada@esempio.it", "bruno@scuola.it"]
30/09/2026
vero falso
Tel. # # #
Mario Rossi

Funzioni: trova_tutti, trova_primo, corrisponde (tutto il testo segue il modello), contiene_modello, sostituisci_modello, dividi_modello, e per i gruppi trova_corrispondenza, gruppi_modello, sostituisci_con_gruppi. Tutte accettano ignora_maiuscole = vero.

La catena |>#

valore |> funzione vuol dire funzione(valore): i passaggi si leggono da sinistra a destra, nell'ordine in cui avvengono. Con altri argomenti, valore |> f(a, b) vuol dire f(valore, a, b).

variabile voti = [4, 7, 9, 5, 8, 10]variabile totale = voti    |> filtra(funzione (v) restituisci v >= 6 fine)    |> sommastampa(totale)"  leo parla italiano " |> pulisci |> maiuscolo |> stampa[3, 1, 2] |> ordina |> stampa

34
LEO PARLA ITALIANO
[1, 2, 3]

Funzioni come valori#

In Leo le funzioni sono valori come gli altri: si mettono in una variabile, si passano ad altre funzioni, si restituiscono. Una funzione ricorda le variabili del posto in cui è nata (una chiusura).

variabile doppio = funzione (x) restituisci x * 2 finestampa(mappa([1, 2, 3], doppio)) funzione crea_contatore()    variabile conteggio = 0    funzione incrementa()        conteggio += 1        restituisci conteggio    fine    restituisci incrementafinevariabile conta = crea_contatore()conta(); conta()stampa(conta()) funzione media_di(valori...)    restituisci somma(valori) / lunghezza(valori)finestampa(media_di(6, 7, 8))variabile voti = [5, 9, 10]stampa(media_di(voti...)) funzione area(base: decimale, altezza: decimale)    restituisci base * altezza / 2finestampa(area(3, 4.5))

[2, 4, 6]
3
7.0
8.0
6.75

• tre puntini dopo l'ultimo parametro (valori...) raccolgono tutti gli argomenti in più; nella chiamata (voti...) fanno il contrario;
• i tipi dei parametri sono facoltativi (base: decimale) e vengono controllati a ogni chiamata;
• una funzione può chiamare se stessa fino a 1.000 volte annidate; oltre c'è ErroreRicorsione.

Programmi in più file: importa#

Un programma lungo si può dividere in più file. importa esegue un altro file .leo e ne rende disponibili i nomi:

importa forme come fimporta matematica come m stampa(arrotonda(f.area_cerchio(2), 2))stampa(f.area_quadrato(5))stampa(m.radice(81))

12.57
25
9.0

funzione area_cerchio(r)    restituisci PI_GRECO * r * rfine funzione area_quadrato(lato)    restituisci lato * latofine

• importa "forme.leo" porta i nomi direttamente nel programma; importa forme come f li tiene «dentro» f (f.area_cerchio), così non si mescolano con i tuoi;
• anche i gruppi della libreria si importano con un nome (importa matematica come m);
• Leo cerca il file nella cartella di chi importa, poi in quella del programma; ogni file si esegue una volta sola.

Lo stile delle dichiarazioni#

Il modo di scrivere le dichiarazioni si può scegliere, per tutto il progetto (sezione [stile] di progetto.toml, o Strumenti → Stile del codice in Leo Studio) oppure per un singolo file, con una prima riga #stile:.

#stile: variabile sia, costante fissa, funzione procedura, parametri con, predefiniti valefissa IVA vale 22sia prezzo vale 100procedura con_iva con importo, aliquota vale IVA    restituisci importo + importo * aliquota / 100finestampa(con_iva(prezzo))stampa(con_iva(prezzo, aliquota vale 10))

122.0
110.0

Le forme canoniche funzionano sempre. Con lo stile implicito (x = 0) Leo non può più accorgersi dei refusi nei nomi, e te lo ricorda. Per convertire un progetto da uno stile all'altro, Leo Studio mostra le differenze e chiede conferma prima di riscrivere i file.

La riga di comando#

Le opzioni più usate: --rigoroso, --semplice, --correggi=no, --tema bianco. Codici d'uscita: 0 tutto bene, 1 errore nel programma, 2 comando scritto male. Leo funziona anche con ingresso e uscita reindirizzati: leo calcolatrice.leo < risposte.txt legge una riga per ogni chiedi.