Rust: mutabilità delle variabili, costanti e visibilità

Una delle prime cose che si impara sulle variabili in Rust è che queste, per definizione, non appena create sono immutabili. Ciò ha dei risvolti importanti in quanto a sicurezza, ottimizzazione e gestione della memoria ma è un qualcosa che il programmatore deve tenere in debito conto per non avere problemi in fase di compilazione.

Se, ad esempio, provassimo a svolgere una somma incrementale di questo tipo:

let totale=0;
totale+=5;
totale+=10;
totale+=20;

Definendo una variabile totale, immutabile per definizione, al momento della compilazione otterremmo un errore di questo tipo:

error[E0384]: cannot assign twice to immutable variable `totale`

Per risolvere il problema, dovremmo utilizzare la parola chiave mut applicata alla dichiarazione della variabile totale. L'esempio seguente infatti:

fn main() {
      let mut totale=0;
      totale+=5;
      totale+=10;
      totale+=20;
      println!("Il totale consiste equivale a {}", totale);
  }

diventerebbe un programma completo che, una volta compilato ed avviato, restituirebbe il seguente output:

Il totale consiste equivale a 35

Interessante notare che l'errore di mancata mutabilità della variabile viene segnalato in fase di compilazione e ciò - sempre nella logica di Rust - mira a permettere l'esecuzione di programmi formalmente corretti: una volta che un programma Rust viene avviato è al sicuro da possibili bug.

Ricordiamo tuttavia che questo meccanismo ha la sua importanza dal punto di vista dei valori pertanto la mutabilità non va assegnata per abitudine ma esclusivamente quando davvero necessaria.

Costanti in Rust

In Rust, possiamo anche dichiarare delle costanti ovvero delle posizioni in memoria, non deputate ad essere modificate, che rappresentano dei punti fermi nell'elaborazione del programma, tipicamente allo scopo di costituire delle configurazioni o delle impostazioni basilari per il funzionamento del software. Per dichiararle, si utilizza la parola chiave const e, per convenzione, si fissa il nome della costante in maiuscolo:

const LIMITE: i32 = 50;

Ad esempio, con le seguenti righe di codice impostiamo una costante che definisce un ipotetico cambio dollaro/euro e lo utilizziamo per la conversione dell'importo:

fn main() {
      // tasso di cambio fissato
      const CAMBIO_US_EUR: f32 = 0.9;
      // variabile definita come mutabile
      let mut importo=100.0;
      importo*=CAMBIO_US_EUR;
      println!("Il valore convertito equivale a {}", importo);
  }

Scope di variabili in Rust

Già svolgendo i primi esempi di codice Rust, si nota come la sua sintassi sia fortemente basata sulle parentesi graffe. Queste - come in molti linguaggi C-like - servono per delimitare i cosiddetti blocchi di codice i quali hanno il compito di definire le istruzioni asservite ad uno specifico costrutto (cicli, operazioni condizionali, funzioni, etc.). Altro loro ruolo importante consiste però nel delimitare lo scope delle variabili ovvero i confini della loro visibilità all'interno del codice. Proviamo, ad esempio, ad innestare un blocco di codice in un semplice programma:

fn main() {
      let da_stampare=16;
      println!("Variabile all'inizio del programma: {}", da_stampare);
      { // inizia un nuovo blocco di codice
        let da_stampare="Buongiorno a tutti!";
        println!("Variabile nel blocco di codice interno: {}", da_stampare);
      }
      println!("Variabile alla fine del programma: {}", da_stampare);
  }

L'esempio è fondato su un main in cui dichiariamo una variabile due volte: una all'inizio del programma e una all'interno di un blocco di codice non collegato a nessun costrutto che consta semplicemente di una coppia di parentesi graffe.

L'output che otteniamo è il seguente:

Variabile all'inizio del programma: 16
Variabile nel blocco di codice interno: Buongiorno a tutti!
Variabile alla fine del programma: 16

Notiamo che viene stampato più volte il valore della variabile da_stampare che esiste in due versioni: dentro il blocco è una stringa, al di fuori del blocco (sia prima che dopo) è un numero intero. Questo ci dimostra non solo come il blocco limiti la visibilità della variabile ma anche come dentro di esso la variabile stringa dichiarata con lo stesso nome faccia "ombra" a quella esistente all'esterno.

Anche questo è un aspetto importante da tenere in considerazione per l'organizzazione dei valori nei propri programmi, sebbene sia sempre meglio evitare situazioni di confusione in cui una variabile locale ne oscura un'altra. Per il compilatore Rust ciò non sarà un problema ma la leggibilità del codice per gli sviluppatori ne potrebbe risultare compromessa.