Rust est un langage de programmation compilé multi-paradigme conçu et développé par Mozilla Research depuis 2010[6]. Il a été conçu pour être « un langage fiable, concurrent, pratique »[7]^,[8], supportant les styles de programmation purement fonctionnel, modèle d'acteur, procédural, ainsi qu'orienté objet sous certains aspects[9].

Pour les articles homonymes, voir Rust et Mozilla.

Rust
Date de première version	2006
Paradigmes	Impératif, fonctionnel, concurrent
Auteur	Graydon Hoare
Développeurs	Mozilla
Dernière version	1.65.0 (3 novembre 2022)[1]
Typage	Fort, statique
Influencé par	C++, Erlang, Haskell, Scala, OCaml, Scheme, Swift, C#, Alef, Limbo[2]
A influencé	Swift[3]
Écrit en	Rust
Système d'exploitation	Multiplate-forme
Licence	Licence Apache version 2.0[4],[5] et licence MIT[4],[5]
Site web	www.rust-lang.org
Extension de fichier	rs
modifier

En 2020, ses domaines de prédilection sont la programmation système, les applications en ligne de commande, les applications Web via WebAssembly, les services réseaux et les systèmes embarqués.

Du fait de la politique de Mozilla[10], Rust est entièrement développé de façon ouverte (les ingénieurs de Mozilla Research publient leurs idées et les décisions prises lors des réunions) et sollicite les remarques et contributions de la communauté. La conception du langage est graduellement améliorée au travers des retours de l'équipe travaillant sur le moteur de rendu Servo[11] et de façon pragmatique lors de l'écriture du compilateur. Bien que le projet soit financé par Mozilla, la majorité des contributions proviennent de la communauté.

Description

Rust se veut un langage performant, sûr et productif[12].

Le langage peut notamment donner des garanties d'absence d'erreur de segmentation ou de situation de concurrence[13] dès l'étape de compilation. De plus, ceci se fait sans ramasse-miettes[14]. Ses performances sont comparables à celles de C ou C++[15] pour ce qui concerne la vitesse d'exécution.

Enfin, Rust est accompagné de Cargo, un gestionnaire de paquets permettant de gérer la compilation et les dépendances entre paquets. Le compilateur fournit des messages d'erreur explicites et utiles. Il existe aussi d'autres outils d'édition pour les EDI ainsi qu'une documentation abondante.

Histoire

Le langage s'est développé à partir d'un projet personnel de Graydon Hoare, qui commença à travailler dessus en 2006. Son employeur, Mozilla, commença sa participation en 2009[16] et révéla officiellement ses travaux en 2010[17]. La même année, le projet passa du compilateur initialement utilisé (écrit en OCaml) au compilateur auto-hébergé écrit en Rust[18]. Ce compilateur, connu sous le nom de rustc, s'est compilé avec succès en 2011[19]. Le compilateur auto-hébergé utilise LLVM en arrière-fond.

La première version alpha numérotée du compilateur Rust apparait en janvier 2012[20].

La première version stable de Rust, 1.0, est sortie en 2015.

En 2017, Mozilla annonce que Rust supporte la compilation vers le jeu d'instruction de l'architecture RISC-V[21].

Caractéristiques

Syntaxe

La syntaxe du langage est similaire à celle du C, étant constituée de blocs de code délimités par des accolades et de structures de contrôle comme if, else, while et for.

Cependant, la sémantique de Rust est assez différente. En effet, les blocs et les structures de contrôles sont des expressions, comme on peut le voir dans l'exemple :

let x = if n < 10 {n} else {n - 10};

En C, une telle opération n'est pas «intelligible» pour le compilateur; il faudra soit encapsuler le bloc conditionnel dans une autre fonction, soit utiliser un opérateur ternaire int x = (n < 10) ? n : n - 10;.

L'utilisation d'expressions rapproche ainsi Rust de langages fonctionnels comme Haskell ou OCaml.

Valeur et mutabilité

Dans la plupart des langages, une variable est modifiable par défaut. Rust inverse cette logique en privilégiant la constance : le mot-clé let déclare par défaut des variables immuables (immutable variable en anglais) qui ne peuvent être affectées qu'une seule fois, mais dont la valeur peut être définie au moment de l'exécution. Il est nécessaire de rajouter le mot-clé mut pour rendre une variable « mutable » ou « muable » : ainsi, on restreint les variables qui sont effectivement autorisées à changer. Le type des variables est inféré à chaque fois que c'est possible.

Pour les valeurs constantes connues à la compilation, le mot-clé const remplace let. Leur type doit être précisé et elles doivent être initialisées à partir d'une expression constante, excluant les résultats d'appels de fonctions[22].

