Rust par l'exemple

fn main() {
    let n = 5;

    if n < 0 {
        print!("{} est négatif.", n);
    } else if n > 0 {
        print!("{} est positif.", n);
    } else {
        print!("{} est nul.", n);
    }

    let big_n =
        if n < 10 && n > -10 {
            println!(" et est un petit nombre, multiplions-le par dix");

            // Cette expression renvoie un entier de type `i32`.
            10 * n
        } else {
            println!(" est un grand nombre, divisons-le par deux");

            // Cette expression doit également renvoyer un entier de type `i32`.
            n / 2
            // TODO ^ Essayez de supprimer cette expression en ajoutant un point-virgule.
        };
    //   ^ Ne pas oubliez de mettre un point-virgule ici! Toutes les 
    // assignations (`let`) doivent se terminer par un point-virgule.

    println!("{} -> {}", n, big_n);
}

fn main() {
    let mut count = 0u32;

    println!("Comptons jusqu'à l'infini!");

    // Boucle infinie.
    loop {
        count += 1;

        if count == 3 {
            println!("trois");

            // Ignore le reste de l'itération.
            continue;
        }

        println!("{}", count);

        if count == 5 {
            println!("Ok, ça suffit!");

            // Sort de la boucle.
            break;
        }
    }
}

fn main() {
    // Un compteur.
    let mut n = 1;

    // Itère sur `n` tant que sa valeur est strictement inférieure 
    // à 101.
    while n < 101 {
        if n % 15 == 0 {
            println!("fizzbuzz");
        } else if n % 3 == 0 {
            println!("fizz");
        } else if n % 5 == 0 {
            println!("buzz");
        } else {
            println!("{}", n);
        }

        // Incrémente le compteur.
        n += 1;
    }
}

fn main() {
    // `n` prendra pour valeur: 1, 2, ..., 100  au fil des itérations. 
    for n in 1..101 {
        if n % 15 == 0 {
            println!("fizzbuzz");
        } else if n % 3 == 0 {
            println!("fizz");
        } else if n % 5 == 0 {
            println!("buzz");
        } else {
            println!("{}", n);
        }
    }
}

fn main() {
    let number = 13;
    // TODO ^ Assignez différentes valeurs à `number`.

    println!("Nature de number {}", number);
    match number {
        // Teste une seule valeur.
        1 => println!("Un!"),
        // Teste plusieurs valeurs.
        2 | 3 | 5 | 7 | 11 => println!("C'est un nombre premier."),
        // Teste l'intervalle [13;19].
        13...19 => println!("A teen"),
        // Couvre tous les autres cas.
        _ => println!("Ain't special"),
    }

    let boolean = true;
    // L'analyse est également une expression.
    let binary = match boolean {
        // Les branches du match doivent couvrir tous les cas possibles.
        false => 0,
        true => 1,
        // TODO ^ Essayez de commenter l'une de ses branches.
    };

    println!("{} -> {}", boolean, binary);
}

// Crée une valeur optionnelle de type `Option<i32>`.
let optional = Some(7);

match optional {
    Some(i) => {
        println!("Ceci est une très longue chaîne de caractères contenant un 
        `{:?}`", i);
        // ^ Deux niveaux d'indentations sont nécessaires alors 
        // que nous aurions pu simplement déstructurer `i`.
    },
    _ => {},
    // ^ Nécessaire parce que `match` est exhaustif. Cette branche vous 
    // paraît-elle utile?
};

fn main() {
    // Toutes les variables sont de type `Option<i32>`.
    let number = Some(7);
    let letter: Option<i32> = None;
    let emoticon: Option<i32> = None;

    // L'ensemble `if let` se déroule de cette manière: 
    // `if let` déstructure `number` et assigne sa valeur à `i` et exécute 
    // le bloc (`{}`).
    if let Some(i) = number {
        println!("{:?} a été trouvé!", i);
    }

    // Si vous devez spécifier un cas d'erreur, utilisez un `else`:
    if let Some(i) = letter {
        println!("{:?} a été trouvé!", i);
    } else {
        // Déstructuration ratée. On exécute le `else`.
        println!("Aucun nombre n'a été trouvé. 
        Cherchons une lettre!");
    };

    // Fournit une condition alternative.
    let i_like_letters = false;

    if let Some(i) = emoticon {
        println!("{:?} a été trouvé!", i);
    // Déstructuration ratée. Passe à une condition `else if` pour tester si 
    // la condition alternative est vraie.
    } else if i_like_letters {
        println!("Aucun nombre n'a été trouvé. 
        Cherchons une lettre!");
    } else {
        // La condition évaluée est fausse. Branche par défaut:
        println!("Je n'aime pas les lettres. Cherchons une emoticône :)!");
    };
}

// Crée une valeur optionnelle de type `Option<i32>`.
let mut optional = Some(0);

// On répète le test.
loop {
    match optional {
        // Si il est possible de déstructurer `optional`, 
        // le bloc sera exécuté.
        Some(i) => {
            if i > 9 {
                println!("Plus grand que 9, on quitte!");
                optional = None;
            } else {
                println!("`i` est égal à `{:?}`. On réitère.", i);
                optional = Some(i + 1);
            }
            // ^ Nécessite trois niveaux d'indentations.
        },
        // On quitte la boucle si la déstructuration 
        // a échoué:
        _ => { break; }
        // ^ Pourquoi cette instruction devrait être nécessaire ?
        // Il doit y avoir une solution plus adaptée!
    }
}

fn main() {
    // Crée une valeur optionnelle de type `Option<i32>`.
    let mut optional = Some(0);

    // Fonctionnement: "`while let` déstructure `optional` pour assigner sa valeur 
    // à Some(i) puis exécute le bloc (`{}`). Sinon, on sort de la boucle."
    while let Some(i) = optional {
        if i > 9 {
            println!("Plus grand que 9, on quitte!");
            optional = None;
        } else {
            println!("`i` est égal à `{:?}`. On réitère.", i);
            optional = Some(i + 1);
        }
        // Moins explicite, il n'est plus nécessaire de gérer 
        // le cas où la déstructuration échoue.
    }
    // ^ `if let` permet d'ajouter des branches `else`/`else if` 
    // optionnelles. `while let` ne le permet pas, en revanche.
}