Des articles approfondis sur les technologies qui façonnent l'avenir.

Rust 1.100 : le never type, dix ans de patience

Rust 1.100 stabilise le never type, les allocateurs personnalisés et les cooldowns Cargo. Ce que cent releases enseignent sur la conception.

Un long escalier de pierre construit marche après marche sur une colline, avec les outils du maçon posés en plein chantier
Cent petites marches régulières : la cadence de sortie de Rust comme philosophie de construction.

Voici un scénario qui devrait être remarquable et ne l'est pas : vous lancez rustup update stable un jeudi matin, recompilez un workspace de quelques centaines de crates et un demi-million de lignes de code, et tout compile. Pas d'avertissements de dépréciation que vous n'avez pas mérités, pas de casse surprise dans une dépendance transitive, pas de figement frénétique des versions. Avec Rust 1.100 — une version vraiment énorme qui stabilise enfin le never type après une décennie de tentatives — ce qu'il y a de plus intéressant, c'est à quel point la mise à jour sera tranquille pour presque tout le monde. Ce n'est pas un hasard. C'est le fruit d'une centaine de releases de discipline institutionnelle, et cette version mérite d'être lue comme on lirait un document de conception.

Le never type, une décennie de gestation

La fonctionnalité phare de la 1.100 est un type qui, par définition, n'a aucune valeur. Le never type, écrit !, est le type non habité canonique : il décrit des calculs qui ne se résolvent jamais en valeur — une boucle infinie, un return, un panic!(), un appel à std::process::exit. Les théoriciens des types connaissent cette bête depuis très longtemps ; c'est le type bas, le ⊥ du lambda-calcul, l'ensemble vide qui traîne dans un coin de votre treillis de types. Les utilisateurs de Haskell le connaissent sous le nom de Void. Rust tourne autour depuis avant la 1.0, et il aura fallu dix ans et cinq tentatives de stabilisation échouées pour y arriver.

Pourquoi si difficile ? Parce que ! peut être coercé vers n'importe quel autre type — c'est précisément sa force — et chaque point de coercion est un endroit où l'inférence de types, la résolution des traits et la vérification d'exhaustivité doivent s'accorder. Parce qu'un bras de match qui diverge a le type !, ce code compile :

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 ligne let Ok(v) = res; est la récompense : comme Err(!) ne peut jamais exister, le compilateur accepte le motif irréfutable, et toute une catégorie d'appels unreachable!() défensifs disparaît. Par ailleurs, l'ancienne énumération std::convert::Infallible devient un alias de type pour !, si bien que toutes les API écrites avec Infallible ces dernières années sont automatiquement compatibles avec le vrai never type. Cette unification était le plan dès le départ — et c'est aussi la raison pour laquelle la stabilisation n'arrêtait pas de glisser : changer l'alias imposait de modifier le fallback du never type dans les éditions antérieures à 2024, un changement techniquement cassant.

Regardez comment l'équipe a géré cette rupture, car c'est toute la philosophie en miniature. Ils ont publié des avertissements de compatibilité future bien à l'avance, testé l'écosystème avec Crater et proposé proactivement des correctifs aux crates publics qui seraient touchés. Une rupture, étalée sur plusieurs cycles de release, avec le rayon d'impact mesuré et corrigé avant que la plupart des utilisateurs ne remarquent quoi que ce soit. Comparez avec le réflexe habituel de l'industrie : monter de version majeure et hausser les épaules. J'ai déjà écrit sur ce à quoi la soundness engage réellement Rust — l'affaire du never type est la version « processus » de ce même engagement. Quand votre garantie est « le code sûr ne peut pas avoir de comportement indéfini », même un type sans aucun habitant doit mériter sa place.

Les allocateurs personnalisés obtiennent enfin des fondations stables

Presque aussi attendu : le cœur du travail sur allocator_api est stabilisé. Le trait Allocator, Global, System et les constructeurs *_in — Vec::new_in, Vec::with_capacity_in, Box::new_in, Box::from_raw_in — sont désormais utilisables sur le Rust stable. Les auteurs de bibliothèques peuvent définir un allocateur et le passer aux collections 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);

Si vous n'avez jamais écrit que du code applicatif, cela peut ressembler à de la tuyauterie. C'en est, et c'est justement là que les langages système vivent ou meurent. Jusqu'ici, changer d'allocateur passait par l'outil brutal qu'est #[global_allocator] : un seul allocateur pour tout le processus. C'est très bien quand vous voulez jemalloc ou mimalloc partout (et il y a de vrais gains de performance à la clé — jemalloc a bâti sa réputation à grande échelle), mais inutilisable quand vous voulez qu'un seul Vec soit adossé à une arène libérée d'un seul coup à la fin d'une requête, pendant que le reste utilise le tas par défaut. Moteurs de jeu, bases de données, cibles embarquées avec plusieurs régions de RAM, code proche du noyau : tous veulent un contrôle par collection, et ils le réclament depuis des années.

