Rust 🦀

Ce document est une prise de notes personnelle de mes lectures sur le Rust.

Particularités du langage

1. Runtime

Le runtime de Rust est léger car il n’a pas de pas de garbage collector et gère la mémoire grâce à son concept d’ownership et borrowing. Rust compile directement le code en code machine et n’utilise pas de machine virtuelle pour la gestion des ressources car tout se passe à la compilation (par opposition à Java et sa JVM par exemple).

2. Pas de pointeurs “classiques”

Dans les langages comme C ou C++, les pointeurs sont des variables qui contiennent l’adresse mémoire d’une autre variable. Cela permet de manipuler directement la mémoire, mais c’est aussi source d’erreurs si un pointeur pointe vers une zone mémoire invalide ou qui a été libérée (c’est ce qu’on appelle une référence dangling ou sauvage).

Rust, pour éviter cela, utilise un système de références sécurisées avec des règles strictes de propriété (ownership), de prêt (borrowing) et de durée de vie (lifetime). Plutôt que de laisser les programmeurs manipuler directement les adresses mémoire comme en C ou C++, Rust utilise des références qui garantissent :

• qu’une référence ne peut pas pointer vers de la mémoire libérée
• qu’une référence mutable ne peut être utilisée que par un seul emprunteur à la fois, pour éviter les conflits
• que le compilateur vérifie toutes ces règles pour garantir la sécurité de la mémoire

3. Pas de valeur “nulle” par défaut

La valeur nulle (ou NULL) est une notion qui existe dans de nombreux langages pour représenter “l’absence de valeur”. Cependant, cette valeur est une grande source de bugs car les programmeurs oublient souvent de vérifier si une valeur est “nulle” avant de l’utiliser. Si un programme essaie de manipuler une valeur qui est “nulle”, cela peut causer une erreur qui fait planter le programme (on parle de null pointer exception).

Rust a choisi de ne pas avoir de valeur null par défaut. À la place, il utilise un type spécial appelé Option pour représenter une valeur qui peut être présente ou absente.

Enums & Match

Cette définition de l’énumération AdresseIp indique que chacune des variantes V4 et V6 auront des valeurs associées de type différents :

    struct Ipv4Addr {}
    
    struct Ipv6Addr {}
    
    enum IpAddr {
        V4(Ipv4Addr),
        V6(Ipv6Addr),
    }

ou bien:

    enum Message {
        Quitter,
        Deplacer { x: i32, y: i32 }, // Structure anonyme
        Ecrire(String), // Tuple
    }

    // Il est possible d'utiliser impl avec un enum:
    impl Message {
        fn appeler(&self) {}
    }
    
    let m = Message::Ecrire(String::from("hello"));
    m.appeler();

Comme la valeur NULL n’existe pas en Rust ce manque est compensé par l’implémentation de l’enum Option<T>. De cette façon une valeur peut-être soit présente soit absente.

   enum Option<T> {
       None,
       Some(T),
   }

   // Exemples
    let un_nombre = Some(5);
    let une_chaine = Some("une chaîne");

    let nombre_absent: Option<i32> = None; // Nous spécifions le type de la variable car Rust ne peut pas inférer le type lui-même.

L’Option<T> permet de garantir que la manipulation d’une variable contient bien une valeur valide. Rust nous oblige a évaluer chaque variante de l’enum pour pouvoir en extraire la valeur.

Un match appliqué à un enum permettra de s’assurer que chaque variante a été gérée.

    enum PieceUs {
        Penny,
        Nickel,
        Dime,
        Quarter,
    }
    
    fn valeur_en_centimes(piece: PieceUs) -> u8 {
        match piece {
            PieceUs::Penny => 1,
            PieceUs::Nickel => 5,
            PieceUs::Dime => 10,
            PieceUs::Quarter => 25,
        }
    }

Autre exemple avec une valeur générique :

    let jete_de_de = 9;
    match jete_de_de {
        3 => ajouter_chapeau_fantaisie(),
        7 => enleve_chapeau_fantaisie(),
        _ => (),
    }

    fn ajouter_chapeau_fantaisie() {}
    fn enleve_chapeau_fantaisie() {}

