Rust par l'exemple

fn main() {
    let immutable_box = Box::new(5u32);

    println!("immutable_box contains {}", immutable_box);

    // Erreur: `immutable_box` ne peut pas être déréférencé.
    // *immutable_box = 4;

    // On créé une copie mutable de `immutable_box`.
    let mut mutable_box = immutable_box;

    println!("mutable_box contains {}", mutable_box);

    // On modifie le contenu de la box.
    *mutable_box = 4;

    println!("mutable_box now contains {}", mutable_box);
}

#[allow(dead_code)]
#[derive(Clone, Copy)]
struct Book {
    // `&'static str` est une référence d'une chaîne de caractères allouée 
    // dans un bloc mémoire qui ne peut être accédé qu'en lecture.
    author: &'static str,
    title: &'static str,
    year: u32,
}

// Cette fonction prend une référence d'une instance 
// de la structure `Book` en paramètre.
fn borrow_book(book: &Book) {
    println!("I immutably borrowed {} - {} edition", book.title, book.year);
}

// Cette fonction prend une référence mutable d'une instance de la 
// structure `Book` en paramètre, et initialise sa date de publication 
// à 2014.
fn new_edition(book: &mut Book) {
    book.year = 2014;
    println!("I mutably borrowed {} - {} edition", book.title, book.year);
}

fn main() {
    // On créé une instance immuable de la 
    // structure `Book` nommée `immutabook`.
    let immutabook = Book {
        // Les chaînes littérales sont typées `&'static str`.
        author: "Douglas Hofstadter",
        title: "Gödel, Escher, Bach",
        year: 1979,
    };

    // On créé une copie mutable de `immutabook` nommée
    // `mutabook`.
    let mut mutabook = immutabook;

    // Emprunte un objet en lecture seule.
    borrow_book(&immutabook);

    // Emprunte un objet en lecture seule.
    borrow_book(&mutabook);

    // Récupère une référence mutable d'un objet mutable.
    new_edition(&mut mutabook);

    // Erreur! Vous ne pouvez pas récupérer une référence 
    // mutable d'un objet immuable.
    // new_edition(&mut immutabook);
    // FIXME ^ Décommentez cette ligne.
}

fn main() {
    let mut _mutable_integer = 7i32;

    {
        // On emprunte `_mutable_integer`.
        // Accès en lecture uniquement.
        let _large_integer = &_mutable_integer;

        // Erreur! `_mutable_integer` est gelé dans ce contexte
        // (i.e. la ressource est empruntée).
        // _mutable_integer = 50;
        // FIXME ^ Décommentez/commentez cette ligne.

        // On sort du contexte de `_large_integer`.
    }

    // Aucun problème! `_mutable_integer` n'est plus gelé dans ce contexte.
    _mutable_integer = 3;
}

struct Point { x: i32, y: i32, z: i32 }

fn main() {
    let mut point = Point { x: 0, y: 0, z: 0 };

    {
        let borrowed_point = &point;
        let another_borrow = &point;

        // Vous pouvez accéder à la ressource par le biais des références 
        // créées et par l'objet original.
        println!("Point has coordinates: ({}, {}, {})",
                 borrowed_point.x, another_borrow.y, point.z);

        // Erreur! Vous ne pouvez pas avoir des accès en écriture à une ressource 
        // qui est déjà empruntée par une référence immuable (i.e. accès en lecture).
        // let mutable_borrow = &mut point;
        // TODO ^ Essayez de décommenter cette ligne.

        // On sort du contexte des références 
        // immuables.
    }

    {
        let mutable_borrow = &mut point;

        // On modifie la ressource par le biais d'une 
        // référence mutable.
        mutable_borrow.x = 5;
        mutable_borrow.y = 2;
        mutable_borrow.z = 1;

        // Erreur! Vous ne pouvez pas accéder à `point` en lecture 
        // alors que la ressource est potentiellement en train d'être modifiée.
        // let y = &point.y;
        // TODO ^ Essayez de décommenter cette ligne.

        // Erreur! On ne peut pas afficher `point.z` en utilisant 
        // la macro `println!` car elle prend en paramètre une référence 
        // immuable.
        // println!("Point Z coordinate is {}", point.z);
        // TODO ^ Essayez de décommenter cette ligne.

        // Ok! Les références mutables peuvent être passées comme 
        // références immuables à `println!`.
        println!("Point has coordinates: ({}, {}, {})",
                 mutable_borrow.x, mutable_borrow.y, mutable_borrow.z);

        // On sort du contexte des références 
        // mutables.
    }

    // Les accès en lecture sur `point` sont de nouveau 
    // permis par le vérificateur d'emprunts.
    let borrowed_point = &point;
    println!("Point now has coordinates: ({}, {}, {})",
             borrowed_point.x, borrowed_point.y, borrowed_point.z);
}