Remarquez le cadrage dans les notes de version elles-mêmes : il s'agit explicitement des fondations du projet « Allocators 1.0 », avec d'autres collections et types de pointeurs à venir. Le projet Rust est désormais à l'aise pour dire « voici le cœur stable ; le reste reste volontairement en nightly ». Ce séquençage — stabiliser le trait et le design, laisser l'écosystème construire dessus, élargir la surface plus tard — est exactement la façon d'éviter de se coincer avec une API qu'il faudra supporter éternellement. C++ a pris le chemin inverse avec std::allocator dans les années 90 : livré à moitié cuit, il a occupé des décennies à contourner les dégâts. La patience coûte moins cher.

DropGuard : le defer de Go, à la sauce Rust

Le succès discret de la version est std::mem::DropGuard. Le trait Drop de Rust garantit déjà que le code de nettoyage s'exécute quand une valeur sort de portée — retour, ?, panique, peu importe. Mais écrire un type entier juste pour exécuter une closure à la sortie, c'est du boilerplate que beaucoup d'entre nous ont subi en rechignant. DropGuard encapsule une valeur et une closure, se déréférence vers la valeur pour qu'on puisse l'utiliser normalement, et exécute la closure quand le garde meurt. Une méthode dismiss() le désamorce. L'usage canonique est le rollback transactionnel :

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(())
}

Si ça sent le defer de Go, c'est bien le cas — mais la différence cruciale tient à l'endroit où vit la garantie. Le defer de Go est une instruction de portée fonction : il s'exécute au retour de la fonction, et il est invisible pour le système de types. DropGuard, lui, est une valeur. On peut la déplacer, la stocker, la confier à un autre scope, la désamorcer conditionnellement. La généalogie passe par le RAII de C++ et le vieux trick ScopeGuard d'Alexandrescu, des débuts du C++ moderne, qui faisait la même chose avec des destructeurs et un appel Dismiss(). Rust n'a pas inventé l'idée ; il a absorbé un idiome C++ vieux de vingt ans, lui a donné une sémantique de propriété et l'a placé dans core. C'est ainsi que l'évolution d'un langage fonctionne vraiment : pas la nouveauté, mais l'adoption de motifs éprouvés dans le vocabulaire standard.

Un funambule traversant un canyon avec une corde de sécurité ancrée derrière lui
DropGuard est le filin d'ancrage : quoi qu'il arrive sur le fil, le rollback s'exécute.

Faire surgir du néant : les types de taille nulle bien faits

Plus bas dans les notes se trouve une fonction au nom que j'adore : std::mem::conjure_zst. Les types de taille nulle — structs unitaires, jetons marqueurs comme Python<'py de PyO3 — sont partout dans la programmation au niveau des types en Rust. Si un type habité n'a pas de taille, il n'a qu'une seule valeur possible, donc la créer est, en un sens, toujours « sûr ». Mais les API reposent régulièrement sur le fait que ces jetons sont infalsifiables : faire surgir un Python<'py de nulle part permettrait à du code sûr de prétendre détenir le GIL. Auparavant, on invoquait les ZST avec des transmutes de () ou des incantations MaybeUninit, chacune ayant des implications subtilement différentes au regard des directives encore indécises sur le code unsafe. Désormais, il existe une orthographe unique, bruyamment marquée unsafe. C'est une petite fonction qui existe pour qu'une grande question de spécification ait une réponse unique et auditable. Sobre, prudent, correct — toute la version dans une seule API.

Les cooldowns de dépendances Cargo : la défense de la chaîne d'approvisionnement à retardement

Le changement le plus lourd de conséquences de la 1.100 n'est peut-être pas dans le langage du tout. Cargo prend désormais en charge une résolution de dépendances consciente de min-publish-age — des cooldowns de dépendances. L'idée sous-jacente est empirique : les versions de paquets malveillantes sont en général repérées en quelques heures ou quelques jours après publication, par des scanners ou par des humains. Il suffit donc de refuser de résoudre vers des versions plus récentes qu'une fenêtre configurée :

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

Dès lors, cargo update ignore discrètement les versions fraîches et vous indique ce qu'il a mis de côté — clap 4.6.7 (available: 4.6.9, published 2 days ago). Quand vous avez vraiment besoin d'un correctif urgent, une variable d'environnement de contournement ponctuel permet de le tirer délibérément, et ce choix est consigné dans Cargo.lock plutôt que de se propager en silence. C'est le rare contrôle de sécurité qui ne coûte presque rien : vous échangez quelques jours de fraîcheur contre une quarantaine permanente sur chaque attaque de paquet zero-day détectée rapidement. Vu ce qu'on a vu arriver à d'autres registres — la compromission de LiteLLM sur PyPI étant un cas d'école récent de la vitesse à laquelle une version empoisonnée se propage —, un cooldown est l'assurance la moins chère de l'écosystème. Les notes de version sont admirablement honnêtes : ce n'est pas une défense complète, et cargo install le contourne entièrement. Le support de quarantaine et la détection automatique des releases suspectes figurent encore sur la feuille de route de crates.io. Défense en profondeur, livrée une couche à la fois.

