Rust par l'exemple

use std::mem;

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

#[allow(dead_code)]
struct Rectangle {
    p1: Point,
    p2: Point,
}

fn origin() -> Point {
    Point { x: 0.0, y: 0.0 }
}

fn boxed_origin() -> Box<Point> {
    // Alloue cette instance de `Point` dans le tas et renvoie un pointeur 
    // sur cette dernière.
    Box::new(Point { x: 0.0, y: 0.0 })
}

fn main() {
    // (Ici le typage est superflu)
    // Variables allouées dans la pile.
    let point: Point = origin();
    let rectangle: Rectangle = Rectangle {
        p1: origin(),
        p2: Point { x: 3.0, y: 4.0 }
    };

    // Rectangle alloué dans le tas.
    let boxed_rectangle: Box<Rectangle> = Box::new(Rectangle {
        p1: origin(),
        p2: origin()
    });

    // Le résultat des fonctions peut être boxé également.
    let boxed_point: Box<Point> = Box::new(origin());

    // Double indirection
    let box_in_a_box: Box<Box<Point>> = Box::new(boxed_origin());

    println!("Point occupies {} bytes in the stack",
             mem::size_of_val(&point));
    println!("Rectangle occupies {} bytes in the stack",
             mem::size_of_val(&rectangle));

    // La taille du pointeur est égale à la taille de la Box.
    println!("Boxed point occupies {} bytes in the stack",
             mem::size_of_val(&boxed_point));
    println!("Boxed rectangle occupies {} bytes in the stack",
             mem::size_of_val(&boxed_rectangle));
    println!("Boxed box occupies {} bytes in the stack",
             mem::size_of_val(&box_in_a_box));

    // La ressource contenue dans `boxed_point` est copiée dans 
    // `unboxed_point`.
    let unboxed_point: Point = *boxed_point;
    println!("Unboxed point occupies {} bytes in the stack",
             mem::size_of_val(&unboxed_point));
}

fn main() {
    // Les éléments des itérateurs peuvent être collectés et 
    // ajoutés dans un vecteur.
    let collected_iterator: Vec<i32> = (0..10).collect();
    println!("Collected (0..10) into: {:?}", collected_iterator);

    // La macro `vec!` peut être utilisée pour initialiser un vecteur.
    let mut xs = vec![1i32, 2, 3];
    println!("Initial vector: {:?}", xs);

    // On ajoute un nouvel élément à la fin du vecteur.
    println!("Push 4 into the vector");
    xs.push(4);
    println!("Vector: {:?}", xs);

    // Erreur! Les vecteurs immuables ne peuvent pas être 
    // agrandis.
    // collected_iterator.push(0);
    // FIXME ^ Commentez/décommentez cette ligne

    // La méthode `len` renvoie la taille actuelle du vecteur.
    println!("Vector size: {}", xs.len());

    // L'indexation peut être faite à l'aide des "[]" (l'indexaction débute à 0).
    println!("Second element: {}", xs[1]);

    // `pop` supprime le dernier élément du vecteur et le renvoie.
    println!("Pop last element: {:?}", xs.pop());

    // Une indexaction hors des capacités du vecteur 
    // mène à un plantage du programme.
    println!("Fourth element: {}", xs[3]);
}

fn main() {
    // (Le typage est optionnel)
    // Une référence d'une chaîne de caractères immuable.
    let pangram: &'static str = "the quick brown fox jumps over the lazy dog";
    println!("Pangram: {}", pangram);

    // On itère sur les mots dans le sens inverse, aucune nouvelle instance 
    // n'est créée.
    println!("Words in reverse");
    for word in pangram.split_whitespace().rev() {
        println!("> {}", word);
    }

    // On copie les caractères dans un vecteur, les trie et supprime 
    // les occurrences multiples.
    let mut chars: Vec<char> = pangram.chars().collect();
    chars.sort();
    chars.dedup();

    // On créé une instance de `String` vide et mutable.
    let mut string = String::new();
    for c in chars {
        // On ajoute un caractère à la fin de la chaîne.
        string.push(c);
        // On ajoute une nouvelle chaîne à la fin de la chaîne initiale.
        string.push_str(", ");
    }

    // La chaîne tronquée est une slice de la chaîne originale, il n'y a 
    // pas de nouvelle allocation.
    let chars_to_trim: &[char] = &[' ', ','];
    let trimmed_str: &str = string.trim_matches(chars_to_trim);
    println!("Used characters: {}", trimmed_str);

    // Chaîne allouée dans le tas.
    let alice = String::from("I like dogs");
    // Nouvelle allocation mémoire et stockage de la chaîne modifiée 
    // à cet endroit.
    let bob: String = alice.replace("dog", "cat");

    println!("Alice says: {}", alice);
    println!("Bob says: {}", bob);
}

// Une division entre deux entiers qui ne plante pas.
fn checked_division(dividend: i32, divisor: i32) -> Option<i32> {
    if divisor == 0 {
        // L'échec est représenté par la variante `None`.
        None
    } else {
        // Le résultat est enveloppé dans une instance `Some`.
        Some(dividend / divisor)
    }
}

// Cette fonction gère une division qui peut ne pas fonctionner.
fn try_division(dividend: i32, divisor: i32) {
    // Les valeurs d'`Option` peuvent être matchées, tout comme les autres enums.
    match checked_division(dividend, divisor) {
        None => println!("{} / {} failed!", dividend, divisor),
        Some(quotient) => {
            println!("{} / {} = {}", dividend, divisor, quotient)
        },
    }
}

