Rust en 2025 : principales nouveautés du langage et de l'écosystème

Rust en 2025 : l'évolution du langage de programmation système

L'année 2025 a été marquante pour l'écosystème Rust. Le langage, qui s'est déjà imposé comme une alternative fiable à C et C++, continue de se développer activement, en introduisant des fonctionnalités très attendues et en améliorant les performances. Dans cet article, nous analyserons les principales innovations déjà disponibles ou à venir dans les versions stables de Rust en 2025. Nous examinerons les changements dans le langage, les outils et les pratiques de développement, en étayant chaque point par des exemples de code concrets.

1. Stabilisation des générateurs asynchrones et des coroutines

L'un des événements les plus attendus de 2025 a été la stabilisation complète des générateurs asynchrones (RFC #2394). Auparavant, la création d'itérateurs asynchrones nécessitait des crates externes ou des macros complexes. Désormais, c'est une fonctionnalité native du langage.

La nouvelle syntaxe permet de définir des fonctions qui peuvent yield des valeurs dans un contexte asynchrone, simplifiant ainsi le travail avec les flux de données, les websockets et le traitement de grands volumes d'informations.

use std::pin::pin;use std::future::Future;

// Générateur asynchrone qui simule la réception de données via le réseauasync fn stream_data(items: Vec<u32>) -> impl AsyncIterator<Item = u32> {    for item in items {        // Simulation d'un délai asynchrone        yield item;    }}

#[tokio::main]async fn main() {    let mut stream = pin!(stream_data(vec![1, 2, 3, 4, 5]));    while let Some(value) = stream.next().await {        println!("Reçu : {}", value);    }}

Ce changement simplifie considérablement l'écriture de pipelines asynchrones efficaces et rend le code plus lisible et plus sûr.

2. Révolution dans la compilation : Polonius et Cranelift

En 2025, le compilateur Rust a reçu deux mises à jour majeures qui affectent directement la vitesse de développement et la vérification du code.

Polonius (NLL v2). Le nouveau modèle d'emprunt (Non-Lexical Lifetimes v2) a été finalement stabilisé. Il permet au compilateur d'analyser plus précisément la durée de vie des références, ce qui conduit à l'acceptation d'un plus grand nombre de programmes corrects qui étaient auparavant rejetés à tort. Cela est particulièrement notable lors du travail avec des structures de données complexes et des références internes.

// Exemple devenu possible grâce à Poloniusfn process_data(data: &mut Vec<i32>) -> &i32 {    let first = &data[0]; // Emprunt de data    data.push(1);          // Auparavant erreur : emprunt mutable et immuable    first                  // Maintenant le compilateur comprend que first ne dépend pas de push}

Backend Cranelift. Pour les builds de débogage (debug mode), le backend Cranelift est désormais utilisé par défaut. Cela permet d'augmenter la vitesse de compilation de 2 à 3 fois par rapport à LLVM, tout en conservant une bonne qualité des messages d'erreur. Pour les builds de production, LLVM optimisé reste utilisé.

3. Nouvelles fonctionnalités dans les traits

Le développement du système de types se poursuit. En 2025, deux fonctions importantes sont apparues : Traits with Associated Defaults et Impl Trait in Associated Types.

La première permet de définir dans un trait non seulement les signatures des méthodes, mais aussi les valeurs par défaut pour les constantes et types associés. La seconde permet d'utiliser impl Trait en position de type de retour pour les types associés, rendant l'API plus flexible.

trait Factory {    type Output: Clone; // Type associé    const DEFAULT_NAME: &'static str = "default"; // Valeur par défaut

    fn create(&self) -> Self::Output;}

struct NumberFactory;

impl Factory for NumberFactory {    type Output = i32;    // const DEFAULT_NAME n'est pas redéfini - nous utilisons "default"

    fn create(&self) -> i32 {        42    }}

// Utilisation de impl Trait dans le type associé