Svogliati
🦀

Rustper Svogliati

Il linguaggio veloce come il C che non ti lascia sparare nei piedi. Ci prova il compilatore a spararti, ma solo prima che il programma parta.

"Se compila, funziona" — detto da ogni rustacean, subito prima di scoprire un bug di logica che il compilatore, onestamente, non poteva sapere.

↓
01 / 15

Come è nato (colpa di un ascensore)

Un programmatore, un ascensore rotto, 21 piani di scale e un'idea fissa: il software non dovrebbe crashare per un puntatore sbagliato.

💡 La leggenda dell'ascensore

Nel 2006 Graydon Hoare, sviluppatore Mozilla, torna a casa e trova l'ascensore del palazzo fuori servizio. Di nuovo. Il software che lo controllava era andato in crash, probabilmente per un errore di memoria. Mentre sale 21 piani a piedi pensa che sia assurdo che nel 2006 non si riesca a scrivere software di sistema veloce e sicuro. Arrivato a casa apre il portatile e inizia un linguaggio tutto suo. Lo chiama Rust, come i funghi della ruggine: organismi "over-engineered for survival", parole sue.

2006

Progetto personale

Hoare scrive il primo compilatore in OCaml. Il linguaggio di allora era molto diverso: aveva un garbage collector, i "green thread" e una sintassi che oggi non riconosceresti.

2009-2010

Mozilla ci crede

Mozilla sponsorizza il progetto: serve un linguaggio per Servo, un motore di rendering web parallelo e sicuro. Nel 2010 Rust viene presentato al pubblico.

2011

Rust compila sé stesso

Il compilatore rustc viene riscritto in Rust, con backend LLVM. Da qui in poi tolgono più cose di quante ne aggiungano: via il GC, via i green thread, dentro l'ownership.

15 maggio 2015

Rust 1.0

Prima versione stabile, con la promessa che regge ancora: il codice che compila oggi compila anche domani. Una release ogni 6 settimane, puntuale come un treno svizzero (non uno italiano).

2016

Il linguaggio "più amato"

Primo posto nel sondaggio Stack Overflow come linguaggio più amato (poi "più ammirato"), posizione tenuta per anni di fila. Amato soprattutto da chi lo usa già: chi lo sta imparando ha opinioni più colorite.

2017

Rust dentro Firefox

Firefox Quantum integra Stylo, il motore CSS scritto in Rust e nato da Servo. Parallelo su tutti i core, e senza i crash che avrebbe avuto in C++.

2018

Prima edition

Arriva l'edition 2018: un modo per cambiare la sintassi senza rompere il codice vecchio. Ogni crate dichiara la sua edition e convive con le altre. Poi 2021 e 2024 (con Rust 1.85, febbraio 2025).

2020-2021

Mozilla taglia, nasce la Foundation

Ad agosto 2020 Mozilla licenzia buona parte del team. Il progetto non muore: a febbraio 2021 nasce la Rust Foundation, fondata da AWS, Google, Huawei, Microsoft e Mozilla.

2022

Rust entra nel kernel Linux

Linux 6.1 (dicembre 2022) accetta il primo supporto per scrivere codice del kernel in Rust. Linus Torvalds, noto per la sua pazienza, non ha bloccato tutto. Questo dice molto.

Oggi

Ovunque, in silenzio

Android, Chromium, componenti del kernel Windows, Firecracker di AWS (dietro Lambda), Cloudflare, Discord, Dropbox, e strumenti che usi tutti i giorni senza saperlo: ripgrep, fd, bat, uv, ruff.

🦀 Ferris e i rustaceanLa mascotte non ufficiale è Ferris, un granchio arancione. Chi programma in Rust si fa chiamare rustacean (da crustacean, crostaceo). Sì, la community è fatta così.
02 / 15

Perché esiste

Per decenni hai dovuto scegliere: veloce e pericoloso (C, C++) oppure sicuro e lento (linguaggi con garbage collector). Rust dice: perché non tutti e due?

📊 Il 70% del problemaMicrosoft e il team di Chromium hanno misurato la stessa cosa: circa il 70% delle vulnerabilità gravi nei loro prodotti viene da errori di gestione della memoria. Use-after-free, buffer overflow, double free. Errori che in Rust sicuro non compilano proprio.

⚡ Veloce come C/C++

  • Compila in codice macchina nativo tramite LLVM
  • Niente garbage collector: nessuna pausa imprevista
  • Zero-cost abstractions: iteratori e generici costano come il ciclo scritto a mano
  • Controllo totale su layout in memoria e allocazioni

🛡️ Sicuro come Java/Go

  • Memory safety garantita a compilazione
  • Niente null: c'è Option
  • Niente eccezioni nascoste: c'è Result
  • Niente data race fra thread: il compilatore le rifiuta
📦

Cargo