fn main() {
    try_division(4, 2);
    try_division(1, 0);

    // L'assignation de `None` à une variable nécessite de typer cette dernière.
    let none: Option<i32> = None;
    let _equivalent_none = None::<i32>;

    let optional_float = Some(0f32);

    // "dé-wrapper" une instance de `Some` va extraire la valeur contenue.
    println!("{:?} unwraps to {:?}", optional_float, optional_float.unwrap());

    // Tenter d'utiliser `unwrap` sur la variante `None` fera planter le programme.
    println!("{:?} unwraps to {:?}", none, none.unwrap());
}

mod checked {
    // Les "erreurs" mathématiques que nous voulons gérer.
    #[derive(Debug)]
    pub enum MathError {
        DivisionByZero,
        NonPositiveLogarithm,
        NegativeSquareRoot,
    }

    pub type MathResult = Result<f64, MathError>;

    pub fn div(x: f64, y: f64) -> MathResult {
        if y == 0.0 {
            // Cette opération échouerait, nous wrappons l'erreur dans une instance 
            // `Err` à la place.
            Err(MathError::DivisionByZero)
        } else {
            // Cette opération est valide, nous renvoyons le résultat wrappé dans `Ok`.
            Ok(x / y)
        }
    }

    pub fn sqrt(x: f64) -> MathResult {
        if x < 0.0 {
            Err(MathError::NegativeSquareRoot)
        } else {
            Ok(x.sqrt())
        }
    }

    pub fn ln(x: f64) -> MathResult {
        if x <= 0.0 {
            Err(MathError::NonPositiveLogarithm)
        } else {
            Ok(x.ln())
        }
    }
}

// `op(x, y)` === `sqrt(ln(x / y))`
fn op(x: f64, y: f64) -> f64 {
    // Ceci est une pyramide de match à trois niveaux !
    match checked::div(x, y) {
        Err(why) => panic!("{:?}", why),
        Ok(ratio) => match checked::ln(ratio) {
            Err(why) => panic!("{:?}", why),
            Ok(ln) => match checked::sqrt(ln) {
                Err(why) => panic!("{:?}", why),
                Ok(sqrt) => sqrt,
            },
        },
    }
}

fn main() {
    // Cette opération va-t-elle échouer ?
    println!("{}", op(1.0, 10.0));
}

// Ré-implémentation de la division d'entiers (/).
fn division(dividend: i32, divisor: i32) -> i32 {
    if divisor == 0 {
        // La division par zéro fait planter le thread courant.
        panic!("division by zero");
    } else {
        dividend / divisor
    }
}


fn main() {
    // Entier alloué dans le tas.
    let _x = Box::new(0i32);

    // Cette opération va déclencher la procédure d'abandon.
    division(3, 0);

    println!("This point won't be reached!");

    // `_x` devrait être détruit à ce niveau.
}

$ rustc panic.rs && valgrind ./panic
==4401== Memcheck, a memory error detector
==4401== Copyright (C) 2002-2013, and GNU GPL′d, by Julian Seward et al.
==4401== Using Valgrind-3.10.0.SVN and LibVEX; rerun with -h for copyright info
==4401== Command: ./panic
==4401== 
thread '<main>' panicked at 'division by zero', panic.rs:5
==4401== 
==4401== HEAP SUMMARY:
==4401==     in use at exit: 0 bytes in 0 blocks
==4401==   total heap usage: 18 allocs, 18 frees, 1,648 bytes allocated
==4401== 
==4401== All heap blocks were freed -- no leaks are possible
==4401== 
==4401== For counts of detected and suppressed errors, rerun with: -v
==4401== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

use std::collections::HashMap;

fn call(number: &str) -> &str {
    match number {
        "798-1364" => "We're sorry, the call cannot be completed as dialed. 
            Please hang up and try again.",
        "645-7689" => "Hello, this is Mr. Awesome's Pizza. My name is Fred.
            What can I get for you today?",
        _ => "Hi! Who is this again?"
    }
}

fn main() { 
    let mut contacts = HashMap::new();

    contacts.insert("Daniel", "798-1364");
    contacts.insert("Ashley", "645-7689");
    contacts.insert("Katie", "435-8291");
    contacts.insert("Robert", "956-1745");

    // Prend une référence en entrée et renvoie un conteneur `Option<&V>`.
    match contacts.get(&"Daniel") {
        Some(&number) => println!("Calling Daniel: {}", call(number)),
        _ => println!("Don't have Daniel's number."),
    }


    // La méthode `HashMap::insert()` renvoie `None` 
    // si la valeur insérée est nouvelle, sinon `Some(value)`.
    contacts.insert("Daniel", "164-6743");

    match contacts.get(&"Ashley") {
        Some(&number) => println!("Calling Ashley: {}", call(number)),
        _ => println!("Don't have Ashley's number."),
    }

    contacts.remove(&("Ashley")); 

    // La méthode `HashMap::iter()` renvoie un itérateur qui fournit 
    // les paires (&'a key, &'a value) dans un ordre arbitraire.
    for (contact, &number) in contacts.iter() {
        println!("Calling {}: {}", contact, call(number)); 
    }
}