Articoli approfonditi sulla tecnologia che plasma il futuro.

Rust 1.100: il never type, dieci anni di attesa

Rust 1.100 stabilizza finalmente il never type, gli allocator personalizzati e i cooldown delle dipendenze in Cargo. Cosa insegnano 100 release.

Una lunga scalinata di pietra costruita gradino dopo gradino su una collina, con gli attrezzi del muratore appoggiati a metà del lavoro
Cento piccoli gradini, tutti alla stessa altezza: la cadenza di rilascio di Rust come filosofia di costruzione.

Ecco uno scenario che dovrebbe essere straordinario e invece non lo è: esegui rustup update stable un giovedì mattina, ricompili un workspace con qualche centinaio di crate e mezzo milione di righe di codice, e tutto compila. Nessun avviso di deprecazione inatteso, nessuna rottura improvvisa in una dipendenza transitiva, nessun frenetico blocco delle versioni. Con Rust 1.100, una release davvero enorme che finalmente porta il never type dopo dieci anni di tentativi, la cosa più interessante è quanto sarà tranquillo l'aggiornamento per quasi tutti. Non è un caso. È il frutto di cento release di disciplina istituzionale, e vale la pena leggere questa uscita come si leggerebbe un documento di design.

Il never type, dieci anni in costruzione

La funzionalità principale di 1.100 è un tipo che, per definizione, non ha valori. Il never type, scritto !, è il tipo disabitato per eccellenza: descrive computazioni che non producono mai un valore, come un loop infinito, un return, un panic!() o una chiamata a std::process::exit. I teorici dei tipi conoscono questa figura da moltissimo tempo: è il tipo bottom, il ⊥ del lambda calcolo, l'insieme vuoto che sta in un angolo del tuo reticolo di tipi. Gli utenti di Haskell lo conoscono come Void. Rust gli gira intorno fin dalla 1.0 e ci sono voluti dieci anni e cinque tentativi di stabilizzazione falliti per portarlo a casa.

Perché così difficile? Perché ! può essere forzato a qualsiasi altro tipo, ed è proprio questo il suo potere, e ogni punto di coercizione è un posto in cui inferenza dei tipi, risoluzione dei trait e controllo di esaustività devono essere d'accordo. Poiché un ramo di match che diverge ha tipo !, questo codice compila:

fn infallible_unwrap<T>(res: Result<T, !>) -> T {
// ^^ naming `!` in a type position like this
// was not allowed on stable before 1.100
let Ok(v) = res;
v
}

La riga let Ok(v) = res; è il premio: visto che Err(!) non può mai esistere, il compilatore accetta il pattern irrefutabile e un'intera categoria di chiamate difensive a unreachable!() sparisce. Insieme a questo, il vecchio enum std::convert::Infallible diventa un alias di tipo per !, quindi ogni API scritta con Infallible negli ultimi anni è automaticamente compatibile con il vero never type. Questa unificazione era il piano fin dall'inizio, ed è anche il motivo per cui la stabilizzazione continuava a slittare: cambiare l'alias richiedeva di cambiare il fallback del never type nelle edizioni precedenti al 2024, una modifica tecnicamente incompatibile.

Guarda come il team ha gestito questa rottura, perché in miniatura racchiude tutta la filosofia. Hanno rilasciato con largo anticipo avvisi di compatibilità futura, testato l'ecosistema con Crater e inviato proattivamente correzioni ai crate pubblici che sarebbero stati colpiti. Una modifica incompatibile, eseguita nell'arco di più cicli di rilascio, con il raggio d'impatto misurato e corretto prima che la maggior parte degli utenti se ne accorgesse. Confronta con la solita mossa dell'industria: alzare la versione major e fare spallucce. Ho già scritto di a cosa si impegna davvero Rust con la soundness: la saga del never type è la versione a livello di processo dello stesso impegno. Quando la tua garanzia è "il codice sicuro non può avere comportamento indefinito", anche un tipo senza nessun abitante deve guadagnarsi il diritto di entrare.

