Bonjour,
Il serait mieux que les boutons run qui permettent de tester le code ouvrent un nouvel onglet.
En effet, une fois sur play.rust-lang.org, quand on fait différents essais, il faut cliquer plusieurs fois sur le bouton de retour à la page précédente, alors qu'avec un nouvel onglet, il suffirait de fermer cet onglet.
D'avance merci.
Ciola

PS : Je suis débutant en rust et je ne sais pas si je dois poster une issue à chaque fois que je vois quelque chose à améliorer.
Existe-t-il une autre procédure?
D'avance merci.

Bonjour,
Je trouve que pour un livre qui s'Adresse aux débutants, il serait bon d'expliquer tous les concepts sans faire appel à d'autres langages.
Ex. "Sachez cependant que les types isize et usize existent aussi et sont l'équivalent de intptr_t et de uintptr_t en C/C++. En gros, sur un système 32 bits, ils feront respectivement 32 bits tandis qu'ils feront 64 bits sur un système 64 bits."

Un link permettant d'aller de fichiers en fichiers pourrait etre utile :P

Dans la descriptions des structures, la structure unitaire "Comment peut-on utiliser une structure sans savoir ce qu'elle contient ? o_O". On appelle ce genre de structure des structures opaques. Cf http://en.wikipedia.org/wiki/Opaque_data_type

Certains mots ont été traduits de l'anglais, il serait bien de donner leur traduction en anglais pour éviter que les gens ne soient perdus s'ils cherchent quelque chose.

Bonjour,

Je suis en train de suivre votre tuto Rust, qui est super bien fait, merci pour cela !

Dans le chapitre "Jeu du Plus ou Moins", dans votre solution pour générer un nombre aléatoire entre 1 et 100, j'obtiens une erreur.

let nombre_aleatoire = rand::thread_rng().gen_range(1, 101);

Dans la doc de rand, il semble qu'il faille utiliser:

let nombre_aleatoire = rand::thread_rng().gen_range(1..101);

Donc .. entre les deux valeurs et non , .

En espérant que cela soit utile pour les autres.

Cheers

L'avant dernier bloc d'exemple (en bas de la page) de II.5 (https://blog.guillaume-gomez.fr/Rust/2/5) sur l'ownership est indiqué comme ne compilant pas, or, il semble que désormais le compilateur n'ait pas de problème avec ce code :

fn main() {
    let reference: &i32;
    let x = 5;
    reference = &x;

    println!("{}", reference);
}

Il faudrait donc sûrement retravailler ce passage qui proposait un version corrigée du code juste en-dessous.

Bonjour,
Il semble que le dernier point-virgule ne soit pas nécessaire dans les codes suivants :
---------------------------- code 1-----------------------------------

    let i = 0i32;
    
    match i {
        10..=100 => println!("La variable est entre 10 et 100 (inclus)"),
        x => println!("{} n'est pas entre 10 et 100 (inclus)", x)
    }

------------------------------code 2-----------------------------------

let i = 0i32;

match i {
    x @ 10..=100 => println!("{} est entre 10 et 100 (inclus)", x),
    x => println!("{} n'est pas entre 10 et 100 (inclus)", x)
};

------------------------------------code 3----------------------------
Idem avec la dernière virgule

match une_variable {
    "jambon" | "poisson" | "œuf" => println!("Des protéines !"),
    "bonbon" => println!("Des bonbons !"),
    "salade" | "épinards" | "fenouil" => println!("Beurk ! Des légumes !"),
    _ => println!("ça, je sais pas ce que c'est..."),
}

De plus, ce serait bien de commencer avec des instructions uniques, puis de montrer l'utilisation d'accolades quand il y a plusieurs instructions et que cela est nécessaire. Je trouve que c'est plus efficace en terme de codage.

match une_variable {
    valeur_1 => instruction_1,
    valeur_2 => instruction_2,
    ...
    valeur_n => instruction_n,
    _ => instruction_complémentaire
}

match une_variable  {
    valeur_1 => {
       instruction_1;
       instruction_2;
    }
    valeur_2 => {
       instruction_3;
       instruction_4;
    }
    _ => {instructions_complémentaires}
}

Pour le moment je crois que criterion est toujours la référence. Recommander d'utiliser clippy aussi.

Bonjour,
Je ne comprends pas les explications. Il faudrait rentrer un peu plus dans les exeplications du binder.
-------------------------------------- extrait --------------------------------------
Pratique ! Vous pouvez aussi "binder" (ou matcher sur un ensemble de valeurs) la variable avec le symbole "@" :

let i = 0i32;

match i {
    x @ 10..=100 => println!("{} est entre 10 et 100 (inclus)", x),
    x => println!("{} n'est pas entre 10 et 100 (inclus)", x)
};

Hello Guillaume!

Comme tu as pu le voir je maintiens https://github.com/darnuria/rust-atelier/

Si tu vois des trucs qui te plaisent dit moi je peux adapter la licence ou ceder des bouts ou faire "dans le style de" pour ton tutoriel. :)

