L'équipe de développement de Rust annonce la sortie de la version 1.32 stable du langage. Pour mémoire Rust est un langage conçu et développé par Mozilla, qui l'utilise notamment por écrire le moteur de rendu Quantum de son navigateur Firefox.  

Cette version vient comme il se doit avec de nombreuses nouveautés et améliorations. Nous nous intéresserons ici aux améliorations de la qualité de vie, selon les termes de l'équipe Rust.

Il s'agit de la qualité de vie des développeurs, c'est bien d'y penser :-) Rust 1.32 veut leur faciliter la tâche notamment en ce qui concerne le débogage.

Si vous faites partie de ceux qui aiment bien que le code en cours de développement affiche quelques valeurs lors de l'exécution, vous deviez procéder ainsi, par exemple :

let x = 5;
println!("{:?}", x);

// ou peut-être comme ceci</>
println!("{:#?}", x);

Pas très agréable à écrire... Rust vient avec une nouvelle macro, dbg!, qui facilite indéniablement la vie :

fn main() {
    let x = 5;

    dbg!(x);
}

Ce qui va afficher à l'exécution :

[src/main.rs:4] x = 5

La macro dgb! affiche ses sorties sur le canal standard stderr. Pour mémoire println! affiche sur stdout. (il fallait utiliser eprintln! pour obtenir des sorties sur stderr).

Cette nouvelle macro dbg! fonctionne dans des contextes complexes et le fait qu'elle renvoie la valeur de ce qu'elle est en train de débogueur procure des sorties beaucoup plus explicites et utiles. Soit une fonction factorielle classique :

fn factorial(n: u32) -> u32 {
    if n <= 1 {
        n
    } else {
        n * factorial(n - 1)
    }
}

Avant pour la débogueur il fallait écrire ceci

fn factorial(n: u32) -> u32 {
    eprintln!("n: {}", n);

    if n <= 1 {
        eprintln!("n <= 1");

        n
    } else {
        let n = n * factorial(n - 1);

        eprintln!("n: {}", n);

        n
    }
}

ce qui est assez lourd, pour obtenirune sortie comme ceci :

n: 4
n: 3
n: 2
n: 1
n <= 1
n: 2
n: 6
n: 24

Avec la macro dbg! tout s'allège :

fn factorial(n: u32) -> u32 {
    if dbg!(n <= 1) {
        dbg!(1)
    } else {
        dbg!(n * factorial(n - 1))
    }
}

Et la sortie produite est beaucoup plus intéressante

[src/main.rs:3] n <= 1 = false
[src/main.rs:3] n <= 1 = false
[src/main.rs:3] n <= 1 = false
[src/main.rs:3] n <= 1 = true
[src/main.rs:4] 1 = 1
[src/main.rs:5] n * factorial(n - 1) = 2
[src/main.rs:5] n * factorial(n - 1) = 6
[src/main.rs:5] n * factorial(n - 1) = 24
[src/main.rs:11] factorial(4) = 24