Ton cerveau sur du Rust

Ecrit le , 3 minutes de bouquinage

Une traduction littérale de "Your brain on Rust". Peut-être qu'écrire cette première esquisse d'article à 01:12 n'était pas une si bonne idée après tout ?

J'ai passé quelques jours à apprendre le Rust par moi-même malgré un été qui s'annonce bien (trop) chaud. J'ai mieux retenu les concepts que la première fois que j'ai tenté d'apprendre; les détails ci-dessous.

En cherchant un peu sur la page du langage, dans la barre de navigation, il y a un lien qui mène vers une page avec les supports d'apprentissage qui permettront d'apprendre le Rust. Sur cette page, il y a un lien vers un chouette projet qui vous enseigne le langage par la pratique et pas à pas: rust-lang/rustlings.

Comme dit plus haut, j'ai déjà tenté d'apprendre Rust une première fois en lisant le manuel. Il me semble que le projet rust-lang/rustlings n'existait pas et le manuel était pratiquement le seul support d'apprentissage, en plus du guide Rust par la pratique. J'ai retenu quelques bricoles avant de lâcher prise sur une bagarre avec le borrow-checker. Maintenant, avec les exercices proposés, j'ai pu retenir une plus grosse partie du langage et j'ai mieux compris les sémantiques du borrow-checker.

Un exmeple d'exercice donné sur un type standard, les itérateurs:

// iterators4.rs

// I AM NOT DONE

pub fn factorial(num: u64) -> u64 {
    // Complete this function to return the factorial of num
    // Do not use:
    // - return
    // Try not to use:
    // - imperative style loops (for, while)
    // - additional variables
    // For an extra challenge, don't use:
    // - recursion
    // Execute `rustlings hint iterators4` for hints.
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn factorial_of_1() {
        assert_eq!(1, factorial(1));
    }
    #[test]
    fn factorial_of_2() {
        assert_eq!(2, factorial(2));
    }

    #[test]
    fn factorial_of_4() {
        assert_eq!(24, factorial(4));
    }
}

Oui, calculer une factorielle en une ligne, sans return, boucles impératives, variables supplémentaires et récursion est possible. Étant donné que cet exercice est donné la partie des itérateurs des types standards, je vous laisse imaginer ce qui viendrait calculer la factorielle.

Il y a également un exercice dédié aux threads et l'exécution concurrentielle sur Rust. Un exercice, certes un peu plus tordu que les autres, mais qui introduit des concepts plus ou moins intéressants.

Ma première impression du langage est qu'il est intéressant de part une syntaxe qui ne dépayse pas trop (::<u64> est un "turbofish". Le rapport avec un poisson ?). Je n'attends que faire quelque chose avec.