Gli allocator personalizzati ottengono finalmente una base stabile

Quasi altrettanto attesa: il nucleo del lavoro su allocator_api è stabile. Il trait Allocator, Global, System e i costruttori *_in (Vec::new_in, Vec::with_capacity_in, Box::new_in, Box::from_raw_in) sono ora utilizzabili su Rust stabile. Chi scrive librerie può definire un allocator e passarlo alle collezioni standard:

use std::alloc::{Allocator, Global};
// A Vec that allocates from your arena/pool/slab instead of the heap
let mut v: Vec<u64, _> = Vec::new_in(MyArena::new());
v.push(42);

Se hai scritto solo codice applicativo, potrebbe sembrarti roba da idraulico. Lo è, e l'idraulica è proprio dove i linguaggi di sistema vincono o perdono. Fino ad ora, cambiare allocator significava lo strumento grossolano #[global_allocator]: un unico allocator per l'intero processo. Va bene quando vuoi jemalloc o mimalloc ovunque (e in gioco c'è una prestazione reale, jemalloc si è guadagnato la sua reputazione su larga scala), ma non serve a nulla quando vuoi un solo Vec basato su un'arena che viene liberata in un colpo solo alla fine di una richiesta, mentre tutto il resto usa l'heap predefinito. Motori di gioco, database, target embedded con più regioni di RAM, codice a ridosso del kernel: tutti questi vogliono un controllo per collezione, e lo vogliono da anni.

Nota l'inquadratura data dalla release stessa: si tratta esplicitamente delle fondamenta del progetto "Allocators 1.0", con altre collezioni e tipi di puntatore in arrivo. Il progetto Rust ha preso confidenza nel dire "ecco il nucleo stabile; il resto resta deliberatamente nightly". Questa sequenza, stabilizzare il trait e il design, lasciare che l'ecosistema ci costruisca sopra ed estendere la superficie più avanti, è esattamente il modo per evitare di incastrarsi con un'API che dovrà essere supportata per sempre. C++ ha preso la strada opposta con std::allocator negli anni Novanta, lo ha rilasciato a metà e ha passato decenni a convivere con i danni. La pazienza costa meno.

DropGuard: il defer di Go, alla maniera Rust

La sorpresa della release è std::mem::DropGuard. Il trait Drop di Rust garantisce già che il codice di pulizia venga eseguito quando un valore esce dallo scope: return, ?, panic, non importa. Ma scrivere un intero nuovo tipo solo per eseguire una closure all'uscita è un boilerplate che molti di noi hanno già sopportato a malincuore. DropGuard incapsula un valore e una closure, fa il deref al valore così puoi usarlo normalmente, ed esegue la closure quando il guard muore. Il metodo dismiss() lo disinnesca. L'uso canonico è il rollback transazionale:

use std::mem::DropGuard;
use std::num::ParseIntError;
/// Push every parsed string into `nums`, or leave `nums` untouched.
fn parse_all(nums: &mut Vec<u32>, strings: &[&str]) -> Result<(), ParseIntError> {
let len = nums.len();
let mut nums = DropGuard::new(nums, move |nums| {
nums.truncate(len); // rollback on failure
});
for s in strings {
nums.push(s.parse()?); // `?` exits early; the guard truncates
}
DropGuard::dismiss(nums); // success: keep the values
Ok(())
}

Se sa di defer di Go, è così, ma con una differenza cruciale su dove vive la garanzia. Il defer di Go è un'istruzione con scope di funzione: viene eseguita al return della funzione ed è invisibile al sistema dei tipi. DropGuard è un valore. Puoi spostarlo, memorizzarlo, passarlo a un altro scope, disinnescarlo in modo condizionale. La genealogia passa dal RAII del C++ e dal vecchio trucco ScopeGuard di Alexandrescu dei primi tempi del C++ moderno, che faceva la stessa cosa con i distruttori e una chiamata a Dismiss(). Rust non ha inventato l'idea: ha assorbito un idioma C++ di vent'anni, gli ha dato una semantica di ownership e l'ha messo in core. È così che l'evoluzione di un linguaggio funziona davvero: non novità, ma adozione di pattern collaudati nel vocabolario standard.

Un funambolo che attraversa un canyon con una corda di sicurezza ancorata alle sue spalle
DropGuard è la corda ancorata: qualunque cosa accada sul filo, il rollback viene eseguito.

Evocare il nulla: tipi a dimensione zero fatti bene

Più in basso nelle note c'è una funzione con un nome che adoro davvero: std::mem::conjure_zst. I tipi a dimensione zero, come le unit struct o i token marker tipo il Python<'py di PyO3, sono ovunque nella programmazione a livello di tipi di Rust. Se un tipo abitato non ha dimensione, può contenere esattamente un valore, quindi crearlo è, in un certo senso, sempre "sicuro". Ma le API si basano di continuo sul fatto che questi token siano non falsificabili: evocare un Python<'py dal nulla permetterebbe al codice sicuro di fingere di possedere il GIL. In passato le persone evocavano gli ZST con transmute di () o con incantesimi MaybeUninit, ognuno con implicazioni leggermente diverse per le linee guida sul codice unsafe, ancora in discussione. Ora c'è un'unica forma ufficiale, esplicitamente unsafe. È una piccola funzione che esiste perché una grande questione di specifica abbia una risposta unica e verificabile. Noiosa, attenta, corretta: tutta la release in una API.

I cooldown delle dipendenze in Cargo: difesa della supply chain a orologio

La modifica più rilevante di 1.100 potrebbe non trovarsi affatto nel linguaggio. Cargo ora supporta una risoluzione delle dipendenze consapevole di min-publish-age, cioè i cooldown delle dipendenze. L'idea alla base è empirica: le versioni malevole di un pacchetto vengono di solito individuate entro poche ore o giorni dalla pubblicazione, da scanner o da persone. Quindi basta rifiutare di risolvere versioni più giovani di una finestra configurata:

# .cargo/config.toml
[registry]
global-min-publish-age = "3 days"

Da quel momento, cargo update salta in silenzio le release fresche e ti dice cosa ha trattenuto, ad esempio clap 4.6.7 (available: 4.6.9, published 2 days ago). Quando hai davvero bisogno di un hotfix, una variabile d'ambiente per un override una tantum ti permette di prenderlo deliberatamente, e quella scelta viene registrata in Cargo.lock invece di propagarsi in silenzio. È un controllo di sicurezza raro, che ti costa quasi nulla: scambi qualche giorno di freschezza con una quarantena permanente su ogni attacco zero-day ai pacchetti che viene catturato rapidamente. Visti gli episodi accaduti ad altri registri, come il compromesso di LiteLLM su PyPI, un esempio recente di quanto velocemente si propaga una release avvelenata, il cooldown è l'assicurazione più economica dell'ecosistema. Le note di rilascio sono onestamente chiare: non è una difesa completa, e cargo install lo aggira del tutto. Il supporto alla quarantena e il rilevamento automatico delle release sospette sono ancora nella roadmap di crates.io. Difesa in profondità, consegnata un livello alla volta.

Igiene della build: dipendenze inutilizzate e collisioni di cache

Due miglioramenti della qualità della vita meritano una menzione perché attaccano le due lamentele più comuni in ogni thread su Rust: tempi di compilazione e uso del disco. Primo, Cargo ora segnala direttamente le dipendenze inutilizzate, con un avviso che punta alla riga esatta del tuo Cargo.toml. Rustc ha da sempre un lint unused_crate_dependencies, ma produceva falsi positivi con Cargo perché le dipendenze sono condivise tra i target di build: una dipendenza usata da un bin del pacchetto sembrava inutilizzata per un altro. Cargo ha la visione globale che a rustc manca, quindi l'avviso ora sta dove sta la verità. Funziona solo costruendo tutti i target rilevanti, ed è il primo elemento di un nuovo sistema di lint, [lints.cargo], per il manifest stesso.

Secondo, la directory di build è stata riorganizzata. Configurazioni di build diverse, come set di feature o profili, producono artefatti diversi, e un hash di configurazione li tiene separati. Quell'hash non veniva applicato in modo coerente per via di vincoli di piattaforma, il che significava ricompilazioni in più, ricompilazioni mancate e confusione generale, il tutto peggiore se condividevi una directory di build tra git worktree. La correzione sposta l'hash dai nomi dei file a una struttura di directory organizzata per fase di build. Invisibile quando funziona, ed è proprio il punto, e sblocca la garbage collection della cache e la deduplicazione tra workspace in futuro. Se la tua directory target/ ha mai mangiato 90 gigabyte e ti ha costretto a un cargo clean quotidiano, le basi della tua salvezza sono appena state gettate. La correzione completa non c'è ancora, ma il refactoring portante sì.

Un ampio magazzino con casse di crate impilate in file ordinate e un angolo di quarantena delimitato da corde
Cooldown e igiene della cache: la logistica poco spettacolare che mantiene affidabile un ecosistema di pacchetti.

Cosa insegnano cento release sull'evoluzione di un linguaggio

La stabilità non è l'assenza di cambiamento. È la disciplina di sequenziare il cambiamento in modo che il codice di nessuno paghi il prezzo della tua roadmap.

Fai un passo indietro e guarda la forma di questa release. Un affinamento di teoria dei tipi durato un decennio. Un trait per gli allocator rilasciato di proposito come fondamenta, non come superficie finita. Un idioma di scope guard più vecchio di alcuni dei suoi utenti, finalmente standardizzato. Una funzionalità di sicurezza costruita sui metadati del registro e su avvertenze oneste. Internals del sistema di build rifattorizzati per sbloccare lavori futuri. Nessuna di queste è un cambio di paradigma che fa notizia, e insieme costituiscono esattamente quello: un linguaggio che si approfondisce senza cambiare sotto i tuoi piedi. È lo stesso accumulo silenzioso che vedi nel cammino poco appariscente di Java, un altro ecosistema che ha capito che la noia è una funzionalità.

Il meccanismo che rende tutto questo possibile merita tanto credito quanto qualsiasi funzionalità. Il modello del treno a sei settimane significa che nessuna stabilizzazione è mai un'emergenza. Crater, lo strumento che compila praticamente l'intero ecosistema pubblico di crate con un compilatore candidato, trasforma la domanda "questo romperà qualcuno?" da una preghiera in una misurazione. Le edizioni offrono un percorso di migrazione opt-in, così il linguaggio può cambiare i suoi default senza cambiare il tuo codice. E la relativamente nuova istituzione degli obiettivi di progetto con nome (Allocators 1.0, il layout della directory di build, il rafforzamento della supply chain di crates.io) dà agli sforzi pluriennali una colonna vertebrale pubblica, così una funzionalità come il never type può fallire cinque volte e avere comunque un percorso designato verso casa invece di morire in un thread di mailing list.

C'è una lezione qui per chiunque mantenga una piattaforma, un protocollo o una libreria molto usata. Gli utenti non vivono la tua roadmap; vivono i tuoi diff. Il never type arrivato in 1.100 invece che in 1.35 non è una storia di lentezza: è la storia di cosa succede quando un progetto considera "lo riconosceremo quando lo vedremo" una risposta accettabile per un decennio. La maggior parte delle organizzazioni software non può permettersi tanta pazienza, e onestamente la maggior parte non ne ha bisogno. Ma se costruisci qualcosa su cui altri costruiscono, il calcolo si ribalta: la fiducia degli utenti si accumula come interesse composto, e l'unico modo per guadagnarla è cento release in cui nulla si rompe. Rust 1.100 è una release importante. La storia più grande è che puoi installarla senza leggere prima le note.