Build, dipendenze, test, documentazione e pubblicazione in un solo comando. Il package manager che C++ sogna da 40 anni.

💬

Errori leggibili

Il compilatore ti dice cosa è sbagliato, dove, perché e spesso come correggerlo. Più che un compilatore, un tutor severo.

🔧

Tooling di serie

rustfmt formatta, clippy ti corregge lo stile, rust-analyzer fa l'IDE. Tutti ufficiali.

🎯

Un binario solo

Compili, copi il file sul server, fine. Niente runtime da installare, niente virtualenv, niente "da me funziona".

📉 Funziona davvero?

Google ha pubblicato i numeri di Android: scrivendo il codice nuovo in linguaggi memory-safe (Rust in testa), la quota di vulnerabilità legate alla memoria è scesa da circa il 76% nel 2019 a circa il 24% nel 2024, senza riscrivere il codice vecchio. Il codice vecchio si "stabilizza", il codice nuovo non introduce più quella classe di bug.

03 / 15

Quando usarlo (e quando lasciar perdere)

Rust non è la risposta a tutto. È la risposta giusta quando sbagliare costa caro: prestazioni, sicurezza, affidabilità a lungo termine.

Rust è una buona idea per

  • Tool da riga di comando veloci e distribuiti come binario unico
  • Servizi di rete, proxy, server ad alto carico
  • Software di sistema: driver, kernel, firmware, embedded
  • Parser e codice che legge input non fidato
  • Moduli veloci per Python o Node (PyO3, napi-rs)
  • WebAssembly nel browser
  • App desktop leggere (Tauri, egui, iced)
  • Codice che deve girare per anni senza sorprese

Meglio altro per

  • Script da 20 righe e automazioni veloci: Python o bash
  • Prototipi da buttare la settimana prossima
  • Data science e notebook: Python vince ancora
  • CRUD web classico con un team che conosce già Django/Rails/Laravel
  • Progetti con scadenza domani e nessuno che conosce Rust
  • App mobile native (si può, ma non è la strada più comoda)
ConfrontoScegli Rust se...Scegli l'altro se...
vs CVuoi la stessa velocità senza buffer overflow, e un package managerLa piattaforma ha solo un compilatore C, o il codice esistente è enorme
vs C++Parti da zero e vuoi sicurezza garantita, non "se segui le linee guida"Devi usare librerie C++ pesanti (Qt, Unreal) o il team è esperto di C++
vs GoServono latenza prevedibile, zero GC, controllo fine sulla memoriaVuoi un servizio di rete scritto in fretta da un team che impara in una settimana
vs PythonContano velocità (10-100 volte), binario unico, tipi rigorosiConta la velocità di scrittura, o vivi di librerie scientifiche
vs Java/C#Niente runtime, avvio istantaneo, poca RAMEcosistema enterprise già in piedi, team già formato
⏳ Il prezzo da pagareLa curva di apprendimento è ripida: le prime settimane litigherai con il borrow checker. Anche la compilazione è lenta rispetto a Go. In cambio, il tempo che non passi a debuggare crash in produzione lo recuperi con gli interessi.
04 / 15

Ownership, borrowing e lifetime

L'idea che rende Rust diverso da tutto il resto. Capita questa, il resto è sintassi.

💡 L'analogia del libro

Hai un libro. È tuo (ownership): quando lo butti, sparisce. Puoi regalarlo (move): da quel momento non è più tuo, non puoi più leggerlo. Puoi prestarlo in lettura a quanti amici vuoi contemporaneamente (&T), ma nessuno ci scrive sopra. Oppure puoi prestarlo a un solo amico con la matita (&mut T), e finché ce l'ha lui nessun altro lo tocca, nemmeno tu. E nessuno può tenersi il libro in prestito dopo che l'hai buttato (lifetime).

REGOLA 1

Un solo proprietario

Ogni valore ha esattamente un owner. Quando l'owner esce dallo scope, il valore viene liberato (drop). Niente free(), niente GC.

REGOLA 2

Tanti lettori oppure uno scrittore

In ogni momento puoi avere N riferimenti immutabili (&T) oppure 1 mutabile (&mut T). Mai le due cose insieme.

REGOLA 3

Il prestito non sopravvive al libro

Un riferimento non può vivere più a lungo del valore a cui punta. Niente puntatori penzolanti (dangling).

🚚 Move: regalare il valore

rust
let a = String::from("ciao");
let b = a;                 // la stringa ora appartiene a b
println!("{a}");          // ERRORE: borrow of moved value `a`

let c = b.clone();         // copia esplicita: due stringhe distinte
println!("{b} {c}");      // ok

let x = 5;
let y = x;                 // i tipi semplici (i32, bool, char...) sono Copy:
println!("{x} {y}");      // vengono copiati, x resta valido

