Rust par l'exemple

// `Centimeters` est un tuple qui peut être comparé.
#[derive(PartialEq, PartialOrd)]
struct Centimeters(f64);

// `Inches` est un tuple qui peut être affiché.
#[derive(Debug)]
struct Inches(i32);

impl Inches {
    fn to_centimeters(&self) -> Centimeters {
        let &Inches(inches) = self;

        Centimeters(inches as f64 * 2.54)
    }
}

// `Seconds` est un tuple ne possédant aucun attribut.
struct Seconds(i32);

fn main() {
    let _one_second = Seconds(1);

    // Erreur: `Seconds` ne peut pas être affiché; Il n'implémente pas le trait `Debug`.
    // println!("One second looks like: {:?}", _one_second);
    // TODO ^ Essayez de décommenter cette ligne.

    // Erreur: `Seconds` ne peut pas être comparé; Il n'implémente pas le trait `PartialEq`.
    // let _this_is_true = (_one_second == _one_second);
    // TODO ^ Essayez de décommenter cette ligne.

    let foot = Inches(12);

    println!("One foot equals {:?}", foot);

    let meter = Centimeters(100.0);

    let cmp =
        if foot.to_centimeters() < meter {
            "smaller"
        } else {
            "bigger"
        };

    println!("One foot is {} than one meter.", cmp);
}

use std::ops;

struct Foo;
struct Bar;

#[derive(Debug)]
struct FooBar;

#[derive(Debug)]
struct BarFoo;

// Le trait `std::ops::Add` est utilisé pour permettre la surcharge de `+`.
// Ici, nous spécifions `Add<Bar>` - cette implémentation sera appelée si l'opérande de droite est 
// de type `Bar`.
// Le bloc ci-dessous implémente l'opération : `Foo + Bar = FooBar`.
impl ops::Add<Bar> for Foo {
    type Output = FooBar;

    fn add(self, _rhs: Bar) -> FooBar {
        println!("> Foo.add(Bar) was called");

        FooBar
    }
}

// En inversant les types, nous nous retrouvons à implémenter une addition non-commutative.
// Ici, nous spécifions `Add<Foo>` - cette implémentation sera appelée si l'opérande de droite 
// est de type `Foo`.
// Le bloc ci-dessous implémente l'opération: `Bar + Foo = BarFoo`.
impl ops::Add<Foo> for Bar {
    type Output = BarFoo;

    fn add(self, _rhs: Foo) -> BarFoo {
        println!("> Bar.add(Foo) was called");

        BarFoo
    }
}

fn main() {
    println!("Foo + Bar = {:?}", Foo + Bar);
    println!("Bar + Foo = {:?}", Bar + Foo);
}

struct Droppable {
    name: &'static str,
}

// Implémentation basique de `drop` qui affiche un message dans la console.
impl Drop for Droppable {
    fn drop(&mut self) {
        println!("> Dropping {}", self.name);
    }
}

fn main() {
    let _a = Droppable { name: "a" };

    // block A
    {
        let _b = Droppable { name: "b" };

        // block B
        {
            let _c = Droppable { name: "c" };
            let _d = Droppable { name: "d" };

            println!("Exiting block B");
        }
        println!("Just exited block B");

        println!("Exiting block A");
    }
    println!("Just exited block A");

    // La variable peut être libérée manuellement en utilisant la fonction `(std::mem::)drop`.
    drop(_a);
    // TODO ^ Essayez de commenter cette ligne.

    println!("end of the main function");

    // `_a` ne *sera pas* libérée une seconde fois ici puisque nous l'avons déjà fait 
    // plus haut, manuellement.
}

struct Fibonacci {
    curr: u32,
    next: u32,
}

// Implémentation de `Iterator` pour le type `Fibonacci`.
// Le trait `Iterator` nécessite l'implémentation d'une méthode seulement pour l'élément `next`.
impl Iterator for Fibonacci {
    type Item = u32;

    // Ici, nous définissons la séquence utilisant `.curr` et `.next`.
    // Le type de renvoi est `Option<T>`:
    //     * Lorsque l'`Iterator` est terminé, `None` est renvoyé;
    //     * Autrement, la valeur suivante est enveloppé dans une instance `Some` et renvoyée.
    fn next(&mut self) -> Option<u32> {
        let new_next = self.curr + self.next;

        self.curr = self.next;
        self.next = new_next;

        // Puisqu'il n'y a pas de limite à une suite de Fibonacci, l'`Iterator` 
        // ne renverra jamais `None`.
        Some(self.curr)
    }
}

// Renvoie un générateur de suites de Fibonacci.
fn fibonacci() -> Fibonacci {
    Fibonacci { curr: 1, next: 1 }
}

fn main() {
    // `0..3` est un `Iterator` qui génère: 0, 1, et 2 (i.e. intervalle `[0, 3[`).
    let mut sequence = 0..3;

    println!("Four consecutive `next` calls on 0..3");
    println!("> {:?}", sequence.next());
    println!("> {:?}", sequence.next());
    println!("> {:?}", sequence.next());
    println!("> {:?}", sequence.next());


    // `for` parcourt un `Iterator` jusqu'à ce qu'il renvoie `None`.
    // Chaque valeur contenue par un objet `Some` est libérée de son conteneur 
    // puis assignée à une variable (en l'occurrence, `i`).
    println!("Iterate through 0..3 using `for`");
    for i in 0..3 {
        println!("> {}", i);
    }

    // La méthode `take(n)` réduit un `Iterator` à ces `n` premiers éléments.
    println!("The first four terms of the Fibonacci sequence are: ");
    for i in fibonacci().take(4) {
        println!("> {}", i);
    }

    // La méthode `skip(n)` tronque les `n` premiers éléments d'un `Iterator`.
    println!("The next four terms of the Fibonacci sequence are: ");
    for i in fibonacci().skip(4).take(4) {
        println!("> {}", i);
    }

    let array = [1u32, 3, 3, 7];

    // La méthode `iter` construit un `Iterator` sur un(e) tableau/slice.
    println!("Iterate the following array {:?}", &array);
    for i in array.iter() {
        println!("> {}", i);
    }
}

// Une structure unitaire sans ressources.
#[derive(Debug, Clone, Copy)]
struct Nil;

// Un tuple avec des ressources qui implémente le trait `Clone`.
#[derive(Clone, Debug)]
struct Pair(Box<i32>, Box<i32>);

fn main() {
    // Un instancie `Nil`.
    let nil = Nil;
    // On copie l'objet `Nil`, aucune ressource à transférer.
    let copied_nil = nil;

    // Les deux instances peuvent être utilisées indépendament l'une de l'autre.
    println!("original: {:?}", nil);
    println!("copy: {:?}", copied_nil);

    // On crée un objet `Pair`.
    let pair = Pair(Box::new(1), Box::new(2));
    println!("original: {:?}", pair);

    // On copie `pair` dans `moved_pair`, transfert de ressources.
    let moved_pair = pair;
    println!("copy: {:?}", moved_pair);

    // Erreur! `pair` ne possède plus ses ressources.
    // println!("original: {:?}", pair);
    // TODO ^ Essayez de décommenter cette ligne.

    // On copie `moved_pair` dans `cloned_pair` (ressources incluses).
    let cloned_pair = moved_pair.clone();
    // On libère la ressource originale avec `std::mem::drop`.
    drop(moved_pair);

    // Erreur! `moved_pair` a été libérée.
    // println!("copy: {:?}", moved_pair);
    // TODO ^ Essayez de décommenter cette ligne.

    // La copie obtenue par `.clone()` peut toujours être utilisée !
    println!("clone: {:?}", cloned_pair);
}