NB: Le if / let ne permettra pas de couvrir toutes les variantes de l’enum :

    let une_valeur_u8 = Some(3u8);
    if let Some(max) = une_valeur_u8 {
        println!("Le maximum est réglé sur {}", max);
    }

Packages & Crates

Un package peut contenir une librairie au maximum, et plusieurs binaires. Mais au miniumum il doit contenir une librairie ou un binaire.

monprojet/ <-------------- package
    Cargo.toml <---------- definition du package
    src/
        main.rs <--------- un crate
        lib.rs (et ou) <-- un crate
    
// autre cas
monprojet/
    Cargo.toml <--
    src/
        lib.rs
        bin/
            main1.rs <---- un crate
            main2.rs <---- un autre crate

Un module rassemble des elements à l’intérieur d’un crate pour donner de la cohérence à l’orgamisation du projet :

// src/libs.rs
    mod salle_a_manger {
        mod accueil {
            fn ajouter_a_la_liste_attente() {}
            fn installer_a_une_table() {}
        }

        mod service {
            fn prendre_commande() {}
            fn servir_commande() {}
            fn encaisser() {}
        }
    }

Ce qui donne cette arborescence :

crate // lib.rs ou main.rs parent de toute l'arborescence
 └── salle_a_manger
     ├── accueil
     │   ├── ajouter_a_la_liste_attente
     │   └── installer_a_une_table
     └── service
         ├── prendre_commande
         ├── servir_commande
         └── encaisser

Grâce aux modules, nous pouvons regrouper ensemble des définitions qui sont liées et donner un nom à ce lien. Ils servent aussi à gérer la visibilité des fonctionnalités.

Pour indiquer à Rust où trouver un élément dans l’arborescence, il a deux types de chemins :

• Les chemins absolus –> crate ou le nom d’une crate.
• Les chemins relatifs –> self, super ou un indicateur à l’intérieur du module.

// src/lib.rs
    mod salle_a_manger {
        pub mod accueil { // Les modules ne servent pas uniquement à organiser votre code. Ils définissent aussi les limites de visibilité de Rust.
            pub fn ajouter_a_la_liste_attente() {} // Rendre le module public ne rend pas son contenu public
        }
    }

    pub fn manger_au_restaurant() {
        // Chemin absolu
        crate::salle_a_manger::accueil::ajouter_a_la_liste_attente();

        // Chemin relatif
        salle_a_manger::accueil::ajouter_a_la_liste_attente(); // Commencer par un nom signifie que le chemin est relatif.
        // On peut utiliser directement salle_a_manger car il est défini au même niveau que manger_au_restaurant().
    }

NB: Le module salle_a_manger n’est pas public, mais comme la fonction manger_au_restaurant est définie dans le même module que salle_a_manger (car manger_au_restaurant et salle_a_manger sont frères), nous pouvons utiliser salle_a_manger à partir de manger_au_restaurant

La visibilité en Rust fait en sorte que tous les éléments (fonctions, méthodes, structures, énumérations, modules et constantes) sont privés par défaut. Les éléments dans un module parent ne peuvent pas utiliser les éléments privés dans les modules enfants, mais les éléments dans les modules enfants peuvent utiliser les éléments dans les modules parents.

Super

Nous pouvons aussi créer des chemins relatifs qui commencent à partir du module parent en utilisant super au début du chemin. C’est comme débuter un chemin dans un système de fichiers avec la syntaxe ...

Pub

Nous pouvons aussi utiliser pub pour déclarer des structures et des énumérations publiquement, mais il y a d’autres points à prendre en compte. Si nous utilisons pub avant la définition d’une structure, nous rendons la structure publique, mais les champs de la structure restent privés. Par contre, si nous rendons publique une énumération, toutes ses variantes seront publiques.

Use

Le mot-clef use permet de définir une importation et rend accessible dans le fichier où il est appelé tous les objets publics présents dans le chemin spécifié.

// lib/src.rs
    mod salle_a_manger {
        pub mod accueil {
            pub fn ajouter_a_la_liste_attente() {}
        }
    }

    use (crate::)salle_a_manger::accueil::ajouter_a_la_liste_attente;

    pub fn manger_au_restaurant() {
        ajouter_a_la_liste_attente();
        ajouter_a_la_liste_attente();
        ajouter_a_la_liste_attente();
    }

