IV. Annexes

1. Codes annexes

Cette section n'a pas réellement d'intérêt si ce n'est montrer quelques fonctionnalités ou comportements que j'ai trouvé intéressants.

Écrire des nombres différemment

Runlet a = 0_0;
let b = 0--0_0--0;
let c = 0-!0_0-!0;
let d = 0xdeadbeef;
let e = 0x_a_bad_1dea_u64;

On peut aussi se servir du _ pour faciliter la lecture des nombres :

Runlet a = 12_u32;
let b = 1_000_000;

Toujours plus de parenthèses !

Runfn tmp() -> Box<FnMut() -> Box<FnMut() -> Box<FnMut() -> Box<FnMut(i32) -> i32>>>> {
    Box::new(|| { Box::new(|| { Box::new(|| { Box::new(|a| { 2 * a }) }) }) })
}

fn main() {
    println!("{}", tmp()()()()(1));
}

Utiliser la méthode d'un trait

Vous savez qu'il est possible de définir une méthode dans un trait, mais qu'on est forcé d'implémenter ce trait pour pouvoir l'appeler. Hé bien voici une méthode pour contourner cette limitation :

Runtrait T {
}

impl dyn T {
    fn yop() {
        println!("yop");
    }
}

fn main() {
    <dyn T>::yop()
}

Toujours plus vers le fonctionnel avec le slice pattern !

Cette fonctionnalité assez intéressante permet de directement matcher une valeur d'un tableau (et aussi de s'assurer qu'il n'est pas vide) :

Runfn sum(values: &[i32]) -> i32 {
    match values {
        [head, tail @ ..] => head + sum(tail),
        [] => 0,
    }
}

fn main() {
    println!("Sum: {}", sum(&[1, 2, 3, 4]));
}

Une autre façon de faire des boucles infinies

Tout le monde connait loop et while true je présume. Hé bien il existe d'autres façons de faire des boucles infinies dont notamment :

Runfor idx in 0.. {
    // le code
}

Pratique dans le cas où on veut une boucle infinie avec un index pour savoir à quelle itération on en est !

Calculer des factorielles avec un itérateur

Il est possible de calculer des factorielles en utilisant la méthode Iterator::product :

Runfn calculer_factorielle(f: usize) -> usize {
    (1..=f).into_iter().product()
}

Façon alambiquée d'itérer sur un Range

Il est possible de renvoyer une valeur avec break, ce qui permet dans le code qui suit :

Runfor x in loop { break 0..2 } {
    println!("{x}");
}

fonctionne de la même façon que :

Runfor x in 0..2 {
    println!("{x}");
}