#[derive(Clone, Copy)]
struct Point { x: i32, y: i32 }

fn main() {
    let c = 'Q';

    // Un emprunt effectué avec le mot-clé `ref` (placé dans la l-value) 
    // est équivalent à une assignation "C-like" avec le `&` (placé dans la r-value).
    let ref ref_c1 = c;
    let ref_c2 = &c;

    println!("ref_c1 equals ref_c2: {}", *ref_c1 == *ref_c2);

    let point = Point { x: 0, y: 0 };

    // `ref` peut également être utilisé lors de la déstructuration 
    // d'une structure (aussi valable pour les tuples(structures et littéraux)).
    let _copy_of_x = {
        // `ref_to_x` est une référence du champ `x` contenu dans 
        // l'instance `point`.
        let Point { x: ref ref_to_x, y: _ } = point;

        // Renvoie une copie du champ `x` de l'instance `point`.
        *ref_to_x
    };

    // Copie mutable de l'instance `point`.
    let mut mutable_point = point;

    {
        // `ref` peut être combiné avec `mut` pour récupérer 
        // une référence mutable.
        let Point { x: _, y: ref mut mut_ref_to_y } = mutable_point;

        // On modifie le champ `y` de l'instance `mutable_point` par 
        // le biais de la référence mutable qu'on a récupéré.
        *mut_ref_to_y = 1;
    }

    println!("point is ({}, {})", point.x, point.y);
    println!("mutable_point is ({}, {})", mutable_point.x, mutable_point.y);

    // Un tuple mutable qui contient un pointeur et un entier non-signé 
    // codé sur 32 bits.
    let mut mutable_tuple = (Box::new(5u32), 3u32);

    {
        // Nous déstructurons le tuple `mutable_tuple` pour modifier 
        // la valeur de `last` (dernière élément indexé par le tuple).
        let (_, ref mut last) = mutable_tuple;
        *last = 2u32;
        // `_` est ajouté dans la valeur de gauche car on ne souhaite 
        // pas en récupérer le contenu.
    }

    println!("tuple is {:?}", mutable_tuple);
}

// `print_refs` prend deux références d'entiers possédant une durée de 
// vie différente chacune (i.e. `'a` et `'b`). Ces deux lifetimes doivent être 
// au moins aussi longues que celle de la fonction `print_refs`.
fn print_refs<'a, 'b>(x: &'a i32, y: &'b i32) {
    println!("x is {} and y is {}", x, y);
}

// Une fonction qui ne prend aucun argument, mais qui déclare quand même 
// une lifetime `'a`.
fn failed_borrow<'a>() {
    let _x = 12;

    // ERREUR: `_x` ne vit pas assez longtemps.
    // let y: &'a i32 = &_x;
    // Tenter d'utiliser la lifetime `'a` sur une ressource au sein de la fonction
    // ne fonctionnera pas car la durée de vie de `&_x` est plus courte que celle 
    // de `y` .
    // Une courte durée de vie ne peut être rallongée en cours de route.
}

fn main() {
    // On crée ces variables pour les emprunter 
    // un peu plus bas.
    let (four, nine) = (4, 9);

    // `print_refs` emprunte (`&`) les deux ressources précédemment 
    // créées.
    print_refs(&four, &nine);
    // Une ressource empruntée doit survivre à la fonction qui l'emprunte.
    // Autrement dit, la durée de vie de `four` et `nine` doit être 
    // plus longue que celle de `print_refs`.

    failed_borrow();

    // `failed_borrow` ne contient aucune référence qui force la lifetime `'a` à 
    // être plus longue que celle de la fonction, mais `'a` reste plus longue.
    // Parce que la durée de vie d'une ressource (empruntée) n'est jamais imposée, 
    // la durée de vie par défaut est `'static`.
}

