Struct, Enum e Pattern Matching in Rust: Potenza dei Tipi Algebrici

Hai mai passato ore a debuggarre codice perché una variabile poteva avere stati impossibili? In Rust questo non succede. Noi che lavoriamo con sistemi reali da quasi un decennio – dalla contabilità alla programmazione di basso livello – abbiamo visto quanto i tipi algebrici facciano la differenza. Non è solo teoria accademica: è il modo più solido per modellare dati complessi senza sorprese a runtime.

Il problema che risolviamo: stati illegali e null pointer

In linguaggi con gerarchie di classi, spesso ti ritrovi con enumerazioni che sono solo numeri e oggetti che possono essere nulli. Ogni accesso è un rischio. Noi, di Meteora Web, abbiamo gestito ERP di negozi di abbigliamento: immagina un articolo che può essere “In magazzino”, “In vetrina”, “Venduto” o “Reso”. In Java o Python lo modelleresti con un campo stringa e tanti if. In Rust lo fai con un enum e il compilatore controlla tutto.

Struct: dati aggregati con controllo fine

Le struct sono il modo più comune per raggruppare campi correlati. A differenza delle classi, non esiste ereditarietà: si compone, non si eredita. Questo evita gerarchie fragili.

struct Articolo {
    id: u32,
    nome: String,
    prezzo: f64,
    stato: StatoArticolo,
}

enum StatoArticolo {
    InMagazzino,
    InVetrina { scaffale: u8, ripiano: u8 },
    Venduto { data: String, cliente: String },
    Reso { motivo: String, rimborso: f64 },
}

Osserva come ogni variante di StatoArticolo può avere dati diversi. Questo è un tipo algebrico somma (sum type). Il compilatore ti obbliga a gestire tutti i casi quando fai pattern matching.

Pattern matching: smontare i dati con garanzie

Il pattern matching è lo strumento che rende i tipi algebrici potenti. Con match e if let puoi estrarre dati e decidere il flusso senza mai lasciare un caso scoperto.

fn gestisci_articolo(art: &Articolo) {
    match &art.stato {
        StatoArticolo::InMagazzino => println!("Articolo {} disponibile", art.nome),
        StatoArticolo::InVetrina { scaffale, ripiano } => {
            println!("Articolo {} in vetrina: scaffale {}, ripiano {}", art.nome, scaffale, ripiano);
        },
        StatoArticolo::Venduto { data, cliente } => {
            println!("Venduto il {} a {}", data, cliente);
        },
        StatoArticolo::Reso { motivo, rimborso } => {
            println!("Reso per '{}' - rimborso {}€", motivo, rimborso);
        },
    }
}

Se aggiungi una nuova variante a StatoArticolo, il compilatore segnala ogni match che non la gestisce. Questo elimina bug a runtime. Noi lo chiamiamo “il compilatore come revisore di codice gratis”.

Enum con dati: molto più di una lista di varianti

Gli enum in Rust sono tipi algebrici sum: ogni variante può contenere dati di tipo arbitrario, anche altre enum o struct. Questo permette di modellare strutture ricorsive come alberi.

enum Espressione {
    Numero(f64),
    Somma(Box<Espressione>, Box<Espressione>),
    Prodotto(Box<Espressione>, Box<Espressione>),
    Variabile(String),
}

fn valuta(expr: &Espressione, variabili: &HashMap<String, f64>) -> f64 {
    match expr {
        Espressione::Numero(n) => *n,
        Espressione::Somma(a, b) => valuta(a, variabili) + valuta(b, variabili),
        Espressione::Prodotto(a, b) => valuta(a, variabili) * valuta(b, variabili),
        Espressione::Variabile(nome) => *variabili.get(nome).unwrap_or(&0.0),
    }
}

Qui Box serve perché le enum sono di dimensione fissa. È il tipico pattern per strutture ricorsive. Il pattern matching smonta l’espressione in modo sicuro.

Pattern matching avanzato: guardie, binding e refutability

Il pattern matching non si ferma ai casi semplici. Puoi aggiungere condizioni con if (guardie), catturare riferimenti con ref e lavorare con pattern irrefutabili (sempre veri) o refutabili (che possono fallire).

fn classifica_prezzo(prezzo: f64) -> &'static str {
    match prezzo {
        p if p < 10.0 => "Budget",
        p if p < 50.0 => "Medio",
        p if p < 200.0 => "Premium",
        _ => "Lusso",
    }
}

Attenzione: i match devono essere esaustivi. Se non gestisci tutti i casi, il compilatore si lamenta. Questo ti obbliga a pensare a ogni possibilità.

Il costrutto if let

Quando vuoi gestire solo un caso specifico e ignorare gli altri, if let è più compatto di match.

if let StatoArticolo::Venduto { data, cliente } = &articolo.stato {
    println!("Venduto a {} il {}", cliente, data);
} else {
    println!("Non ancora venduto");
}

È syntactic sugar per un match con un solo braccio e il _ per il resto.

Tipi algebrici e performance: nessun overhead a runtime

Una domanda che ci fanno spesso: “ma tutto questo controllo non rallenta il programma?”. No. I pattern match vengono compilati in semplici salti condizionali. Il compilatore genera codice macchina efficiente quanto una serie di if-else scritti a mano, ma con garanzie statiche. Noi lo abbiamo misurato su sistemi di logging e parser: stack enum con pattern matching è spesso più veloce di gerarchie di classi dinamiche.

Errori comuni da evitare

• Dimenticare il case generico con _ quando non serve – ma attenzione: se la enum ha varianti senza dati, non usare _ perché se aggiungi una variante il compilatore non ti avviserà. Meglio elencare esplicitamente tutte le varianti.
• Usare if let quando serve anche il ramo else: spesso un match è più chiaro.
• Pattern matching su riferimenti: quando matchi un riferimento, i pattern devono usare & oppure usare ref per vincolare.

let r = &StatoArticolo::InMagazzino;
match r {
    &StatoArticolo::InMagazzino => println!("in magazzino"),
    // oppure
    StatoArticolo::InMagazzino => println!("in magazzino"), // autodeferenziazione
    _ => (),
}

Come integrare struct enum pattern matching nel tuo progetto

Ecco una checklist per progettare i tuoi tipi algebrici:

1. Identifica gli stati possibili di un'entità (es. ordine: in attesa, in lavorazione, spedito, consegnato, annullato).
2. Crea un enum con una variante per ogni stato, inserendo nei dati solo le informazioni necessarie per quello stato.
3. Usa match in tutti i punti in cui devi reagire allo stato. Il compilatore ti obbligherà a gestire ogni caso.
4. Quando lo stato cambia, costruisci una nuova istanza dell'enum – mai mutare un campo “stato” a caso.

In sintesi – cosa fare adesso

1. Riscrivi un sistema a stati con enum in Rust: prendi un pezzo di codice esistente in un altro linguaggio che usa flag o stringhe per lo stato, e convertilo in un enum. Vedrai sparire if annidati.
2. Prova a modellare un albero (es. espressioni matematiche, file system) con enum ricorsivi. Fai pattern matching per visitarlo.
3. Attiva i warning del compilatore su varianti inutilizzate (#![deny(unused_variants)]) – ti costringerà a pulire il codice.
4. Leggi la documentazione ufficiale su Enum e Pattern Matching per approfondire.

Noi, di Meteora Web, abbiamo costruito piattaforme di e-commerce e sistemi di logging usando questi principi. Quando il compilatore dice OK, possiamo dormire sonni tranquilli. I tipi algebrici non sono un lusso accademico: sono la rete di sicurezza che ogni sviluppatore professionista merita.