Bonjour,
J'ai parcouru ton tuto hier, et voici quelques commentaires qui j'espère, pourront t'aider. Je précise que je débute en Rust, donc si les points relevés ne sont pas pertinents ou faux, n'hésite pas à me le faire remarquer ;).
Sur ta partie sur les variables, tu passes très rapidement sur la mutabilité. Je pense que quelqu'un n'ayant pas une grande expérience en programmation n'y verra la qu'une contrainte pénible du langage, et aura donc tendance à mettre des let mut partout, pour ne pas s'embêter avec ce problème. D'autant plus que tu présentes ça sous la forme « sans mut on a une erreur, avec mut, ça marche !».
Sur cette même partie, tu parles de l'inférence de type un peu plus tard, alors que tous tes exemples avant utilisent justement l'inférence de type. Peut-être est-il plus judicieux que les exemples avant déclarent les types des variables explicitement, pour ensuite introduire l'inférence de type ?
Tu fais une remarque sur la notation i++, en soit ce n'est pas gênant, mais je trouve que ça arrive un peu comme un cheveu sur la soupe, je ne vois pas trop le rapport avec la partie (enfin si, je vois pourquoi tu précises ça, mais je ne suis pas certain que ce soit très utile, par exmple, ça n'a rien de surprenant pour quelqu'un ayant déjà fait du Python).
Quand tu parles des slices, le commentaire de la deuxième ligne est faux (« à partir du 2e élément ») :
| let tab = [0, 1, 2]; // tab est un tableau contenant 0, 1 et 2
let s = &tab; // s est maintenant une slice commençant à partir du 2e élément de tab
println!("{:?}", s); // ça affichera "[0, 1, 2]"
let s = &tab[1..]; // s est maintenant une slice pointeur le 2e élément de tab
println!("{:?}", s); // ça affichera "[1, 2]"
|
Sur le pattern matching :
| let my_string = "hello";
let s = match my_string {
"bonjour" => "francais",
"ciao" => "italien",
"hello" => "anglais",
"hola" => "espagnol",
_ => "je ne connais pas cette langue..."
}; // on met un ';' ici car ce match retourne un type
println!("{}", s);
|
Le match ne retourne pas un type, mais plutôt une expression ou une valeur, non ?
Au moment où tu parles de la boucle while, il y a un qu qui traine dans ton code d'exemple ! i += 1;qu
Une petite remarque qui me vient à l'esprit, tu utilises alternativement la syntaxe let mut i = 0i32; et let mut i : i32 = 0;, peut-être est-il mieux de n'utiliser que la seconde pour une question de consistance ?
Lorsque tu parles des expressions, tu dis à un moment « une assignation de valeur retourne le type () », ne faudrait-il pas plutôt dire « la valeur () » ?
Sur la distinction tuple / struct tuple, ton exemple de tuple (struct Tuple(isize, usize, bool);) est justement un struct tuple, non ?
Dans cette même partie, tu donnes un exemple contenant la ligne let Distance(longueur) = distance;, je pense que tu pourrais caser une petite phrase pour préciser que cette ligne permet de déstructurer la structure, j'ai dû faire des recherches par moi-même pour comprendre cette notation.
« À présent, venons-en au '&' devant le self : c'est la durée de vie de l'objet. » : est-ce exact de parler de durée de vie ? &self ne fait pas plutôt reférence à la notion de proprieté (référence sur self) ?
Au début du chapitre sur le déférencement, tu écris :
« Cependant, il est aussi possible de faire :
| let x = String::new();
let deref_x = *x; // ce qui renvoie une erreur car le type str n'implémente pas le trait Sized
|
»
Du coup, ce n'est pas possible de le faire, vu que ça renvoit une erreur ;). Et tu fais référence au trait Sized, ce qui est déroutant pour le lecteur qui va essayer un code qui ne compile pas, mais il ne sait pas pourquoi. Peut-être pourrais-tu écrire une petite phrase pour dire que tu vas parler de Sized plus tard ?
| #![feature(box_syntax)]
let a : [u8; 100000] = [0; 100000]; // bof...
let b : Box<[u8; 100000]> = box new([0; 100000]; // mieux !
|
Il manque une parenthèse !
Voila les quelques remarques que j'avais pu noter au cours de ma lecture, j'avoue être passé plus rapidement sur la suite du tutoriel.
En plus de ça, quelques commentaires sur l'ensemble : je ne peux que rejoindre l'avais de Gabbro et nohar, le tutoriel ressemble un peu trop à une liste des spécifités du langage, sans trop de liens. Je pense que dans l'ensemble, tu pourrais appuyer un peu plus sur le pourquoi les créateurs de Rust ont conçu le langage d'une telle façon, et pas d'une autre, pour ne pas que le lecteur ait l'impression qu'au final, Rust ce n'est qu'une suite de contraintes dont on ne voit pas trop l'interêt.
En tout cas, merci et bravo de t'être attelé à la rédacction d'un tutoriel sur Rust, ça fait toujours plaisir de voir des ressources en français sur ce jeune langage :).
Faire un tuto prend beaucoup de temps, d'autant plus quand il est bien fait (ce qui semble être le cas ici).