fn main() {
    // Déclaration de variables
    let mut a = 5; // a est une variable modifiable
    let b = a * 2; // b est non modifiable et du même type que a

    // Constantes
    const c: u32 = 5; // déclaration d'une constante entière non-signée
    const c: u8 = b - 3; // interdit car `b - 3` n'est pas une expression constante (b non défini à la compilation)
    const c = 5; // interdit car le type de c n'est pas précisé

    // Altération
    c = 3; // illégal car c est une constante
    b = 3; // illégal car b est une variable immuable
    a = 2; // autorisé car a est déclaré comme "mut"
    let a = a + 5; // autorisé une nouvelle variable a est créée valant 7,
                   // l'ancienne variable a est "couverte" par la nouvelle (shadowing)

    // Vérification des valeurs
    assert_eq!(a, 5); // faux
    assert_eq!(b, 10); // vrai
}

Énumérations et filtrage par motif

Rust permet la définition de types sommes (ou énumérations) à l'aide du mot-clé enum. On peut utiliser ces types sommes avec du filtrage par motif, en utilisant par exemple le mot-clé match.

Exemple :

// On crée un type « Forme » pour décrire des formes géométriques.
enum Forme {
    Point,               // une forme peut être un point, sans données attachées.
    Rectangle(f64, f64), // une forme peut être un rectangle, caractérisé par les longueurs de ses côtés.
    Cercle(f64),         // une forme peut être un cercle, caractérisé par son rayon.
}

// Calcule l'aire d'une forme géométrique.
fn aire(f: Forme) -> f64 {
    match f {
        // Filtrage par motif avec « match »
        Forme::Point => 0.0,
        Forme::Cercle(rayon) => 3.14 * rayon * rayon,
        Forme::Rectangle(cote_a, cote_b) => cote_a * cote_b,
    }
}

Certaines énumérations font partie de la bibliothèque standard, comme Option, permettant d'éviter l'utilisation du pointeur NULL[23].

Métaprogrammation permise grâce au filtrage par motif

Cette section est vide, insuffisamment détaillée ou incomplète. Votre aide est la bienvenue pour développer cette section en se basant sur les macro !

Programmation générique

Afin de garantir la programmation générique, le langage Rust implémente son propre système de métaprogrammation basé sur les traits. Ainsi, un développeur souhaitant mettre en place une fonction générique sera dans l’obligation d’expliciter les différents traits utilisés dans sa fonction, son objet ou sa méthode.

Exemple de l’implémentation du tri-bulle de manière générique:

fn tri_bulle<T: std::cmp::PartialOrd>(liste: &mut Vec<T>) {
    // Ici, on a besoin de l’opérateur de comparaison < implémenté par le trait
    // PartialOrd
    let mut i = 0;

    while i < (liste.len() - 1) {
        if liste[i] < liste[i + 1] {
            liste.swap(i, i + 1);
            i = 0;
        } else {
            i += 1;
        }
    }
}

Ainsi, toute liste de valeurs supportant l’opérateur de comparaison < pourra être passée comme argument pour cette fonction.

Définition des méthodes communes par le biais de trait

Les traits sont assimilables aux interfaces en java ou aux classes abstraites en C++: Ils définissent les méthodes qui seront proposées par les structures les implémentant. Ils sont des composants centraux du langage, étant donné que les opérations comme les additions sont définies via l’implémentation de traits. Ces derniers peuvent également proposer une implémentation générique de certaines de leur fonctions à condition que ces dernières ne requièrent pas l’utilisation de données stockées dans les objets.

Exemple de définition d‘un trait:

trait Polygone {
    fn nombre_cotes(&self) -> usize;

    fn points(&self) -> Vec<(f32, f32)>;

    // Il n’existe pas de méthode simple et générique pour calculer l’aire d’un
    // polygone
    fn aire(&self) -> f32;

    fn perimetre(&self) -> f32 {
        let mut ret = 0.0;
        let points = self.points();

        for i in 1..points.len() {
            ret += f32::sqrt(
                f32::pow(points[i].0 - points[i - 1].0, 2)
                    + f32::pow(points[i].1 - points[i - 1].1, 2),
            );
        }

        return ret;
    }
}

Possession et emprunt

Pour obtenir des garanties de sûreté, Rust utilise les concepts d'ownership (propriété ou possession) et de borrowing (emprunt).

Ainsi, une valeur a toujours un seul propriétaire. Si la valeur change de propriétaire, l'ancien propriétaire ne peut plus l'utiliser.

Par exemple :

fn prend_possession(v: Vec<i32>) {
    // Cette fonction prend possession de son paramètre v et ne la rend pas.
    println!("{:?}", v);
}

fn main() {
    let mut a = vec![1, 2, 3]; // a est le propriétaire du vecteur.
    let mut b = a; // b est maintenant le propriétaire du vecteur.

    // pas clair,
    a.push(4); // erreur de compilation : a n'a plus le droit d'utiliser ce vecteur

    prend_possession(b);
    b.push(5); // erreur de compilation : b n'a plus le droit d'utiliser ce vecteur
}

Pour utiliser une valeur à plusieurs endroits à la fois, il est possible de prêter cette valeur en créant des références.

Il est possible de créer :