I tipi che stanno nello stack e costano poco da copiare (numeri, bool, char, tuple di questi) implementano Copy. Tutto ciò che possiede memoria nello heap (String, Vec, Box) si sposta.

🤝 Borrowing: prestare il valore

rust
fn lunghezza(s: &String) -> usize {   // prende in prestito, non possiede
    s.len()
}

fn aggiungi_punto(s: &mut String) {     // prestito con la matita
    s.push('.');
}

fn main() {
    let mut testo = String::from("ciao");
    let n = lunghezza(&testo);        // testo resta di main
    aggiungi_punto(&mut testo);
    println!("{testo} ({n})");        // "ciao. (4)"

    let r1 = &testo;
    let r2 = &testo;                    // due lettori: ok
    let w = &mut testo;                // ERRORE se r1/r2 vengono usati dopo
    println!("{r1} {r2}");
}

Il compilatore è furbo: un prestito "finisce" all'ultimo punto in cui viene usato, non alla chiusura della graffa (si chiama NLL, non-lexical lifetimes). Se sposti il println! prima di &mut testo, compila.

⏱️ Lifetime: quanto dura il prestito

Quasi sempre il compilatore deduce da solo quanto vive un riferimento. Quando una funzione restituisce un riferimento e non è chiaro da quale parametro arrivi, glielo dici tu con un'annotazione 'a:

rust
// "il risultato vive quanto il più corto fra x e y"
fn piu_lunga<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() >= y.len() { x } else { y }
}

// una struct che contiene un riferimento deve dichiararne la durata
struct Estratto<'a> {
    testo: &'a str,
}

// 'static = vive per tutto il programma (es. le stringhe letterali)
let s: &'static str = "sono nel binario";

Le lifetime non cambiano quanto vive un valore: descrivono relazioni che esistono già, così il compilatore può controllarle.

💡 Trucco da svogliatoAll'inizio, se il borrow checker ti blocca e hai fretta: .clone(). Costa un po' di memoria, ma sblocca. Ottimizzerai dopo, quando capirai cosa stava cercando di dirti.
05 / 15

Installare Rust e usare Cargo

Un installer, un comando per creare il progetto, uno per lanciarlo. Fine della configurazione.

⬇️ Installazione con rustup

shell
# Linux / macOS
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Windows: scarica rustup-init.exe da rustup.rs (serve anche Visual Studio Build Tools)

rustc --version          # il compilatore
cargo --version          # il tuttofare
rustup update            # aggiorna all'ultima stable (ogni 6 settimane)
rustup component add clippy rustfmt rust-analyzer

rustup gestisce le versioni (stable, beta, nightly) e i target di cross-compilazione, per esempio rustup target add aarch64-unknown-linux-gnu per un Raspberry Pi a 64 bit.

📦 Il primo progetto

shell
cargo new ciao          # binario (--lib per una libreria)
cd ciao
cargo run               # compila in debug e lancia
cargo build --release   # binario ottimizzato in target/release/ciao
cargo check             # controlla senza produrre il binario: molto più veloce
cargo test              # lancia i test
cargo fmt               # formatta tutto il codice
cargo clippy            # linter: centinaia di consigli
cargo add serde --features derive   # aggiunge una dipendenza
cargo doc --open        # documentazione tua e delle dipendenze
struttura
ciao/
├── Cargo.toml      # nome, versione, edition, dipendenze
├── Cargo.lock      # versioni esatte risolte (committalo per i binari)
├── src/
│   ├── main.rs     # punto d'ingresso di un binario
│   └── lib.rs      # radice di una libreria (opzionale)
├── tests/          # test di integrazione
└── target/         # output di compilazione (nel .gitignore)
Cargo.toml
[package]
name = "ciao"
version = "0.1.0"
edition = "2024"

[dependencies]
serde = { version = "1", features = ["derive"] }
tokio = { version = "1", features = ["full"] }

[profile.release]
lto = true          # ottimizzazione fra crate
strip = true        # binario più piccolo

Le librerie si chiamano crate e stanno su crates.io. La documentazione di ognuna è generata in automatico su docs.rs.

06 / 15

Le basi: variabili, tipi, funzioni, cicli

La parte che somiglia agli altri linguaggi. Con qualche sorpresa.

📌 Variabili e mutabilità

rust
let x = 5;              // immutabile di default
x = 6;                  // ERRORE: cannot assign twice to immutable variable

let mut y = 5;          // mutabile solo se lo chiedi
y += 1;

let z = 5;
let z = z * 2;          // shadowing: una NUOVA variabile con lo stesso nome
let z = "ora è testo";  // può anche cambiare tipo

const MAX_UTENTI: u32 = 100;        // costante, tipo obbligatorio
static NOME: &str = "svogliati";   // valore globale con indirizzo fisso

🔢 Tipi primitivi

