Type Alias in Rust

I type alias in Rust permettono di creare nomi alternativi per tipi esistenti, rendendo il codice più leggibile e manutenibile.

Definire un Type Alias

type Chilometri = f64;
type Secondi = f64;

fn velocita(distanza: Chilometri, tempo: Secondi) -> f64 {
    distanza / tempo
}

fn main() {
    let v = velocita(100.0, 3600.0);
    println!("Velocità: {} km/s", v);
}

Nota: un alias è solo un nome alternativo. Chilometri e f64 sono intercambiabili, il compilatore non distingue tra i due.

Semplificare Tipi Complessi

type Risultato<T> = Result<T, Box<dyn std::error::Error>>;
type Callback = Box<dyn Fn(i32) -> i32>;
type MappaUtenti = std::collections::HashMap<String, Vec<Utente>>;

fn elabora() -> Risultato<String> {
    Ok("tutto ok".to_string())
}

fn registra_callback(cb: Callback) {
    let risultato = cb(42);
    println!("{}", risultato);
}

Alias con Generics

type Coppia<T> = (T, T);
type ListaDi<T> = Vec<T>;

fn somma_coppia(c: Coppia<i32>) -> i32 {
    c.0 + c.1
}

// Alias per Result con errore fisso (pattern comune nella std)
type IoResult<T> = Result<T, std::io::Error>;

Pattern Newtype

Per creare un tipo davvero distinto (non solo un alias), usa il pattern newtype con una tuple struct:

struct Metri(f64);
struct Secondi(f64);

impl Metri {
    fn new(valore: f64) -> Self {
        Metri(valore)
    }
}

fn velocita(distanza: Metri, tempo: Secondi) -> f64 {
    distanza.0 / tempo.0
}

fn main() {
    let d = Metri::new(100.0);
    let t = Secondi(9.58);
    let v = velocita(d, t);
    // velocita(t, d); // ERRORE! I tipi sono diversi
}

Il newtype pattern è preferibile quando serve type safety reale.

Differenza tra Alias e Newtype

// ALIAS: stesso tipo, intercambiabile
type Eta = u32;
let e: Eta = 25;
let n: u32 = e; // OK, sono lo stesso tipo

// NEWTYPE: tipo diverso, non intercambiabile
struct Eta(u32);
let e = Eta(25);
// let n: u32 = e; // ERRORE: tipi diversi
let n: u32 = e.0; // OK, accesso esplicito

Quando Usare Type Alias

• Per abbreviare tipi complessi e ripetitivi
• Per documentare l’intento di un tipo (type UserId = u64)
• Per facilitare il refactoring (cambi il tipo in un solo punto)

Quando Usare Newtype

• Per garantire che tipi semanticamente diversi non vengano confusi
• Per implementare trait su tipi esterni
• Per nascondere l’implementazione interna

Conclusione

I type alias migliorano la leggibilità del codice senza aggiungere overhead. Per una vera distinzione tra tipi, usa il pattern newtype. La scelta dipende dal livello di sicurezza necessario: gli alias sono un aiuto alla documentazione, i newtype sono una garanzia del compilatore.