Rust e i costrutti condizionali

Questa nuova lezione su Rust apre l'importantissimo argomento del controllo di flusso. Ovvero l'insieme di costrutti che servono a regolare la logica del programma in esecuzione, stabilendo blocchi di istruzioni che possono:

• essere eseguiti o meno in virtù del verificarsi di una specifica condizione;
• venire ripetuti più volte finché il risultato di uno specifico controllo continua a dare esito positivo.

Iniziamo parlando del primo caso, i costrutti condizionali.

Il costrutto if in Rust

Il primo passo da affrontare è lo studio del costrutto if. Fondamentale per determinare se un'operazione deve essere svolta o meno in base alla verifica di una condizione booleana.

Iniziamo subito con un esempio completo per prendere confidenza con questa funzionalità e le sue varie articolazioni:

fn main() {
          let voto:f32=8.5;
          if voto>=6.0 {
              println!("Voto sufficiente, esame superato: {}", voto);
          }
          else if voto>=5.0 && voto

Nell'esempio, valutiamo la variabile voto contenente il risultato di un esame. In base al suo livello, l'esame sarà stato superato (se il voto è almeno pari al 6), da completare con un orale di recupero (se si verifica un'insufficienza leggera tra il 5 e il 6) oppure fallito per un voto inferiore al 5.

Notiamo che il costrutto if deve essere associato ad un confronto booleano la cui veridicità determinerà l'esecuzione del blocco di codice collegato. Solo se il confronto darà esito falso, verrà tentato quello collegato all'else if. Come ultima chance verrà eseguito il blocco else nel caso in cui nessun confronto legato a if o else if abbia fornito esito positivo.

Si noti che le condizioni booleane non richiedono l'uso di parentesi tonde. Qualora le si impieghi ugualmente, ciò verrà ricordato in fase di compilazione con un warning. Tale regola vale per le condizioni impiegate in tutti i costrutti per il controllo di flusso in Rust, come vedremo in questa e nelle prossime lezioni.

Interessante vedere come il costrutto if può essere impiegato per l'assegnazione condizionale di una variabile. Se ad esempio volessimo scrivere l'esito dell'esame in una variabile di nome risultato potremmo usare il seguente impianto:

let risultato = if voto>=6.0 {
        "Voto sufficiente, esame superato"
}
else if voto>=5.0 && voto

In base al valore di voto e ai confronti esperiti, alla variabile risultato verrà assegnata una delle espressioni riportate tra parentesi graffe. Notare che in ogni blocco di codice, a seguito del confronto, viene restituita una stringa, mai seguita da un punto e virgola. L'unico punto e virgola utilizzato è posto alla fine della sequenza di confronti a dimostrazione che tutto consta di un'unica espressione.

Il costrutto match

Esiste anche un costrutto simile al classico switch..case che in Rust prende il nome di match. Permette di valutare il valore di una variabile e confrontarlo con una serie di casistiche. Sarà eseguita l'istruzione corrispondente alla prima occorrenza riscontrata.

Ad esempio:

let stelle=5;
        match stelle {
            0..=2 => println!("Prodotto non buono!"),
            3 | 4 => println!("Prodotto buono"),
            5 => println!("Prodotto ottimo"),
            _ => println!("Valutazione non valida"),
        }

Partiamo da una variabile di nome stelle che corrisponde al numero di stelle associate, immaginiamo, ad una recensione per un acquisto di un bene online. Ogni caso mette in relazione un valore o intervallo di valori con un'operazione di stampa da svolgere. Abbiamo scelto casi diversi (supponendo anche la possibilità di avere 0 stelle come risultato) per mostrare i vari modi in cui gli intervalli di valori possono essere indicati:

• 0..=2 rappresenta un intervallo che include i valori da 0 a 2 compresi;
• 3 | 4 il simbolo pipe (|) rappresenta un OR quindi pone un'alternativa tra più possibilità (anche più di 2), utile per valori non contigui per i quali la definizione di un intervallo non è possibile;
• 5, come si può immaginare, esemplifica il caso del valore singolo;
• _, il simbolo underscore, rappresenta il comportamento di default, non coincidente con nessun'altra casistica precedente.

Anche il match, come l'if, può essere impiegato per dare vita ad un'assegnazione dinamica. Riproponiamo l'esempio precedente evitando i println e restituendo un responso in una variabile stringa di nome giudizio:

let giudizio = match stelle {
            0..=2 => "Prodotto non buono!",
            3 | 4 => "Prodotto buono",
            5 => "Prodotto ottimo",
            _ => "Valutazione non valida",
        };

Anche in questo caso si noti che il punto e virgola appare solo alla fine dell'espressione. Non troviamo più dei println ma la reazione al confronto equivale alla sola restituzione di una stringa.

Questi sono i costrutti condizionali di base, necessari per poter iniziare ad istruire la nostra logica di programmazione. Un linguaggio ricco come Rust - non nascondiamo - permette degli impieghi più variegati di tali logiche ma li affronteremo in lezioni successive quando avremo acquisito, tra le nostre conoscenze, ulteriori elementi sintattici.