TipoEsempiNote
Interi con segnoi8 i16 i32 i64 i128 isizei32 è il default
Interi senza segnou8 u16 u32 u64 u128 usizeusize per indici e lunghezze
Virgola mobilef32 f64f64 è il default
Booleanobooltrue, false
CaratterecharUnicode, 4 byte: '🦀' è un char valido
Tupla(i32, f64, char)Accesso con t.0, t.1
Array[i32; 5]Lunghezza fissa, nello stack
Slice&[i32], &strUna "finestra" su dati di qualcun altro
Unit()Il "niente", come void
🧵 String vs &strString possiede il testo (nello heap, può crescere). &str è un prestito di testo che sta da qualche parte (in una String o nel binario). Regola pratica: i parametri delle funzioni prendono &str, le struct contengono String.
➕ OverflowIn debug un overflow intero fa panic, in release fa il giro (wrap). Se ti serve un comportamento preciso, dillo: checked_add, wrapping_add, saturating_add. Le conversioni fra tipi sono sempre esplicite: x as u64 oppure u8::try_from(x).

🔧 Funzioni ed espressioni

rust
fn somma(a: i32, b: i32) -> i32 {
    a + b        // niente punto e virgola = valore restituito
}

fn dividi(a: f64, b: f64) -> f64 {
    if b == 0.0 {
        return 0.0;   // return esplicito per uscire prima
    }
    a / b
}

// quasi tutto è un'espressione: anche if e i blocchi
let segno = if x >= 0 { "positivo" } else { "negativo" };
let area = {
    let lato = 4;
    lato * lato  // il blocco vale 16
};

🔁 Cicli

rust
for i in 0..5 { }          // 0,1,2,3,4
for i in 0..=5 { }         // 0..5 incluso
for i in (0..10).rev().step_by(2) { }

let nomi = vec!["arx", "nomina", "missus"];
for (i, nome) in nomi.iter().enumerate() {
    println!("{i}: {nome}");
}

while contatore < 10 { contatore += 1; }

// loop infinito che può restituire un valore
let risultato = loop {
    tentativi += 1;
    if tentativi == 3 { break tentativi * 10; }
};

// etichette per uscire da cicli annidati
'esterno: for x in 0..10 {
    for y in 0..10 {
        if x * y == 42 { break 'esterno; }
    }
}
07 / 15

Struct, enum e match

Niente classi, niente ereditarietà. Dati da una parte, comportamento dall'altra, e un match che non ti lascia dimenticare nessun caso.

🧱 Struct e impl

rust
#[derive(Debug, Clone, PartialEq)]   // implementazioni automatiche
struct Server {
    nome: String,
    porta: u16,
    attivo: bool,
}

impl Server {
    // funzione associata (niente self): il "costruttore" per convenzione
    fn new(nome: &str, porta: u16) -> Self {
        Self { nome: nome.to_string(), porta, attivo: true }
    }

    fn indirizzo(&self) -> String {     // legge
        format!("{}:{}", self.nome, self.porta)
    }

    fn spegni(&mut self) {               // modifica
        self.attivo = false;
    }

    fn distruggi(self) { }               // consuma: dopo la chiamata non esiste più
}

let mut s = Server::new("artemis", 443);
s.spegni();
println!("{:?}", s);                     // stampa grazie a Debug

// struct tupla e struct vuota
struct Metri(f64);                       // "newtype": un f64 che non puoi confondere
struct Segnaposto;

🎭 Enum: molto più che costanti

Ogni variante di un enum può portarsi dietro dati diversi. È il modo di Rust per dire "questo valore è una di queste cose".

rust
enum Messaggio {
    Esci,                              // nessun dato
    Sposta { x: i32, y: i32 },          // campi con nome
    Scrivi(String),                    // un valore
    Colore(u8, u8, u8),               // tre valori
}

fn gestisci(m: Messaggio) {
    match m {
        Messaggio::Esci => println!("ciao"),
        Messaggio::Sposta { x, y } => println!("vado a {x},{y}"),
        Messaggio::Scrivi(testo) => println!("{testo}"),
        Messaggio::Colore(r, g, b) => println!("#{r:02x}{g:02x}{b:02x}"),
    }   // se dimentichi una variante: non compila
}

🔍 Pattern matching

rust
let descrizione = match codice_http {
    200 => "ok",
    301 | 302 => "redirect",               // più valori
    400..=499 => "colpa tua",               // intervalli
    n if n >= 500 => "colpa del server",      // guardia
    _ => "boh",                             // tutto il resto
};

// destrutturare tuple e struct
let (a, b) = (1, 2);
let Server { nome, porta, .. } = s;

// if let: quando ti interessa un caso solo
if let Some(utente) = trova_utente(id) {
    println!("trovato {utente}");
}

// let else: estrai o esci
let Some(config) = leggi_config() else {
    return;
};

// while let: cicla finché il pattern combacia
while let Some(elemento) = pila.pop() { }

