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.
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.
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.
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.
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.
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.
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).
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.
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++.
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).
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.
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.
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.
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?
⚡ 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.
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)
| Confronto | Scegli Rust se... | Scegli l'altro se... |
|---|---|---|
| vs C | Vuoi la stessa velocità senza buffer overflow, e un package manager | La 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 Go | Servono latenza prevedibile, zero GC, controllo fine sulla memoria | Vuoi un servizio di rete scritto in fretta da un team che impara in una settimana |
| vs Python | Contano velocità (10-100 volte), binario unico, tipi rigorosi | Conta la velocità di scrittura, o vivi di librerie scientifiche |
| vs Java/C# | Niente runtime, avvio istantaneo, poca RAM | Ecosistema enterprise già in piedi, team già formato |
Ownership, borrowing e lifetime
L'idea che rende Rust diverso da tutto il resto. Capita questa, il resto è sintassi.
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).
Un solo proprietario
Ogni valore ha esattamente un owner. Quando l'owner esce dallo scope, il valore viene liberato (drop). Niente free(), niente GC.
Tanti lettori oppure uno scrittore
In ogni momento puoi avere N riferimenti immutabili (&T) oppure 1 mutabile (&mut T). Mai le due cose insieme.
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
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
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:
// "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.
.clone(). Costa un po' di memoria, ma sblocca. Ottimizzerai dopo, quando capirai cosa stava cercando di dirti.
Installare Rust e usare Cargo
Un installer, un comando per creare il progetto, uno per lanciarlo. Fine della configurazione.
⬇️ Installazione con rustup
# 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
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
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)
[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.
Le basi: variabili, tipi, funzioni, cicli
La parte che somiglia agli altri linguaggi. Con qualche sorpresa.
📌 Variabili e mutabilità
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
| Tipo | Esempi | Note |
|---|---|---|
| Interi con segno | i8 i16 i32 i64 i128 isize | i32 è il default |
| Interi senza segno | u8 u16 u32 u64 u128 usize | usize per indici e lunghezze |
| Virgola mobile | f32 f64 | f64 è il default |
| Booleano | bool | true, false |
| Carattere | char | Unicode, 4 byte: '🦀' è un char valido |
| Tupla | (i32, f64, char) | Accesso con t.0, t.1 |
| Array | [i32; 5] | Lunghezza fissa, nello stack |
| Slice | &[i32], &str | Una "finestra" su dati di qualcun altro |
| Unit | () | Il "niente", come void |
String 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.
checked_add, wrapping_add, saturating_add. Le conversioni fra tipi sono sempre esplicite: x as u64 oppure u8::try_from(x).
🔧 Funzioni ed espressioni
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
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; }
}
}
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
#[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".
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
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);
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".
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.
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.
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
| Metodo | Cosa fa | Quando |
|---|---|---|
unwrap() | Estrae il valore, panic se manca | Prototipi e test. In produzione è una bomba a orologeria |
expect("msg") | Come unwrap, con un messaggio | Quando sei certo che non fallisca, e dici perché |
unwrap_or(v) | Valore di default se manca | porta.unwrap_or(8080) |
unwrap_or_default() | Usa il Default del tipo | 0, 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 fallire | Parsing a più passaggi |
ok_or(e) | Trasforma Option in Result | Per poter usare ? su un Option |
map_err(f) | Trasforma il tipo di errore | Adattare errori di librerie diverse |
is_some() / is_ok() | Controlla senza estrarre | Nei 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.
// 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! è 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.
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
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
// 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
| Trait | Cosa abilita |
|---|---|
Debug | Stampa con {:?} (quasi sempre con #[derive]) |
Display | Stampa con {}, da implementare a mano |
Clone / Copy | Copia esplicita con .clone() / copia implicita |
PartialEq / Eq | Confronto con == |
PartialOrd / Ord | Confronto con < > e ordinamento |
Hash | Usare il tipo come chiave di HashMap |
Default | Un valore di partenza con T::default() |
From / Into | Conversioni fra tipi (String::from, .into()) |
Iterator | Poter fare for x in ... e usare map/filter |
Drop | Codice eseguito quando il valore viene distrutto |
Send / Sync | Il tipo può passare fra thread / essere condiviso fra thread |
Closure e iteratori
Lo stile funzionale che compila in un ciclo for ottimizzato. Leggibile come Python, veloce come C.
λ Closure
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
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();
| Metodo | Produce | Il vettore dopo |
|---|---|---|
.iter() | &T | Ancora tuo |
.iter_mut() | &mut T | Tuo, modificato |
.into_iter() | T | Consumato, 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.
Collezioni e smart pointer
Dove mettere i dati, e cosa fare quando la regola "un solo proprietario" ti sta stretta.
🗃️ Collezioni
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
| Tipo | Cosa fa | Quando serve |
|---|---|---|
Box<T> | Mette il valore nello heap, un solo proprietario | Tipi ricorsivi (alberi, liste), trait object, valori grandi |
Rc<T> | Più proprietari, conteggio dei riferimenti | Grafi e strutture condivise, un solo thread |
Arc<T> | Come Rc, con contatore atomico | Dati condivisi fra più thread |
RefCell<T> | Mutabilità controllata a runtime | Modificare dentro un Rc (panic se violi le regole) |
Mutex<T> | Un thread alla volta modifica | Con Arc: Arc<Mutex<T>> |
RwLock<T> | Tanti lettori o uno scrittore, fra thread | Dati letti spesso e scritti di rado |
Cow<T> | Prestito che diventa copia solo se serve | Funzioni che a volte modificano l'input |
// 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]
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
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
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.
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();
}
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.
Moduli, test, macro e unsafe
Come organizzare il codice, come testarlo, e le due porte di servizio del linguaggio.
📁 Moduli e visibilità
mod rete; // carica src/rete.rs (o src/rete/mod.rs)
use rete::client::connetti;
use std::collections::HashMap;
fn main() { connetti(); }
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
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.
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.
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.
Litigare con il compilatore (e vincere)
Gli errori che vedrai di più nelle prime settimane, tradotti in italiano.
| Errore | Cosa vuol dire | Come se ne esce |
|---|---|---|
E0382 borrow of moved value | Hai usato una variabile dopo averla "regalata" | Passa &x invece di x, oppure x.clone() |
E0499 cannot borrow as mutable more than once | Due prestiti con la matita insieme | Chiudi il primo prima di aprire il secondo, o dividi i dati |
E0502 cannot borrow as mutable because it is also borrowed as immutable | Stai modificando qualcosa che stai anche leggendo | Classico: modificare un Vec mentre lo iteri. Raccogli prima le modifiche, applicale dopo |
E0106 missing lifetime specifier | Restituisci un riferimento e non è chiaro da dove venga | Aggiungi 'a, o restituisci un valore posseduto (String invece di &str) |
E0597 does not live long enough | Il prestito sopravvive al valore | Sposta la variabile in uno scope più esterno |
E0308 mismatched types | Tipo sbagliato, spesso un ; di troppo a fine funzione | Togli il punto e virgola dall'ultima espressione |
E0277 trait bound not satisfied | Il tipo non sa fare quello che chiedi | Aggiungi #[derive(...)] o il vincolo T: Trait |
E0599 no method named ... found | Metodo inesistente o trait non importato | Controlla gli use: molti metodi arrivano da trait |
| future cannot be sent between threads | Dentro una async tieni qualcosa di non Send attraverso un .await | Rilascia il MutexGuard o l'Rc prima dell'await |
rustc --explain E0502. E leggi tutto il messaggio: spesso l'ultima riga è un help: con la correzione già scritta.
Buone abitudini
cargo clippyprima di ogni commitcargo checkmentre scrivi,buildsolo quando serve- Parametri
&stre&[T], nonStringeVec ?eResultinvece diunwrap- 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
Da dove continuare
Quasi tutto il materiale migliore è gratuito e ufficiale.
🗺️ Un percorso in quattro tappe
- Settimana 1-2: leggi "The Book" fino al capitolo 10 e fai gli esercizi di Rustlings.
- Settimana 3-4: scrivi un piccolo tool da riga di comando con
clapeanyhow: un parser di log, un controllo di porte, un rinominatore di file. - Mese 2: capitoli su smart pointer, concorrenza e trait avanzati. Poi un servizio HTTP con
tokioeaxum. - Dopo: leggi codice altrui (ripgrep è scritto benissimo) e il Rustonomicon solo quando ti serve davvero
unsafe.
| Risorsa | Cos'è |
|---|---|
| The Rust Programming Language (doc.rust-lang.org/book) | "The Book": il manuale ufficiale, gratuito, si parte da qui |
| Rust by Example | Gli stessi concetti, ma solo esempi eseguibili |
| Rustlings | Piccoli 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 Tokio | Per capire async senza impazzire |
| The Rustonomicon | Le arti oscure di unsafe. Leggere solo con un adulto |
| blessed.rs | Elenco ragionato dei crate più usati per ogni esigenza |
📦 I crate che userai di sicuro
| Esigenza | Crate |
|---|---|
| Argomenti da riga di comando | clap |
| JSON, TOML, YAML | serde + serde_json / toml |
| Errori | anyhow (app), thiserror (librerie) |
| Async | tokio |
| Server web | axum, actix-web |
| Client HTTP | reqwest, ureq (sincrono) |
| Database | sqlx, rusqlite, diesel |
| Log | tracing, log + env_logger |
| Parallelismo sui dati | rayon: cambi .iter() in .par_iter() e usi tutti i core |
| GUI | egui, iced, tauri |