Rust (langage)

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.

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[20].

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
}

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[21].

Afin de garantir la programmation générique, le langage Rust implément 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, toutes les listes de valeurs supportant l’opérateur de comparaison < pourra être passé comme argument pour cette fonction.

Les traits sont assimilables aux interfaces en java ou les 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;
    }
}

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

• Zig

• (en) Site officiel

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