// matches!: un match che restituisce bool
let e_errore = matches!(codice_http, 400..=599);
08 / 15

Option, Result e la gestione degli errori

Niente null, niente eccezioni. Se una cosa può mancare o fallire, lo dice il tipo, e non puoi far finta di niente.

❓ Option<T>

Un valore che può esserci o no. Sostituisce null, che il suo inventore Tony Hoare chiama "il mio errore da un miliardo di dollari".

rust
enum Option<T> {
    Some(T),
    None,
}

✅ Result<T, E>

Un'operazione che può riuscire o fallire. L'errore fa parte della firma: chi chiama sa che deve gestirlo.

rust
enum Result<T, E> {
    Ok(T),
    Err(E),
}

❗ L'operatore ?

Il punto interrogativo dice: "se è un errore, restituiscilo subito al chiamante; se è ok, dammi il valore". Rimpiazza pagine di if err != nil.

rust
use std::fs;
use std::io;

fn leggi_porta(percorso: &str) -> Result<u16, Box<dyn std::error::Error>> {
    let testo = fs::read_to_string(percorso)?;   // errore di I/O → esce
    let porta = testo.trim().parse::<u16>()?;   // errore di parsing → esce
    Ok(porta)
}

fn main() {
    match leggi_porta("porta.txt") {
        Ok(p) => println!("ascolto su {p}"),
        Err(e) => eprintln!("errore: {e}"),
    }
}

🧰 I metodi che userai ogni giorno

MetodoCosa faQuando
unwrap()Estrae il valore, panic se mancaPrototipi e test. In produzione è una bomba a orologeria
expect("msg")Come unwrap, con un messaggioQuando sei certo che non fallisca, e dici perché
unwrap_or(v)Valore di default se mancaporta.unwrap_or(8080)
unwrap_or_default()Usa il Default del tipo0, stringa vuota, vettore vuoto
map(f)Trasforma il valore dentro, se c'ènome.map(|n| n.to_uppercase())
and_then(f)Concatena operazioni che possono fallireParsing a più passaggi
ok_or(e)Trasforma Option in ResultPer poter usare ? su un Option
map_err(f)Trasforma il tipo di erroreAdattare errori di librerie diverse
is_some() / is_ok()Controlla senza estrarreNei filtri e nelle condizioni

🏷️ Errori tuoi: thiserror e anyhow

Regola diffusa: nelle librerie definisci un enum di errori preciso (crate thiserror), nelle applicazioni usi anyhow, che accetta qualsiasi errore e ci aggiunge contesto.

rust
// libreria
#[derive(Debug, thiserror::Error)]
enum ConfigError {
    #[error("file non trovato: {0}")]
    NonTrovato(String),
    #[error("porta non valida")]
    PortaNonValida(#[from] std::num::ParseIntError),
}

// applicazione
use anyhow::{Context, Result};

fn main() -> Result<()> {
    let cfg = std::fs::read_to_string("/etc/app.toml")
        .context("non riesco a leggere la configurazione")?;
    Ok(())
}
💥 panic! non è un'eccezionepanic! è per i bug, non per gli errori previsti: fa terminare il thread (o il programma). File mancante, input sbagliato, rete giù sono situazioni normali: si gestiscono con Result.
09 / 15

Trait e generici

Il posto dell'ereditarietà lo prendono i trait: "questo tipo sa fare queste cose". Come le interfacce, ma più potenti.

🧩 Definire e implementare un trait

rust
trait Controllo {
    fn nome(&self) -> String;
    fn esegui(&self) -> bool;

