Shadowing in Rust

Lo shadowing in Rust permette di dichiarare una nuova variabile con lo stesso nome di una precedente, “oscurando” la variabile originale nello scope corrente.

Cos’è lo Shadowing

fn main() {
    let x = 5;
    let x = x + 1;    // Nuova variabile x, oscura la precedente
    let x = x * 2;    // Nuova variabile x, oscura di nuovo

    println!("{}", x); // 12
}

Ogni let x crea una nuova variabile: non modifica la precedente.

Shadowing vs Mutabilità

Lo shadowing è diverso da mut:

fn main() {
    // Con mut: stessa variabile, modificata
    let mut y = 5;
    y = 10; // OK: stessa variabile, stesso tipo

    // Con shadowing: nuova variabile
    let x = 5;
    let x = 10; // Nuova variabile con lo stesso nome
}

Cambiare Tipo con Shadowing

La differenza principale: lo shadowing permette di cambiare il tipo:

fn main() {
    // OK con shadowing: da &str a usize
    let spazi = "   ";
    let spazi = spazi.len(); // Ora spazi è usize (3)

    // ERRORE con mut: non puoi cambiare tipo
    // let mut spazi = "   ";
    // spazi = spazi.len(); // ERRORE: tipi incompatibili
}

Shadowing tra Scope

Una variabile in uno scope interno può oscurare quella dello scope esterno:

fn main() {
    let x = 5;

    {
        let x = "ciao"; // Oscura x nello scope interno
        println!("{}", x); // "ciao"
    }

    println!("{}", x); // 5 - la x originale è intatta
}

Casi d’Uso Comuni

Parsing dell’Input

fn main() {
    let input = "42";
    let input: i32 = input.parse().unwrap();
    // Riutilizziamo "input" ma ora è un i32
    println!("{}", input + 8); // 50
}

Trasformazione Progressiva

fn main() {
    let dati = " Ciao, Mondo! ";
    let dati = dati.trim();
    let dati = dati.to_lowercase();
    let dati = dati.replace(",", "");

    println!("{}", dati); // "ciao mondo!"
}

Scartare il Wrapper

fn main() {
    let config = std::env::var("HOME");
    let config = config.unwrap_or_else(|_| "/default".to_string());
    // config è ora String, non Result<String, VarError>
}

Quando Usare lo Shadowing

• Quando trasformi un valore attraverso più passaggi
• Quando il tipo cambia ma il significato semantico resta lo stesso
• Quando vuoi mantenere l’immutabilità (ogni let crea una variabile immutabile)

Quando Evitarlo

• Se rende il codice confuso o difficile da seguire
• Se la variabile originale serve ancora dopo il shadowing
• In funzioni lunghe dove potrebbe nascondere bug

Conclusione

Lo shadowing è una caratteristica idiomatica di Rust che permette di trasformare valori mantenendo nomi significativi e immutabilità. A differenza di mut, consente di cambiare tipo e crea sempre una nuova variabile. Usalo quando rende il codice più chiaro, specialmente per trasformazioni sequenziali di dati.