• Soit des références immuables, avec l'opérateur &.
• Soit une référence muable, avec l'opérateur & mut.

En particulier, il n'est pas possible de mélanger les références muables et immuables.

Exemple :

fn take_reference(v: &Vec<i32>) {
    // Cette fonction prend une référence vers un vecteur
    println!("{:?}", v);
}

fn correct() {
    let a = vec![1, 2, 3];
    let ref_1 = &a;
    let ref_2 = &a;
    // On crée plusieurs références immuables vers a que l'on peut passer à des fonctions.
    // Faire ceci ne serait pas possible si l'on travaillait avec une fonction qui prend
    // l'ownership de a.
    take_reference(ref_1);
    take_reference(ref_2);
}

fn incorrect() {
    let mut a = vec![1, 2, 3];
    // Ce code ne compile pas.
    // En effet, on travaille à la fois avec une référence muable vers a (ref_1),
    // et à la fois avec une référence immuable vers a (ref_2).
    let ref_1 = &mut a[0];
    let ref_2 = &a;
    println!("{}", *ref_1);
    take_reference(ref_2);
}

Points forts

Rust repose sur des concepts connus et éprouvés (d'où le nom Rust, « la rouille » en anglais) et n'intègre pas de concepts nouveaux et non testés[24]^{[réf. obsolète]}[25]. Ces concepts ont été empruntés à des langages de programmation existants et assemblés dans un seul langage[26] :

• orientation bas niveau, avec la possibilité de choisir la gestion de la mémoire adaptée au programme : pile, tas (notamment via l'utilisation de pointeurs intelligents) ;
• gestion de la concurrence intégrée dans le langage ;
• sûr par défaut, avec la possibilité de contourner cette sûreté dans les blocs unsafe :
  • typage statique sans conversions implicites,
  • accès mémoire validés statiquement par le compilateur,
  • variables immuables par défaut,
  • passage de messages entre tâches concurrentes pour éviter des erreurs liées aux accès concurrents à la mémoire,
  • pas d'utilisation de null ;
• inférence de types ;
• filtrage par motif ;
• généricité.

Rust est souvent décrit comme l'un des successeurs potentiels de C et C++[27] (avec D et, dans une moindre mesure, Go) notamment grâce à sa sûreté et sa rapidité — c'est un objectif clairement affiché par les développeurs.

Projets basés sur Rust

• Firefox[28] :
  • Servo : moteur de rendu HTML ;
• Cargo : gestionnaire de paquets Rust ;
• Redox : un système d'exploitation de type Unix ;
• Deno : successeur à Node.js ;
• exa (en) : alternative à ls ;
• fd (en): alternative à find;
• GNOME Fractal : client Matrix ;
• Libra Core : Cryptomonnaie ;
• Solana: Cryptomonnaie ;
• Discord : logiciel de VoIP[29] et de messagerie instantanée ;
• Hyperledger Sawtooth[30] ;
• Magic Pocket : système de stockage distribué de Dropbox[31];
• Android:
  • Gabeldorsche: stack Bluetooth Android (depuis Android 11)[32].

Exemples de code

Hello world :

// This is the main function
fn main() {
    // The statements here will be executed when the compiled binary is called

    // Print text to the console
    println!("Hello World!");
}

Arrays and Slices :

use std::mem;

// This function borrows a slice
fn analyze_slice(slice: &[i32]) {
    println!("first element of the slice: {}", slice[0]);
    println!("the slice has {} elements", slice.len());
}

fn main() {
    // Fixed-size array (type signature is superfluous)
    let xs: [i32; 5] = [1, 2, 3, 4, 5];

    // All elements can be initialized to the same value
    let ys: [i32; 500] = [0; 500];

    // Indexing starts at 0
    println!("first element of the array: {}", xs[0]);
    println!("second element of the array: {}", xs[1]);

    // `len` returns the size of the array
    println!("array size: {}", xs.len());

    // Arrays are stack allocated
    println!("array occupies {} bytes", mem::size_of_val(&xs));

    // Arrays can be automatically borrowed as slices
    println!("borrow the whole array as a slice");
    analyze_slice(&xs);

    // Slices can point to a section of an array
    println!("borrow a section of the array as a slice");
    analyze_slice(&ys[1..4]);

    // Out of bound indexing yields a panic
    println!("{}", xs[5]);
}

Bibliographie

• Jim Blandy et Jason Orendorff, Programmer avec Rust - pour une programmation système rapide et sûre, First Interactive, 5 septembre 2019, (ISBN 9782412046593)
• Benoît Prieur, Rust - Développez des programmes robustes et sécurisés, Éditions ENI, 11 mai 2022, 362 p. (ISBN 2-409-03528-0)

Références

Articles connexes

• Zig

Liens externes

• (en) Site officiel

• Portail de l’informatique
• Portail des logiciels libres
• Portail de la programmation informatique

На других языках

[it] Rust (linguaggio di programmazione)

[ru] Rust (язык программирования)