    // metodo con implementazione di default
    fn rapporto(&self) -> String {
        let esito = if self.esegui() { "OK" } else { "KO" };
        format!("[{esito}] {}", self.nome())
    }
}

struct Ping { host: String }

impl Controllo for Ping {
    fn nome(&self) -> String { format!("ping {}", self.host) }
    fn esegui(&self) -> bool { true }
}

🧬 Generici: statico contro dinamico

rust
// generico: il compilatore genera una versione per ogni tipo (velocissimo)
fn stampa<T: Controllo>(c: &T) { println!("{}", c.rapporto()); }

// stessa cosa, sintassi corta
fn stampa2(c: &impl Controllo) { }

// più vincoli: con where è più leggibile
fn confronta<T>(a: T, b: T) -> T
where
    T: PartialOrd + std::fmt::Display,
{
    if a > b { a } else { b }
}

// dinamico (trait object): tipi diversi nella stessa lista, costo di una chiamata indiretta
let controlli: Vec<Box<dyn Controllo>> = vec![
    Box::new(Ping { host: "1.1.1.1".into() }),
    // Box::new(Http { ... }), Box::new(Dns { ... }), ...
];
for c in &controlli { println!("{}", c.rapporto()); }

// struct generica
struct Coppia<T> { a: T, b: T }

⭐ I trait della libreria standard da conoscere

TraitCosa abilita
DebugStampa con {:?} (quasi sempre con #[derive])
DisplayStampa con {}, da implementare a mano
Clone / CopyCopia esplicita con .clone() / copia implicita
PartialEq / EqConfronto con ==
PartialOrd / OrdConfronto con < > e ordinamento
HashUsare il tipo come chiave di HashMap
DefaultUn valore di partenza con T::default()
From / IntoConversioni fra tipi (String::from, .into())
IteratorPoter fare for x in ... e usare map/filter
DropCodice eseguito quando il valore viene distrutto
Send / SyncIl tipo può passare fra thread / essere condiviso fra thread
10 / 15

Closure e iteratori

Lo stile funzionale che compila in un ciclo for ottimizzato. Leggibile come Python, veloce come C.

λ Closure

rust
let doppio = |x| x * 2;
let somma = |a: i32, b: i32| -> i32 { a + b };

let soglia = 10;
let sopra = |x: i32| x > soglia;     // cattura soglia per riferimento

let nome = String::from("job");
let f = move || println!("{nome}");  // move: la closure si prende nome (serve con i thread)

// accettare una closure come parametro
fn applica<F: Fn(i32) -> i32>(f: F, v: i32) -> i32 { f(v) }

Tre "gusti": Fn (legge ciò che cattura), FnMut (lo modifica), FnOnce (lo consuma, chiamabile una volta). Il compilatore sceglie da solo il più permissivo possibile.

⛓️ Iteratori

rust
let numeri = vec![1, 2, 3, 4, 5, 6];

let pari_al_quadrato: Vec<i32> = numeri
    .iter()                     // &i32, non consuma il vettore
    .filter(|n| *n % 2 == 0)
    .map(|n| n * n)
    .collect();                 // [4, 16, 36]

let totale: i32 = numeri.iter().sum();
let massimo = numeri.iter().max();             // Option<&i32>
let primo_grande = numeri.iter().find(|&&n| n > 4);
let tutti_positivi = numeri.iter().all(|&n| n > 0);

let righe: Vec<String> = testo
    .lines()
    .map(str::trim)
    .filter(|r| !r.is_empty() && !r.starts_with('#'))
    .map(String::from)
    .collect();
MetodoProduceIl vettore dopo
.iter()&TAncora tuo
.iter_mut()&mut TTuo, modificato
.into_iter()TConsumato, non esiste più

Gli iteratori sono pigri: finché non chiami collect, sum, for o simili, non succede niente. Altri utili: zip, chain, take, skip, windows, chunks, fold, flat_map, any, position.

11 / 15

Collezioni e smart pointer

Dove mettere i dati, e cosa fare quando la regola "un solo proprietario" ti sta stretta.

🗃️ Collezioni

rust
use std::collections::{HashMap, HashSet, BTreeMap, VecDeque};

// Vec: lista che cresce
let mut v: Vec<i32> = Vec::new();
v.push(1);
let terzo = v.get(2);          // Option: None se fuori range
let terzo = v[2];              // panic se fuori range

// HashMap: chiave → valore
let mut visite: HashMap<String, u32> = HashMap::new();
visite.insert("home".into(), 1);
*visite.entry("rust".into()).or_insert(0) += 1;   // il contatore classico
if let Some(n) = visite.get("home") { }
for (pagina, n) in &visite { }

// HashSet: valori unici · BTreeMap: chiavi ordinate · VecDeque: coda a due capi

📍 Smart pointer

TipoCosa faQuando serve
Box<T>Mette il valore nello heap, un solo proprietarioTipi ricorsivi (alberi, liste), trait object, valori grandi
Rc<T>Più proprietari, conteggio dei riferimentiGrafi e strutture condivise, un solo thread
Arc<T>Come Rc, con contatore atomicoDati condivisi fra più thread
RefCell<T>Mutabilità controllata a runtimeModificare dentro un Rc (panic se violi le regole)
Mutex<T>Un thread alla volta modificaCon Arc: Arc<Mutex<T>>
RwLock<T>Tanti lettori o uno scrittore, fra threadDati letti spesso e scritti di rado
Cow<T>Prestito che diventa copia solo se serveFunzioni che a volte modificano l'input
rust
// un albero: senza Box il tipo avrebbe dimensione infinita
enum Albero {
    Foglia(i32),
    Nodo(Box<Albero>, Box<Albero>),
}

use std::rc::Rc;
use std::cell::RefCell;

let condiviso = Rc::new(RefCell::new(vec![1, 2]));
let altro = Rc::clone(&condiviso);        // copia il puntatore, non i dati
altro.borrow_mut().push(3);
println!("{:?}", condiviso.borrow());        // [1, 2, 3]
12 / 15

Thread, canali e async

"Fearless concurrency": le stesse regole dell'ownership impediscono le data race. Se condividi qualcosa fra thread in modo sbagliato, non compila.

🧵 Thread e dati condivisi

rust
use std::sync::{Arc, Mutex};
use std::thread;

let contatore = Arc::new(Mutex::new(0));
let mut handle = Vec::new();

for _ in 0..8 {
    let c = Arc::clone(&contatore);
    handle.push(thread::spawn(move || {
        *c.lock().unwrap() += 1;      // il lock si rilascia da solo a fine scope
    }));
}
for h in handle { h.join().unwrap(); }
println!("{}", *contatore.lock().unwrap());   // 8

// thread con scope: possono prendere in prestito variabili locali
let dati = vec![1, 2, 3];
thread::scope(|s| {
    s.spawn(|| println!("{:?}", dati));
});

📨 Canali: comunicare invece di condividere

rust
use std::sync::mpsc;

let (tx, rx) = mpsc::channel();
for id in 0..3 {
    let tx = tx.clone();
    thread::spawn(move || tx.send(format!("worker {id} fatto")).unwrap());
}
drop(tx);                              // chiude il canale originale
for msg in rx { println!("{msg}"); }   // finisce quando tutti i tx sono chiusi

⚡ async/await con Tokio

Per migliaia di connessioni di rete i thread costano troppo. async trasforma una funzione in una future che si sospende mentre aspetta I/O. Rust fornisce la sintassi, il runtime lo scegli tu: quasi sempre Tokio.

rust
use tokio::time::{sleep, Duration};

async fn controlla(host: &str) -> bool {
    sleep(Duration::from_millis(100)).await;   // non blocca il thread
    true
}

#[tokio::main]
async fn main() {
    // due controlli in parallelo
    let (a, b) = tokio::join!(controlla("arx"), controlla("nomina"));

    // un task in background
    let task = tokio::spawn(async { controlla("missus").await });
    let c = task.await.unwrap();
}
⚠️ Non bloccare il runtimeDentro una funzione async non chiamare operazioni bloccanti (std::thread::sleep, I/O sincrono pesante, calcoli lunghi): fermi tutti gli altri task. Usa le versioni async di Tokio o tokio::task::spawn_blocking.
13 / 15

Moduli, test, macro e unsafe

Come organizzare il codice, come testarlo, e le due porte di servizio del linguaggio.

📁 Moduli e visibilità

src/main.rs
mod rete;                 // carica src/rete.rs (o src/rete/mod.rs)

use rete::client::connetti;
use std::collections::HashMap;

fn main() { connetti(); }
src/rete.rs
pub mod client {
    pub fn connetti() { handshake(); }     // pub: visibile fuori
    fn handshake() { }                     // privato di default
}

pub(crate) fn interna() { }               // visibile solo in questo crate

Tutto è privato di default. pub apre, pub(crate) apre solo dentro il progetto. crate:: parte dalla radice, super:: sale di un livello, self:: resta nel modulo.

🧪 Test integrati

rust
pub fn somma(a: i32, b: i32) -> i32 { a + b }

#[cfg(test)]                // compilato solo con cargo test
mod tests {
    use super::*;

    #[test]
    fn somma_base() {
        assert_eq!(somma(2, 2), 4);
    }

    #[test]
    #[should_panic]
    fn indice_fuori_range() {
        let v: Vec<i32> = vec![];
        v[0];
    }
}

Bonus: gli esempi di codice nei commenti di documentazione (///) vengono compilati ed eseguiti come test. La documentazione non può andare fuori sincronia con il codice.

✨ Macro

Le macro finiscono con ! e generano codice a compilazione. Le userai ogni giorno ben prima di scriverne una.

rust
println!("{nome} ha {anni} anni");   // formattazione controllata a compilazione
format!("{:>8.2}", prezzo);         // allineato a destra, 2 decimali
vec![0; 100];                       // 100 zeri
assert!(x > 0, "x deve essere positivo");
todo!();                             // compila, panica se eseguito: "lo faccio dopo"
unreachable!();                      // "qui non ci arrivi mai"
dbg!(&valore);                       // stampa file, riga, espressione e valore

// una macro tua, con macro_rules!
macro_rules! quadrato {
    ($x:expr) => { $x * $x };
}
let q = quadrato!(7);                 // 49

Le macro derive (#[derive(Serialize, Deserialize)] di serde, per esempio) generano implementazioni intere di trait. È così che Rust converte una struct in JSON senza riflessione a runtime.

☢️ unsafe

Un blocco unsafe sblocca cinque cose che il compilatore non può verificare: dereferenziare puntatori grezzi, chiamare funzioni unsafe (incluse quelle C via FFI), accedere a static mut, implementare trait unsafe, accedere ai campi delle union.

rust
unsafe extern "C" {
    fn abs(x: i32) -> i32;           // funzione della libc
}

let n = unsafe { abs(-3) };         // "garantisco io"

Il borrow checker resta acceso anche dentro unsafe: non è "modalità C", è "qui mi prendo io la responsabilità di queste cinque cose". L'idea è chiudere l'unsafe dentro piccole funzioni sicure e ben testate, come fa la libreria standard.

14 / 15

Litigare con il compilatore (e vincere)

Gli errori che vedrai di più nelle prime settimane, tradotti in italiano.

ErroreCosa vuol direCome se ne esce
E0382 borrow of moved valueHai usato una variabile dopo averla "regalata"Passa &x invece di x, oppure x.clone()
E0499 cannot borrow as mutable more than onceDue prestiti con la matita insiemeChiudi il primo prima di aprire il secondo, o dividi i dati
E0502 cannot borrow as mutable because it is also borrowed as immutableStai modificando qualcosa che stai anche leggendoClassico: modificare un Vec mentre lo iteri. Raccogli prima le modifiche, applicale dopo
E0106 missing lifetime specifierRestituisci un riferimento e non è chiaro da dove vengaAggiungi 'a, o restituisci un valore posseduto (String invece di &str)
E0597 does not live long enoughIl prestito sopravvive al valoreSposta la variabile in uno scope più esterno
E0308 mismatched typesTipo sbagliato, spesso un ; di troppo a fine funzioneTogli il punto e virgola dall'ultima espressione
E0277 trait bound not satisfiedIl tipo non sa fare quello che chiediAggiungi #[derive(...)] o il vincolo T: Trait
E0599 no method named ... foundMetodo inesistente o trait non importatoControlla gli use: molti metodi arrivano da trait
future cannot be sent between threadsDentro una async tieni qualcosa di non Send attraverso un .awaitRilascia il MutexGuard o l'Rc prima dell'await
📖 rustc --explainOgni codice d'errore ha la sua spiegazione con esempi: rustc --explain E0502. E leggi tutto il messaggio: spesso l'ultima riga è un help: con la correzione già scritta.

Buone abitudini

  • cargo clippy prima di ogni commit
  • cargo check mentre scrivi, build solo quando serve
  • Parametri &str e &[T], non String e Vec
  • ? e Result invece di unwrap
  • Enum per gli stati, così il match ti costringe a gestirli tutti
  • Newtype (struct UserId(u64)) per non confondere i numeri

Classici da evitare

  • unwrap() sparsi in codice di produzione
  • Riempire tutto di Rc<RefCell<...>> per scrivere Java in Rust
  • Lifetime ovunque per evitare un clone da 20 byte
  • unsafe "per far contento il compilatore"
  • Misurare le prestazioni con una build di debug
  • Struct che si riferiscono a sé stesse: cambia design
15 / 15

Da dove continuare

Quasi tutto il materiale migliore è gratuito e ufficiale.

🗺️ Un percorso in quattro tappe

  1. Settimana 1-2: leggi "The Book" fino al capitolo 10 e fai gli esercizi di Rustlings.
  2. Settimana 3-4: scrivi un piccolo tool da riga di comando con clap e anyhow: un parser di log, un controllo di porte, un rinominatore di file.
  3. Mese 2: capitoli su smart pointer, concorrenza e trait avanzati. Poi un servizio HTTP con tokio e axum.
  4. Dopo: leggi codice altrui (ripgrep è scritto benissimo) e il Rustonomicon solo quando ti serve davvero unsafe.
RisorsaCos'è
The Rust Programming Language (doc.rust-lang.org/book)"The Book": il manuale ufficiale, gratuito, si parte da qui
Rust by ExampleGli stessi concetti, ma solo esempi eseguibili
RustlingsPiccoli esercizi da sistemare finché compilano
Rust Playground (play.rust-lang.org)Compila e lancia codice nel browser, senza installare niente
std docs (doc.rust-lang.org/std)La documentazione della libreria standard, con esempi ovunque
Async Book e tutorial TokioPer capire async senza impazzire
The RustonomiconLe arti oscure di unsafe. Leggere solo con un adulto
blessed.rsElenco ragionato dei crate più usati per ogni esigenza

📦 I crate che userai di sicuro

EsigenzaCrate
Argomenti da riga di comandoclap
JSON, TOML, YAMLserde + serde_json / toml
Errorianyhow (app), thiserror (librerie)
Asynctokio
Server webaxum, actix-web
Client HTTPreqwest, ureq (sincrono)
Databasesqlx, rusqlite, diesel
Logtracing, log + env_logger
Parallelismo sui datirayon: cambi .iter() in .par_iter() e usi tutti i core
GUIegui, iced, tauri
🦀 L'ultimo consiglio da svogliatoIl borrow checker non ce l'ha con te. Ti sta dicendo, con molta insistenza, dove il tuo programma avrebbe crashato alle 3 di notte di un sabato. Ascoltalo adesso, e il sabato dormi.