Bonjour,

J'ai écrit un tutoriel sur le langage Rust disponible à cette adresse. Présenter ce projet personnel ici a pour moi deux buts :

- Le faire connaître aux gens ne connaissant pas du tout Rust.

- Avoir la possibilité d'obtenir des retours sur mon tutoriel (erreurs, possibles améliorations, etc...).

En espérant qu'il vous plaira !

-
Edité par imperio 5 juillet 2015 à 17:22:01

imperio a écrit:

Bonjour,

J'ai écrit un tutoriel sur le langage Rust disponible à cette adresse. Présenter ce projet personnel ici à pour moi deux buts :

- Le faire connaître aux gens ne connaissant pas du tout Rust.

- Avoir la possibilité d'obtenir des retours sur mon tutoriel (erreurs, possibles améliorations, etc...).

En espérant qu'il vous plaira !

-
Edité par imperio il y a environ 14 heures

Salut imperio,

Je trouve dommage que tu reprennes les notions de e-book de rust-lang officiel (malgré qu'ils soient tournés sous une autre forme), cependant certain pourront apprécier le fait de lire un tutoriel en Français. J'ai feuilleté rapidement, si je ne me trompe pas tu ne parle pas de BufReader, qui pourtant est un quelque chose de très utile lorsqu'on manipule des fichiers (ou encore des sockets!).

Voilà, cela reste probablement une source sure pour les débutants en Rust, et bien sur en Français :).

Bonne soirée.

Je ne suis pas sûr de te comprendre : "les notions de e-book" ? Qu'est-ce que tu entends par là ?

Le but du cours est juste une introduction à Rust pour les développeurs. Je pense qu'ils sont à même de faire les recherches correspondantes ensuite pour trouver ce qui leur manque. Après je ne suis pas contre ajouter de nouveaux chapitres, mais BufReader ou Socket ne me semble pas très utile dans l'immédiat. Cela dit, si d'autres personnes me le demandent, je les ajouterai.

En tout cas merci de ton retour !

La font me fait très très mal aux yeux... Mais c'est cool franchement, un tuto en Français ça peut être bien utile pour pas se prendre la tête et démarrer

Fire4764: Erreur de ma part, la font size avait été réinitialisée à 300 donc c'était relativement moche. Je l'ai de nouveau remise à sa valeur initiale. Tu peux me dire si c'est bon pour toi ?

-
Edité par imperio 22 juin 2015 à 11:17:36

J'en profite pour annoncer que j'ai ajouté plusieurs chapitres (dont un sur les threads).

imperio a écrit:

Fire4764: Erreur de ma part, la font size avait été réinitialisée à 300 donc c'était relativement moche. Je l'ai de nouveau remise à sa valeur initiale. Tu peux me dire si c'est bon pour toi ?

-
Edité par imperio le 22 juin 2015 à 11:17:36

Ouaip niquel merci

Je pense que ton tutoriel plus complet :

Déjà, tu ne parle pas des enums qui sont pourtant une fonctionnalité très importante du langage. Pas mal de pattern manquant (..., @, déréférancement…).Ensuite tu utilise pas mal de fonctionnalité que tu n'explique pas comme les attributs ou les "pub", et pas mal d'autre truc qui sont tout de même important.

Sur les structures, il me semble qu'il y a une erreur : il y en a que 3 types, ce que tu appelle "tuple" est là un "tuple struct" comme celui que tu appelle comme çà. Les tuples ne sont pas vraiment des structures et ont peux directement en créer sans déclarer le type (d’ailleurs un tuple une sémantique de copie lorsque que tous ses champs utilisent une sémantique de copie contrairement aux structures). Tu devrais présenté les tuples dans le chapitres sur les variables et montrer tout ce qu'on peut faire avec.

let a = (2, 3, "coucou");
let (b, _, c) = a;
...

Tu utilise aussi des "int" quelque fois alors que ça n'existe plus et il y a plein d'autre que je pourrais redire et ajouté, pas mal de chose qu'il faudrait mieux expliqué et détaillé, mais ça risque d'être un peu long et tu as dis que c'était juste une introduction donc je vais en rester là. (invite tout de même les gens à lire le book et rustby exemple)

Sinon j'avais moi aussi eu l'idée de faire un tuto sur Rust mais je n'ai pas assez pratiqué le langage et j'ai un mauvais niveau d'anglais qui rendent la compréhension de certains aspect difficile.

Rust devrait être plus connu, c'est un langage qui apporte vraiment quelque chose, bien plus que Go et Swift pour ma part. En tout cas, il est devenu mon langage préféré et je suis très content qu'il y a d'autre personne qui essaye de le faire connaître .

@ ? Là pour le coup je connais pas. Je sais que ça existait dans une version précédente mais je ne l'ai jamais croisé (et pourtant je fais du Rust depuis bientôt deux ans !).