// La référence passée en paramètre possédant la lifetime `'a` 
// doit vivre au moins aussi longtemps que le fonction.
fn print_one<'a>(x: &'a i32) {
    println!("`print_one`: x is {}", x);
}

// L'utilisation des références mutables est également possible 
// avec les lifetimes.
fn add_one<'a>(x: &'a mut i32) {
    *x += 1;
}

// Plusieurs entrées avec différentes lifetimes. Dans ce cas, 
// il serait plus simple, pour les deux paramètres, d'avoir 
// la même durée de vie (`'a`), mais dans des cas plus délicats, 
// plusieurs lifetimes peuvent être requises.
fn print_multi<'a, 'b>(x: &'a i32, y: &'b i32) {
    println!("`print_multi`: x is {}, y is {}", x, y);
}

// Renvoyer des références qui ont été passées en paramètre est légal.
// Toutefois, veillez à renvoyer la bonne lifetime.
fn pass_x<'a, 'b>(x: &'a i32, _: &'b i32) -> &'a i32 { x }

// fn invalid_output<'a>() -> &'a i32 { &7 }
// La déclaration ci-dessus est invalide: `'a` doit, au moins, 
// survivre à la fonction. Ici, `&7` créerait un entier et récupérerait 
// sa référence. La ressource serait alors perdue une fois l'exécution 
// de la fonction terminée, renvoyant une référence d'une ressource qui n'existe plus.

fn main() {
    let x = 7;
    let y = 9;

    print_one(&x);
    print_multi(&x, &y);

    let z = pass_x(&x, &y);
    print_one(z);

    let mut t = 3;
    add_one(&mut t);
    print_one(&t);
}

struct Owner(i32);

impl Owner {
    // On déclare et annote les lifetimes comme 
    // dans une fonction traditionnelle.
    fn add_one<'a>(&'a mut self) { self.0 += 1; }
    fn print<'a>(&'a self) {
        println!("`print`: {}", self.0);
    }
}

fn main() {
    let mut owner  = Owner(18);

    owner.add_one();
    owner.print();
}

// On créé un type nommé `Borrowed` qui a pour attribut 
// une référence d'un entier codé sur 32 bits. La référence 
// doit survivre à l'instance de la structure `Borrowed`.
#[derive(Debug)]
struct Borrowed<'a>(&'a i32);

// Même combat, ces deux références doivent survivre à l'instance
// (ou aux instances)  de la structure `NamedBorrowed`.
#[derive(Debug)]
struct NamedBorrowed<'a> {
    x: &'a i32,
    y: &'a i32,
}

// On créé une énumération qui contient deux variantes :
// 1. Un tuple qui prend en entrée un entier codé sur 32 bits;
// 2. Un tuple qui prend en entrée une référence d'un `i32`.
#[derive(Debug)]
enum Either<'a> {
    Num(i32),
    Ref(&'a i32),
}

fn main() {
    let x = 18;
    let y = 15;

    let single = Borrowed(&x);
    let double = NamedBorrowed { x: &x, y: &y };
    let reference = Either::Ref(&x);
    let number    = Either::Num(y);

    println!("x is borrowed in {:?}", single);
    println!("x and y are borrowed in {:?}", double);
    println!("x is borrowed in {:?}", reference);
    println!("y is *not* borrowed in {:?}", number);
}

use std::fmt::Debug; // On importe le trait `Debug`.
// Trait avec lequel nous allons filtrer les entrées 
// des fonctions génériques.