Hygiène de build : dépendances inutilisées et collisions de cache

Deux améliorations de confort méritent d'être mentionnées, car elles attaquent les deux plaintes les plus fréquentes de tout fil de discussion sur Rust : les temps de compilation et l'occupation disque. D'abord, Cargo signale désormais directement les dépendances inutilisées, avec un avertissement pointant la ligne exacte de votre Cargo.toml. Rustc dispose depuis longtemps d'un lint unused_crate_dependencies, mais il produisait de faux positifs avec Cargo, car les dépendances sont partagées entre les cibles de build — une dépendance utilisée par un bin d'un paquet semble inutilisée pour un autre. Cargo a la vue globale qui manque à rustc, donc l'avertissement se trouve désormais là où est la vérité. Il est conditionné à la compilation de toutes les cibles pertinentes, et c'est le premier élément d'un tout nouveau système de lints [lints.cargo] pour le manifeste lui-même.

Ensuite, le répertoire de build a été réorganisé. Des configurations de build différentes — ensembles de features, profils — produisent des artefacts différents, et un hash de configuration les garde distincts. Ce hash n'était pas appliqué de manière cohérente à cause de contraintes de plateforme, ce qui entraînait des recompilations superflues, des recompilations manquées et une confusion générale, pire encore si vous partagiez un répertoire de build entre plusieurs worktrees git. La correction déplace le hash des noms de fichiers vers une arborescence de répertoires organisée par étape de build. Invisible quand ça marche, et c'est justement le but — et cela ouvre la voie au ramassage de cache et à la déduplication entre workspaces. Si votre dossier target/ a déjà englouti 90 gigaoctets et vous a forcé à un cargo clean quotidien, les fondations de votre salut viennent d'être posées. La correction complète n'est pas encore là, mais le refactoring porteur est livré.

Un vaste entrepôt avec des caisses empilées en rangées ordonnées et un coin de quarantaine délimité par une corde
Cooldowns et hygiène du cache : la logistique sans éclat qui rend un écosystème de paquets fiable.

Ce que cent releases enseignent sur l'évolution d'un langage

La stabilité n'est pas l'absence de changement. C'est la discipline qui consiste à séquencer les changements pour que le code de personne ne paie le prix de votre feuille de route.

Prenez du recul et regardez la forme de cette version. Un raffinement de théorie des types qui a pris une décennie. Un trait d'allocateur livré délibérément comme fondation, pas comme surface finie. Un idiome de scope guard plus ancien que certains de ses utilisateurs, enfin standardisé. Une fonctionnalité de sécurité bâtie sur les métadonnées du registre et des mises en garde honnêtes. Des internes du système de build refactorés pour débloquer du travail futur. Aucune de ces choses n'est un virage paradigmatique qui fait les gros titres, et ensemble elles constituent exactement cela : un langage qui gagne en profondeur sans changer sous vos pieds. C'est la même accumulation discrète qu'on observe dans la marche sans éclat de Java, un autre écosystème qui a compris que l'ennui est une fonctionnalité.

La machinerie qui rend tout cela possible mérite autant de crédit que n'importe quelle fonctionnalité. Le modèle de train de six semaines fait qu'aucune stabilisation n'est jamais une urgence. Crater — l'outil qui compile pratiquement tout l'écosystème public de crates contre un compilateur candidat — transforme la question « est-ce que ça va casser quelqu'un ? » d'une prière en mesure. Les éditions offrent un chemin de migration optionnel, si bien que le langage peut changer ses valeurs par défaut sans changer votre code. Et l'institution, relativement récente, des objectifs de projet nommés (Allocators 1.0, la disposition du répertoire de build, le durcissement de la chaîne d'approvisionnement de crates.io) donne aux efforts pluriannuels une colonne vertébrale publique : ainsi, une fonctionnalité comme le never type peut échouer cinq fois et conserver un chemin désigné pour aboutir, au lieu de mourir dans un fil de discussion de liste de diffusion.

Il y a là une leçon pour quiconque maintient une plateforme, un protocole ou une bibliothèque largement utilisée. Les utilisateurs ne vivent pas votre feuille de route ; ils vivent vos diffs. Le never type arrivant en 1.100 plutôt qu'en 1.35 n'est pas une histoire de lenteur — c'est l'histoire de ce qui se passe quand un projet considère « on saura quand on le verra » comme une réponse acceptable pendant une décennie. La plupart des organisations logicielles ne peuvent pas se permettre cette patience, et honnêtement la plupart n'en ont pas besoin. Mais si vous construisez quelque chose sur quoi d'autres construisent, le calcul s'inverse : la confiance de vos utilisateurs se compose comme des intérêts, et la seule façon de la gagner, c'est une centaine de releases où rien ne casse. Rust 1.100 est une grosse version. La vraie histoire, c'est qu'on peut l'installer sans avoir lu les notes au préalable.