GwenLg a écrit 51 commentaires

Petite note d'encouragement concernant Rust.

J'étais moi aussi un programmeur C/C++, et je me suis mis à apprendre Rust il y a un peu moins de deux ans.
Effectivement la transition n'est pas toujours facile, et je conseillerais d'avoir une personne qui peux nous débloquer en cas de besoin et/ou de suivre une petite formation.

Mais je trouve que ça vaut largement l'effort. Il y a tellement de progrès par rapport à C/C++.
Un exemple:
Il y a quelques jours j'ai voulu utiliser réutiliser un projet Rust, et le code actuel avait un warning sur un bout de code.
Ce code construisait, à partir d'un array (tableau static) un autre array de même taille. C'était fait à la méthode C++, avec un for.
Mais pour être certain que toutes les valeurs de l'array de sortie soit bien initialisé, il fallait avant de faire la boucle for, initialiser le tableau avec des valeurs par défaut, sinon le compilateur n'est pas content, car il n'est pas capable de vérifier que le code dans le for initialise bien tout l'array.
La limite de ça, c'est que du coup le compilateur ne nous aide pas à vérifier que la boucle for initialise bien toutes les valeurs, et que du coup on n'a pas des valeurs par défaut qui pourraient traîner dans le tableau.

// Generate an array from another, C++ way.
fn array_from_another(input: &[f32; 16]) -> [f32; 16] {
    let mut output: [f32; 16] = Default::default();
    for (i, x) in input.iter().enumerate() {
        let a = value_convertion(x[0]);
        let b = value_convertion(x[1]);
        let c = value_convertion(x[2]);
        output[i] = 0.2126 * a + 0.7152 * b + 0.0722 * c;
    }
    return output;
}

Je trouvais ça dommage, et en cherchant comment améliorer le code j'ai découvert que la primitive array possédait une méthode map. J'ai pu donc réécrire le passage en question en code 'fonctionnel'. Le nouveau code :
- évite une double initialisation du tableau (même s'il n'y avait pas de problème de performance dans ce cas)
- est plus concis et évite toute une partie "glu"
- permet d'être plus explicite sur les intentions du code, ce qui permet au compilateur de vérifier plus de chose, mais aussi d'être plus facilement lisible par les humains (quand on s'y est habitué)

// Generate an array from another Rust way.
fn array_from_another(input: &[f32; 16]) -> [f32; 16] {
    input.map(|x| {
        let a = value_convertion(x[0]);
        let b = value_convertion(x[1]);
        let c = value_convertion(x[2]);
        0.2126 * a + 0.7152 * b + 0.0722 * c
    })
}

le diff est visible ici

Note: Bien sur, ce n'est pas forcément exceptionnel, ça doit exister ailleurs, mais quand on vient du C++ et combiné avec toutes les autres fonctionnalités de Rust ça en fait un langage qui mérite qu'on s'y intéresse

Donc @AncalagonTotof je te conseille de continuer d'essayer de faire le tuto Rust. Avec Codium et le plugin Rust qui va bien ;)