Plusieurs personnes m'ont fait la demande d'un tel chapitre.

low: imperio: un truc sur les Vec, Path, PathBuf, String, &str ce serait peut-être pas mal, non ?
...
Levans: une slice, c'est une référence vers un morceau d'un array (une tranche, pour traduire littéralement)
Levans: en gros, c'est un pointeur intelligent vers un premier élément associé à une taille

Genre avec map/collect/zip.

Bonjour,

Merci tout d'abord pour cette excellente documentation, elle est limpide ! 😄

L'objet de cet issue est à propos d'une erreur de typo amenant à une erreur de compilation dans le Chapitre 1, Module 9 (Expressions) :

let var: i32 = if true {
    1u32;
} else {
    2u32;
};

Après avoir run, on voit que le compilateur bug sur le cast d'u32 vers i32

Ce serait bien de proposer la correction :

let var: u32 = if true {
    1u32
} else {
    2u32
};

This is some code written in the blog :

trait Animal {
    fn get_nom(&self) -> String {
        self.nom
    }

    fn get_nombre_de_pattes(&self) -> usize {
        self.nombre_de_pattes
    }
}

struct Chien {
    nom: String,
    nombre_de_pattes: usize
}

struct Chat {
    nom: String,
    nombre_de_pattes: usize
}

struct Oiseau {
    nom: String,
    nombre_de_pattes: usize
}

struct Araignee {
    nom: String,
    nombre_de_pattes: usize
}

impl Animal for Chien {}
impl Animal for Chat {}
impl Animal for Oiseau {}
impl Animal for Araignee {}

fn affiche_animal<T: Animal>(animal: T) {
    println!("Cet animal s'appelle {} et il a {} patte(s)", animal.get_nom(),
        animal.get_nombre_de_pattes());
}

let chat = Chat { nom : "Félix", nombre_de_pattes: 4};
let spider = Araignee { nom : "Yuuuurk", nombre_de_pattes: 8};

affiche_animal(chat);
affiche_animal(spider);

Unfortunately, this code doesn't works because the compiler doesn't know, for the trait Animal with function get_nom, if the self 'object' has a field named 'nom'...

Bonjour Guillaume,

Souhaites-tu ajouter ce petit script à ton repository ?

Merci pour ton tutorial.

#!/bin/bash
(
echo "---"
echo "title: Tutoriel Rust"
echo "author: Guillaume GOMEZ"
echo "lang: fr-FR"
echo "date: `date +%Y`"
echo "cover-image: rust-logo.png"
echo "abstract: |"
echo "  "`tail -n +5 README.md`
echo "---"
echo

echo "# Les bases de la programmation en Rust"
find src/1*md -type f -name '*.md' | \
    sort -t _ -k 1.3 -k 2.2 -k 2.1 -n | \
    while read l ; do \
        tail -n +2 ${l} ; \
    done

echo
echo "# Spécificités de Rust"
find src/2*md -type f -name '*.md' | \
    sort -t _ -k 1.3 -k 2.2 -k 2.1 -n | \
    while read l ; do \
        tail -n +2 ${l} ; \
    done

echo
echo "# Aller plus loin"
find src/3*md -type f -name '*.md' | \
    sort -t _ -k 1.3 -k 2.2 -k 2.1 -n | \
    while read l ; do \
        tail -n +2 ${l} ; \
    done

) | pandoc -f markdown -t epub2 -o tuto-rust.epub

Bonjour,
La syntaxe présentée ci-dessous est déjà présente dans l'exemple intitulé "exemple d'utilisation" un peu au dessus.
"Par défaut, tout est expression en Rust, le point-virgule permettant simplement de marquer la fin de l'expression courante. Dans le cas présent, on pourrait tout aussi bien écrire :

fn addition(nb1: i32, nb2: i32) ->  i32 {
    return nb1 + nb2;
}

"
Je pense que ce serait mieux de d'abord présenter la syntaxe sans return puis de dire que l'on peut quand même l'utiliser comme dans d'autres langage.

Hello, nice tutorial, bravo

let age : i32 = 17;
match age {
    tmp if tmp > 17 {
        println!("majeur !");
    }
    _ => {
        println!("mineur !");
    }
};

