Skip to content

Projet Guessing Game

On poursuit l'exploration du book

Création du projet

Depuis mon dossier RUST :

cargo new guessing_game
On ouvre ensuite ce dossier directement dans VSCodium.

Premières lignes de code

On complète le fichier src/main.rs :

use std::io;

fn main() {
    println!("Guess the number!");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {guess}");
}

Puis on exécute, sans problème. Je tente un debugging, pas de soucis : on va commencer à apprendre réellement la syntaxe et les principes de Rust.

Analyse des lignes du code

On regarde uniquement les nouveautés :

  • use std::io; : utilise la librairie io (inputs/ouputs) de la librairie standard.
  • let mut guess = String::new(); :
    • let : permet de définir une variable, immutable par défaut ;
    • let mut : évidemment, la variable devient mutable ;
    • guess = String::new() : la variable s'appelle guess, et elle sera liée à un objet String (avec un «S» majuscule), qui est un type de chaine de caractère extensible encodé en UTF-8, porésent dans la librairie standard. ::new(), j'imagine fait appel à la méthode permettant de construire un nouvel objet String, vide.
  • On va maintenant regarder le bloc de code suivant :
    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");` 
    
    • io::stdin() : Ayant importé le module io, on peut utiliser cette syntaxe pour appeler la fonction stdinainsi, Sans importe le module, on aurrait écrit std::io::stdin(). Cette fonction renvoie une instance de std::io::Stdin, qui représente le type permettant de récupérer une entrée depuis le terminal.
    • .read_line(&mut guess) : appelle la méthode read_line, avec l'argument &mut guess. L'argument doit être mutable pour que la méthode puisse modifier le contenu de la chaine référencée par guess. L'esperluette & indique qu'il s'agit d'une référence. Par défaut, les références sont immutables, donc il faut écrit &mut pour la rendre mutable (bon, pour l'instant c'est flou, et ça va s'éclaircir plus tard). A noter que read_line mùodifie l'argument qui lui est passé selon ce qui est saisi dans le terminal, mais elle renvoie aussi une valeur de type Result, qui est du type enum (une énumération) : c'est un type pouvant être dans plusieurs états, aussi appelées variantes. Ici les variantes de Result sont Ok et Err
    • `#!rust .expect("Failed to read line"); : expect est une méthode du type Result, qui va arrêter le programme et afficher le message passé en argument. A noter que si la méthode n'est pas utilisée, le compilateur va signaler que le programme peut ne pas prendre en charge une erreur potentielle.
  • println!("You guessed: {guess}");: On utilise un formatage de chaine de caractère. C'est aussi possible d'utiliser les placeholders en évaluant une expression, en utilisant la syntaxe suivante :
    let x = 5;
    let y = 10;
    
    println!("x = {x} and y + 2 = {}", y + 2);
    
    Il semblerait que, contrairement à Python, il ne soit pas possible d'évaluer une expression directement dans les placeholders.

Les «crate»

De ce que je comprends pour l'instant, un «crate» (une caisse) est une collection de codes sources Rust. Le projet de guessing_game est lui même un «crate». On va utiliser le crate rand, qui contient du code ne pouvant être exécuté de lui-même.

Pour utiliser rand, il faut modifier le fichier Cargo.toml, pour ajouter rand en tant que dépendance. On ajoute ainsi :

[dependencies]
rand = "0.10.1"

Cargo comprends le [Semantic Versioning](https://semver.org/]{target="_blank"} ou SemVer, qui est un standard pour l'écriture des numéros de versions. Ici 0.10.1 signifie en réalité ^0.10.1, soit toute version supérieure ou égale à 0.10.1 et strictement inférieure à 0.11.0.

On lance une compilation avec cargo build, et on observe le téléchargement des dépendances. un avertissement apparait : nous n'utilisons pas dans le projet pour l'instant le crate rand.

Le fichier Cargo.lock contient toutes les versions utilisées lors du premier build, et c'est ce fichier qui sera lu pour les prochaines compilations ( il n'y aura pas de mise à jour automatiques).

Pour mettre à jour les versions, on peut utiliser cargo update, qui modifiera le fichier Cargo.toml.

Générer un nombre aléatoire

On ajoute :

  • avant la fonction la ligne use rand::prelude::*; : le module prelude contient toutes les éléments utilisés de manière commune du crate rand, et l'utilisation de use rends ces items disponibles dans la portée de notre programme (portée au sen de portée des variables - program's scope).
  • dans le corps de la fonction, les lignes suivantes :
    let secret_number = rand::rng().random_range(1..=100);
    
    println!("The secret number is: {secret_number}");
    
    La première ligne crée une variable secret_number. On affecte à cette variable un nombre compris entre 1 et 100 (bornes inclues).

Bon quelques éléments du book sont assez obscurs :

  • rand::rng() : si j'ai bien compris, sélectionne comme générateur de nombre pseudo-aléatoire la fonction rng, qui va utiliser une graine dépendant du thread d'exécution de notre programme.
  • .random_range() : bon, là ça devient obscur. A priori random_range est une méthode provenant de RngExt qui provient lui-même du module rand::prelude.
  • "!rust 1..=100 : signifie de 1 à 100 inclus, c'est pas trop compliqué jusque là.

Le book propose d'essayer la commande suivante pour explorer un peu rand :

cargo doc --open

Bon, en lisant, on constate que le vocabulaire utilisé est Trait pour RngExt. A priori c'est un «truc» qui génère automatiquement une interface utilisateur pour tous les RNG disponibles.

Pour l'instant, on va accepter de ne pas tout comprendre... Quoi qu'il en soit, ça fonctionne comme prévu.

Comparer des valeurs

Bon, le book nous amène d'abord sur une fausse piste, mais en utilisant un code bizarre :

use std::cmp::Ordering;
use std::io;

use rand::prelude::*;

fn main() {
    // --snip--

    println!("You guessed: {guess}");

    match guess.cmp(&secret_number) {
        Ordering::Less => println!("Too small!"),
        Ordering::Greater => println!("Too big!"),
        Ordering::Equal => println!("You win!"),
    }
}

Primo, on importe un type std::cmp::Ordering, qui est une autre enum, ayant pour variantes Less, Greater et Equal.

Puis on appelle la méthode cmp sur guess, à qui on passe en argument une référence à secret_number. Normalement, cmp renvoie une des variantes d'Ordering (il me semble là qu'il y a une différence avec les imports de Python : ici il semblerait qu'on ait importé à la fois cmp et Ordering ? Nous verrons ça plus tard...). On utilise ensuite une expression match pour savoir quoi faire selon la variante renvoyée.

Danger

Évidemment, ça ne fonctionne pas, la compilation renvoie l'erreur prévisible sur les types :

Compiling guessing_game v0.1.0 (/mnt/sdb1/Documents/RUST/guessing_game)
error[E0308]: mismatched types
    --> src/main.rs:22:21
    |
 22 |     match guess.cmp(&secret_number) {
    |                 --- ^^^^^^^^^^^^^^ expected `&String`, found `&{integer}`
    |                 |
    |                 arguments to this method are incorrect
    |
    = note: expected reference `&String`
            found reference `&{integer}`

Il faut donc faire un transtypage de guess en entier (u32 pour entier non signé sur 32 bits ), en ajoutant après la saisie la ligne suivante :

let guess: u32 = guess.trim().parse().expect("Please type a number!");

Alors comment décrypter cette ligne :

  • let guess : on va masquer la précédente valeur de guess (c'est la traduction littérale, en python j'aurai dit réaffecter, mais je ne maitrise pas suffisament Rust pour savoir si ce terme pourrait convenir.)
  • .trim() : guess est une chaine de caractère, on la nettoie des espaces inutiles avant et aptès la chaine de caractère, et surtout on supprime le \n de fin de ligne qui est récupéré par read_line;
  • .parse() : c'est le transtypage, On va convertir en u32 (définit par le :u32 après guess). Comme le transtypage peut ne pas réussir (si il y a des caractères autres que des chiffres par exemple), parse() renvoie un objet de type Result, qui va être traité par le .expect() comme on l'a déjà vu.

Et maintenant, ça fonctionne !

Danger

Deux remarques à ce stade :

  • les chaines de caractères ne sont définies que par des guillemets doubles " ;
  • c'est expect et pas except...