#[derive(Debug)]
struct Ref<'a, T: 'a>(&'a T);
// `Ref` contient la référence d'un type générique `T` qui possède 
// une lifetime inconnue nommée `'a`. Toutes les références contenues par 
// le type `T` sont contraintes à survivre à la lifetime `'a`. De plus, 
// la durée de vie de `Ref` ne peut pas excéder la lifetime `'a`.

// Une fonction générique qui affiche le résultat de l'utilisation 
// du trait `Debug`.
fn print<T>(t: T) where
    T: Debug {
    println!("`print`: t is {:?}", t);
}

// Ici, nous avons une référence de type `T` en entrée où 
// `T` implémente le trait `Debug` et toutes les références 
// contenues par le type `T` survivent à la lifetime `'a`. La lifetime 
// `'a` doit survivre à l'appel de la fonction.
fn print_ref<'a, T>(t: &'a T) where
    T: Debug + 'a {
    println!("`print_ref`: t is {:?}", t);
}

fn main() {
    let x = 7;
    let ref_x = Ref(&x);

    print_ref(&ref_x);
    print(ref_x);
}

// Ici, Rust va inférer une durée de vie aussi courte que possible. 
// Les deux références sont alors assignées à cette durée de vie.
fn multiply<'a>(first: &'a i32, second: &'a i32) -> i32 {
    first * second
}

// `<'a: 'b, 'b>` se lit comme suit: La lifetime `'a` est au moins aussi longue 
// que `'b`. Ici, nous prenons en entrée un entier soumis à la lifetime 
// `&'a i32` et renvoyons un entier (le même entier, en fait) soumis à la lifetime 
// `&'b i32` comme résultat de la coercition.
// Note: Nous pouvons renvoyer l'entier taggé avec la lifetime `'b` car `'a` et `'b`
// ont une durée de vie aussi longue, pour le temps de l'exécution de la fonction, 
// tout du moins.
fn choose_first<'a: 'b, 'b>(first: &'a i32, _: &'b i32) -> &'b i32 {
    first
}

fn main() {
    let first = 2; // Longue lifetime.

    {
        let second = 3; // Courte lifetime.

        // Note: Ici `first` et `second` possèdent la même durée de vie.
        println!("The product is {}", multiply(&first, &second));
        println!("{} is the first", choose_first(&first, &second));
    };
}

// On créé une constante avec la lifetime `'static` en utilisant 
// le mot-clé `static`.
static NUM: i32 = 18;

// Renvoie une référence de `NUM` où sa lifetime `'static` 
// est obligée de s'aligner avec la durée de vie du paramètre 
// passé à la fonction.
fn coerce_static<'a>(_: &'a i32) -> &'a i32 {
    &NUM
}

fn main() {
    {
        // On créé une chaîne de caractères littérale, primitive 
        // et on l'affiche.
        let static_string = "I'm in read-only memory";
        println!("static_string: {}", static_string);

        // Lorsque `static_string` sortira du contexte, la référence 
        // ne pourra plus être utilisée, mais la ressource restera 
        // présente dans le binaire.
    }

    {
        // On créé un entier à passer à la 
        // fonction `coerce_static`:
        let lifetime_num = 9;

        // On aligne, adapte la durée de vie de `NUM à 
        // celle de `lifetime_num`:
        let coerced_static = coerce_static(&lifetime_num);

        println!("coerced_static: {}", coerced_static);
    }

    println!("NUM: {} stays accessible!", NUM);
}

// `elided_input` et `annotated_input` ont fondamentalement la même signature, 
// sauf que la lifetime de l'entrée de la fonction `elided_input` a été omise 
// et ajoutée par le compilateur.
fn elided_input(x: &i32) {
    println!("`elided_input`: {}", x)
}

fn annotated_input<'a>(x: &'a i32) {
    println!("`annotated_input`: {}", x)
}

// Même combat, `elided_pass` et `annotated_pass` possèdent la même signature 
// sauf que la lifetime de `x`, pour la fonction `elided_pass`, a été omise 
// et ajoutée par le compilateur. Annotation implicite.
fn elided_pass(x: &i32) -> &i32 { x }

fn annotated_pass<'a>(x: &'a i32) -> &'a i32 { x }

fn main() {
    let x = 3;

    elided_input(&x);
    annotated_input(&x);

    println!("`elided_pass`: {}", elided_pass(&x));
    println!("`annotated_pass`: {}", annotated_pass(&x));
}