missing "=>" after 17

  match age {
    tmp if tmp > 17 => { println!("majeur !") }
                  _ => { println!("mineur !") }
  };  // semicolon for EOstt-block "match"

so I prefer this kind of layout, looks clearer to me, enlighten semicolon use,..

fn main() {
  let my_string = "hello";
  match my_string {                       // this layout is clearer
    "bonjour" => { println!("francais") } // NO EOstt semicolon before }
    "ciao" =>    { println!("italien")  } // NO EOstt semicolon before }
    "hello" =>   { println!("anglais")  } // NO EOstt semicolon before }
    "hola" =>    { println!("espagnol") } // NO EOstt semicolon before }
    _ =>         { println!("unknown language") } // NO EOstt semicolon before }
    // _ means "any other expression", kind of "else", not for next boolean
  };  // semicolon for EOstt-block "match"
}

Perhaps could you signal this nice rustc option (Compiler)

rustc hello.rs
from the Windows cmd shell
outputs hello.exe 2.5Mega but 50K using the -C prefer-dynamic option

   rustc hello.rs                    REM outputs hello.exe to launch
   hello                             REM launch, it displays: Hello World!
   rustc hello.rs -o hi              REM -output it as hi.exe  
   rustc -C prefer-dynamic hello.rs  REM reduce the output size dramatically !
   REM this dynamic option requires the availability at runtime of the Rust libraries.
   REM the PATH to Rust is updated if you choosed the option when installing it

perhaps a button to COPY or SEND code to https://play.rust-lang.org

To do these exercises in https://github.com/carols10cents/rustlings
Thanks to btbytes' prlinks, you can now click on the links below to load the exercises in the rust playground!

Have a nice day

Francis, Brussel

Dans la section "Mise en place des outils", il serait sans doute judicieux de parler de http://www.tutorialspoint.com/compile_rust_online.php

Plusieurs avantages par rapport à https://play.rust-lang.org/ :

• édition sur plusieurs fichiers (+ download/upload d'un projet complet)
• un shell sh de dispo

Pour unsafe, j'en parle très vaguement dans le chapitre Utiliser du code compilé en C avec les FFI, mais un chapitre avant celui-ci pour expliquer exactement ce qui change avec unsafe (déréférencer des pointeurs et appeler des fonctions unsafe en gros) et surtout bien rappeler que les règles du borrow-checker sont les mêmes dans ces blocks serait le bienvenu.

Par exemple :

struct Color {
    r: u8,
    g: u8,
    b: u8,
    alpha: u8,
}

union ColorUnion {
    color: Color,
    value: u32,
}

sSend.diff.txt

Bonjour,
Dans l'exemple des boucles for, changer l'exemple par :
for (i, j) in (6..10).enumerate() {
println!("i = {} et j = {}", i, j);
}
Pour que personne ne pense que les j suivent les i.

Dans le chapitre sur les structures (II.2 https://blog.guillaume-gomez.fr/Rust/2/2), les structures sont listées selon un certain ordre, puis le premier exemple (déclarations) les présente dans un ordre différent, et le second exemple (instanciations) les présente dans un ordre encore différent.

Je trouve que cela rends la lecture moins compréhensible au premier regard que si l'ordre était toujours le même.

Bonjour,
Sachant l'importance que donne rust aux références vs valeurs, pour moi qui suis débutant en rust, j'aurais aimé avoir minimalement un éclaicissement à propos de * et &.
Par exemple, dans le code concernant les slices

// tab est une slice contenant 0, 1 et 2
let tab = &[0, 1, 2];
// ça affichera "[0, 1, 2]"
println!("{:?}", tab);
// s est maintenant une slice commençant à partir du 2e élément de tab
let s = &tab[1..];
// ça affichera "[1, 2]"
println!("{:?}", s);

Cela fonctionne encore avec let tab = [0, 1, 2]; mais ne fonctionne plus avec let s = tab[1..];
Pourquoi est-ce le cas ? Comment fonctionne le langage concernant les références?

Penser à préciser l'usage de Some() afin d'avoir une lecture fluide.

Issue liée à #48

Pour l'introduction, je pense qu'il serait suffisant d'aborder le concept de ressource présente/non-présente contrairement à d'autres langages où la notion de pointeur nul est acceptée, puis finir par la déstructuration des variantes (ce qui complèterait le chapitre lié au pattern matching).

Par contre si la section est placée avant le chapitre abordant if/while let, il va falloir réorganiser les autres sections (changer leur place/numéro).

J'ai remarqué que le dossier src contient des documents mais elles ne sont pas en ordre. Par exemple: 1, 10, 12 ... 19, 2, 20 ...

Il serait mieux de renommer les filières 00, 01, 02 ... 09, 10 ...