Rust
Date de première version	2006
Paradigmes	Impératif, fonctionnel, concurrent
Auteur	Graydon Hoare
Développeurs	Mozilla
Dernière version	1.73.0 (5 octobre 2023)[1]
Typage	Fort, statique
Influencé par	C++, Erlang, Haskell, Scala, OCaml, Scheme, Swift, C#, Alef, Limbo[2]
A influencé	Swift[3]
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

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

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^[11], 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^[12] 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^[13].

Le langage peut notamment donner des garanties d'absence d'erreur de segmentation ou de situation de concurrence^[14] dès l'étape de compilation. De plus, ceci se fait sans ramasse-miettes^[15]. Ses performances sont comparables à celles de C ou C++^[16] 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, initié en 2006. Son employeur, Mozilla, commença sa participation en 2009^[17] et révéla officiellement ses travaux en 2010^[18]. La même année, le projet passa du compilateur initialement utilisé (écrit en OCaml) au compilateur auto-hébergé écrit en Rust^[19]. Ce compilateur, connu sous le nom de rustc, s'est compilé avec succès en 2011^[20]. 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^[21].

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'instructions de l'architecture RISC-V^[22].

Caractéristiques

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

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
}

// 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,
    }
}

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;
        }
    }
}

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;
    }
}

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
}

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^[25][26]. Ces concepts ont été empruntés à des langages de programmation existants et assemblés dans un seul langage^[27] :

• 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++^[28] (avec D et, dans une moindre mesure, Go) notamment de par sa sûreté et sa rapidité — c'est un objectif clairement affiché par les développeurs.

Projets basés sur Rust

• Firefox^[29] :
  • 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 : alternative à find;
• GNOME Fractal : client Matrix ;
• Libra Core : cryptomonnaie ;
• Solana : cryptomonnaie ;
• Discord : logiciel de VoIP^[30] et de messagerie instantanée ;
• Hyperledger Sawtooth^[31] ;
• Magic Pocket : système de stockage distribué de Dropbox^[32];
• Android:
  • Gabeldorsche : stack Bluetooth Android (depuis Android 11)^[33].

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