Je parle du déréférencement (c'est le chapitre 7 de la partie 2). Je ne l'ai ajouté qu'il n'y a quelques jours, peut-être ne l'as-tu pas vu ? 

Je n'ai pas parlé des enums ?! Oula, gros oubli, va falloir que je me dépêche de le rajouter, merci de me le dire.

Concernant les différents types de structures, le rustbook dit qu'il y en a 4, donc j'ai préféré reprendre ce nombre et leur explication pour ne pas embrouiller les gens qui voudraient s'y référer plus tard.

Je crois que le rustbyexample n'est plus à jour depuis un certain temps. Il faudrait que je me renseigne... Je vais ajouter un lien pour le rustbook.

Concernant les int, j'avais eu des retours à ce sujet il y a plusieurs semaines, il ne semblait pas qu'il en restait... Je regarde !

Rien ne t'empêche d'ajouter des chapitres ou de corriger des choses. Pour cela, passe par le dépôt github et n'oublie pas de préciser que c'est toi qui as écrit ce chapitre en fin de page.

En tout cas merci beaucoup pour ces retours ! J'espère que tu contribueras au tutoriel et qu'on se recroisera à l'occasion sur #rust-fr. 

-
Edité par imperio 4 juillet 2015 à 22:05:59

Pour le @, c'est un pattern pour nommer une variable quand on utilise un Range :

match 42 {
    x @ 10...100 => println!(x)
    _ => unreachable!()
}

Pour le déréférencement, je voulais en fait parler du binding mais on peut quand même faire du déréférencement dans un match.

Pour les structures, je viens de regarder le book mais je ne vois pas où ils disent qu'ils n'y en a 4 et il parle bien de la strut à 1 attribut mais ne le nomme pas (un tuple struct à 1 attribut). Ce que tu appelle des tuples sont bien des tuples structs. D'ailleurs ton exemple ne compile pas :

let t : Tuple = (0, 2, false); // Le tuple

 Il faudrait plutôt écrire :

let t : (_, _, _) = (0, 2, false); // tuple simple
let ts : Tuple = Tuple(0, 2, false); // tuple struct

Le rustbyexemple m'avais semblé utilisé la version 1, à vérifier…

Pour la contribution je sais pas, à voir, je ne suis pas encore tout à fait au point sur le langage. Si je le fais, je mettrais sûrement plein d'exemple pour bien montrer tout ce qu'on peut faire. Après je sais pas si tu vises un petit tuto simple pour présenter un peu ou un gros tuto bien complet.

-
Edité par nyco240594 5 juillet 2015 à 1:37:43

Hum, en effet... Le book a changé depuis la dernière fois, il faut que je mette mon tuto à jour ! J'vais aussi mettre à jour l'exemple pour qu'il compile.

Merci pour le @, je connaissais pas du tout, j'vais ajouter ça aussi !

Merci pour tout. Si jamais l'envie t'en prends, n'hésite pas à ajouter des choses ou autres, toute contribution est la bienvenue, je ne le dirai jamais assez. 

Je viens de regarder à nouveau le tuto, il semble il y avoir un petit problème à la fin du pattern matching, tout le texte est devenue un lien mais ce n'est pas visible sur github.

Aussi il n'y a pas besoin d'ajouter un @ c'est juste pour récupérer la variable :

match x {
    'a' ... 'j' => println!("early letter"),
    'k' ... 'z' => println!("late letter"),
    _ => println!("something else"),
}

La page du book indique encore quelque autre patterns, il y en a ensuite d'autre disséminer ailleurs comme le ref pattern (pas réussi à le retrouver celui-là, je crois que je l'ai vu dans rustbyexemple). Il est toujours bon de relire les tutos, on découvre parfois des trucs (surtout quand ils changent…).

Un autre truc très intéressant avec les patterns est quand on les combinent avec les tuples( encore eux), par exemple pour un and avec un boolean ternaire :

pub enum Tribool{
    True, False, Unknow
}

impl BitAnd for Tribool{
    type Output = Tribool;

    fn bitand(self, rhs: Tribool) -> Tribool{
        // on met les variables dans un tuple
        match (self, rhs) {
            (True, True) => True,
            (False, _) | (_, False) => False,
            _ => Unknow
        }
    }
}

Je regarderais plus tard pour voir ce que je pourrais ajouter, ça fait longtemps que je ne suis pas aller sur github et j'ai encore du mal à l'utiliser. Pour l'instant je fais de petit programme pour m’entraîner,je passerais ensuite aux choses sérieuses .

Okay ! J'ai mis à jour le tutoriel. Encore merci pour ces précisions ! Si jamais t'as besoin d'aide pour te remettre à git et github, n'hésite pas à me contacter. 

Hello,

Je sais que ce sujet date un peu mais je relance quand même.

Je viens du PHP donc les langages compilés sont assez lointains pour moi. Je voulais me mettre au Rust et j'étais très content de voir un tuto en français

Mais je le trouve pas pratique pour quelqu'un qui n'y connait absolument rien au langage.

J'en suis qu'au chapitre 1, les bases, je comprends quelques notions mais souvent tu utilises des fonctionnalités, des termes ou autres sans les expliqués comme si on était déjà censé les connaître.

Donc plus clairement je comprends rien

Par exemple, un moment tu passes de ça :

let x = Some(10);

if let Some(10) = x {
    // faire quelque chose
} else if let Some(11) = x {
    // ...
}

(déjà on sait pas ce qu'est le `Some` mais ok)

à ça :

let x = Ok(Some(Ok(Ok(2))));

if let Ok(Some(Ok(Ok(2)))) = x {
    // ...
}

Sans expliquer quoi que ce soit. C'est quoi les `Ok`. La seule phrase qui accompagne est "Vous pouvez bien évidemment le faire sur autant de "niveaux" que vous le souhaitez".

J'ai pris cet exemple mais il y en a plein dès le début, et là j'en suis qu'au chapitre 1.6

Enfin dans tout ça, merci quand même pour ton tuto je me doute que ce n'est pas un travaille bien facile que tu as effectué là. Mais juste ma remarque est qu'il n'est pas assez accessible.