Dans une portée, utiliser un use s’apparente à créer un lien symbolique dans le système de fichier.

NB: l’import de deux types ayant le même nom dans la même portée nécessite d’utiliser leurs modules parents.

    use std::fmt;
    use std::io;

    fn fonction1() -> fmt::Result {}

    fn fonction2() -> io::Result<()> {}

Une autre alternative si deux types ont le même nom est d’utiliser as.

    use std::fmt::Result;
    use std::io::Result as IoResult;

    fn fonction1() -> Result {}

    fn fonction2() -> IoResult<()> {}

Il est possible de réexporter un élément privée en public:

//src/lib.rs
    mod salle_a_manger {
        pub mod accueil {
            pub fn ajouter_a_la_liste_attente() {}
        }
    }

    pub use crate::salle_a_manger::accueil;

    pub fn manger_au_restaurant() {
        accueil::ajouter_a_la_liste_attente();
        accueil::ajouter_a_la_liste_attente();
        accueil::ajouter_a_la_liste_attente();
    }

Grâce à pub use, le code externe peut maintenant appeler la fonction ajouter_a_la_liste_attente en utilisant accueil::ajouter_a_la_liste_attente. Si nous n’avions pas utilisé pub use, la fonction manger_au_restaurant aurait pu appeler accueil::ajouter_a_la_liste_attente dans sa portée, mais le code externe n’aurait pas pu profiter de ce nouveau chemin.

Exemple d’imbrication d’importations:

    use std::io;
    use std::io::Write;

    // =

    use std::io::{self, Write};

    // Pour importer tous les éléments:

    use std::collections::*; // NB: cette méthode est déconseillée sauf dans le cas des tests.

Collections

Une collection est un regroupement de plusieurs éléments. La taille d’une collection n’est pas connue à la déclaration ce qui veut dire que les données seront stockées dans la heap car Rust ne peut pas déterminer sa taille à la compilation car elle dépendra de l’exécution du programme. Parmi les collections les plus usitées nous retrouvons:

• Vec, liste de variables du même type.
• String, collection de char.
• HashMap qui permet d’associer une variable à une clef.

Vec

Un vecteur peut stocker n’importe quel type mais la liste doit contenir des éléments de même type.

    let mut v: Vec<i32> = Vec::new(); // Initialisation avec annotation de type
    v.push(5);

Néanmoins, Rust peut inférer le type lui-même selon les instructions qui vont suivre l’initialisation. Par exemple:

    let v = vec![1, 2, 3];

NB: La mémoire sera libérée lorsque le vecteur sortira de la portée.

Il existe deux façons de désigner une valeur enregistrée dans un vecteur : via les indices ou en utilisant la méthode get.

    let v = vec![1, 2, 3, 4, 5];

    // Cette méthode peut paniquer
    let troisieme: &i32 = &v[2]; // Renvoie une référence
    println!("Le troisième élément est {}", troisieme);

    match v.get(2) { // Renvoie une Option<&T>
        Some(troisieme) => println!("Le troisième élément est {}", troisieme),
        None => println!("Il n'y a pas de troisième élément."),
    }

Lorsque le programme obtient une référence valide, le vérificateur d’emprunt va faire appliquer les règles de possession et d’emprunt pour s’assurer que cette référence ainsi que toutes les autres références au contenu de ce vecteur restent valides. On ne peut pas avoir des références mutables et immuables dans la même portée.

    let mut v = vec![1, 2, 3, 4, 5];

    let premier = &v[0]; // <-- erreur de compilation

    v.push(6); // <------------ erreur de compilation

    println!("Le premier élément est : {}", premier);

Pour ajouter un élément dans un vecteur, Rust va utilisé l’espace contigue dans la mémoire. Si il n’y a pas assez de place il devra réallouer l’intégralité du vecteur dans un autre espace mémoire. Dans ce cas, le pointeur du premier élément du vecter fera référence à un emplacement mémoire désalloué.

Il est possible d’utiliser un énum, cela permet de stocker des éléments de type différents dans un même vecteur.

String

HashMap

🔗

• Rust book