[rust/fr] - French translation for Rust tutorial (#2297)

* Initial pass at a fr translation of Rust tutorial

* Clean up formatting

* Add GFM rust modifer to code black

* Final pre-PR fixes

* Edit YAML front-matter

* Grammar and typo fixes

1 files changed, 319 insertions, 0 deletions

diff --git a/fr-fr/rust-fr.html.markdown b/fr-fr/rust-fr.html.markdown
new file mode 100644
index 00000000..0fa16075
--- /dev/null
+++ b/fr-fr/rust-fr.html.markdown
@@ -0,0 +1,319 @@
+---
+language: rust
+contributors:
+    - ["P1start", "http://p1start.github.io/"]
+translators:
+    - ["Ryan Rembert", "http://jrrembert.github.io"]
+filename: learnrust-fr.rs
+lang: fr-fr
+---
+
+Rust est un langage de programmation développé par Mozilla Research. Rust combine le contrôle de bas niveau sur la performance avec la commodité et la sécurité garanties de haut niveau.
+
+Il atteint ces objectifs sans avoir besoin d'un ramasse-miettes ou environnement d'exécution, ce qui rend possible l'utilisation de bibliothèques Rust comme une substitution directe pour C.
+
+La première version de Rust, 0.1, est sortie en janvier 2012 et a tellement évolué rapidement que jusqu'à récemment, l'utilisation de versions stables était déconseillée - à la place ce était conseillé d'utiliser les nightly builds.
+
+Le 15 mai 2015, Rust 1.0 a été libéré avec une garantie complète de compatibilité ascendante. Améliorations aux temps de compilation et d'autres aspects du compilateur sont actuellement disponibles dans la nightly builds. Rust a adopté un modèle de libération à bord du train avec les versions régulières toutes les six semaines. Rust 1.1 beta a été mis à la disposition dans le même temps de la libération de Rust 1.0.
+
+Bien que Rust soit un langage relativement bas niveau, Rust a quelques concepts fonctionnels qui se trouvent généralement dans les langues de niveau supérieur. Cela rend Rust non seulement rapide, mais aussi efficace et facile à coder.
+
+```rust
+// Ceci est un commentaire. commentaires de ligne ressemblent à ceci ...
+// Et prolonger plusieurs lignes comme celle-ci.
+
+/// Les commentaires de documentation ressemblent à ceci et à soutenir
+/// la notation de démarques.
+/// # Exemples
+///
+/// ```
+/// let cinq = 5
+/// ```
+
+///////////////
+// 1. Basics //
+///////////////
+
+// Les fonctions
+// `I32` est le type 32 bits entiers signés
+fn add2(x: i32, y: i32) -> i32 {
+    // Retour implicite (pas virgule)
+    x + y
+}
+
+// Fonction principale
+fn main() {
+    // Nombres //
+
+    // Reliures immutable
+    let x: i32 = 1;
+
+    // Entier suffixes/float
+    let y: I32 = 13i32;
+    let f: f64 = 1.3f64;
+
+    // Type Inférence
+    // La plupart du temps, le compilateur Rust peut déduire le type de variable
+    // est, donc vous ne devez pas écrire une annotation de type explicite.
+    // Tout au long de ce tutoriel, les types sont explicitement annotées dans
+    // de nombreux endroits, mais seulement à des fins de démonstration.
+    // L'inférence de type peut gérer cela pour vous la plupart du temps.
+    let implicit_x = 1;
+    let implicit_f = 1,3;
+
+    // Arithmétique
+    let somme = x + y + 13;
+
+    // Variable Mutable
+    let mut mutable = 1;
+    let mutable = 4;
+    let mutable += 2;
+
+    // Chaînes //
+
+    // Littéraux chaîne
+    let x: &str = "Bonjour tout le monde!";
+
+    // Impression
+    println!("{} {}", f, x); // 1.3 Bonjour tout le monde
+
+    // A `Chaîne` - une chaîne de tas alloué
+    let s: String = "Bonjour tout le monde".to_string();
+
+    // Une tranche de chaîne - une vue immutable dans une else chaîne.
+    // Ceci est essentiellement un pointeur immutable à une chaîne - il n'a pas
+    // contient effectivement le contenu d'une chaîne, juste un pointeur vers
+    // quelque chose qui fait(dans ce cas, `s`).
+    let s_slice: &str = &s;
+
+    println!("{} {}", s, s_slice); // Bonjour monde Bonjour tout le monde
+
+    // Vecteurs/tableau //
+
+    // Un tableau de taille fixe
+    let four_ints: [i32; 4] = [1, 2, 3, 4];
+
+    // Un tableau dynamique(vecteur)
+    let mut vecteur: Vec<i32> = vec![1, 2, 3, 4];
+    vecteur.push(5);
+
+    // Une tranche - une vue immutable dans un vecteur ou un tableau.
+    // Ceci est un peu comme une tranche de chaîne, mais pour les vecteurs.
+    let tranche: &[i32] = &vecteur;
+
+    // Utiliser `{:?}` pour imprimer quelque chose de débogage de style
+    println!("{:?} {:?}", vecteur, tranche); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
+
+    // Tuples //
+
+    // Un tuple est un ensemble de valeurs de peut-être différents types.
+    // de taille fixe
+    let x:(i32, &str, f64) = (1, "bonjour", 3.4);
+
+    // Déstructurante `let`
+    let (a, b, c) = x;
+    println!("{} {} {}", a, b, c); // 1 bonjour 3.4
+
+    // indexation
+    println!("{}", x.1); // Bonjour
+
+    //////////////
+    // 2. Types //
+    //////////////
+
+    // Struct
+    struct Point {
+        x: i32,
+        y: i32,
+    }
+
+    let origine: Point = Point { x: 0, y: 0 };
+
+    // Un struct avec des champs sans nom, appelé 'tuple struct'.
+    struct Point2(i32, i32);
+
+    let origine2 = Point2(0, 0);
+
+    // Basic C-like enum
+    enum Direction {
+        Àgauche,
+        Droite,
+        En_Haut,
+        Vers_Le_Bas,
+    }
+
+    let en_haut = Direction::En_Haut;
+
+    // Enum avec des champs
+    enum OptionnelI32 {
+        AnI32(I32),
+        Rien,
+    }
+
+    let deux: OptionnelI32 = OptionnelI32::AnI32(2);
+    let rien = OptionnelI32::Rien;
+
+    // Generics //
+
+    struct Foo<T> { bar: T }
+
+    // Ceci est défini dans la bibliothèque standard comme `Option`.
+    enum Optionnel<T> {
+        SomeVal(T),
+        NoVal,
+    }
+
+    // Méthodes //
+
+    impl<T> Foo<T> {
+        // Méthodes prennent un paramètre explicite `de self`.
+        fn get_bar(self) -> T {
+            self.bar
+        }
+    }
+
+    let a_foo = Foo { bar: 1 };
+    println!("{}", a_foo.get_bar()); // 1
+
+    // Traits (connu sous le nom des interfaces ou des classes de types dans
+    // d'elses langues).
+
+    trait Frobnicate<T> {
+        fn frobnicate(self) -> Option<T>;
+    }
+
+    impl<T> Frobnicate<T> for Foo<T> {
+        fn frobnicate(self) -> Option<T> {
+            Some(self.bar)
+        }
+    }
+
+    let another_foo = Foo { bar: 1 };
+    println!("{:?}", another_foo.frobnicate()); // Some(1)
+
+    /////////////////////////
+    // 3. Motif correspondant //
+    /////////////////////////
+
+    let foo = OptionnelI32::AnI32(1);
+    match foo {
+        OptionnelI32::AnI32(n) => println!("Il est un i32: {}", n),
+        OptionnelI32::Rien     => println!("Il n'y a rien!"),
+    }
+
+    // Motif avancé correspondant
+    struct FooBar { x: i32, y: OptionnelI32 }
+    let bar = FooBar { x: 15, y: OptionnelI32::AnI32(32) };
+
+    match bar {
+        FooBar { x: 0, y: OptionnelI32 :: AnI32(0)} =>
+            println!("Les chiffres sont nuls!"),
+        FooBar { x: n, y: OptionnelI32 :: AnI32(m)} if n == m =>
+            println!("Les chiffres sont les mêmes"),
+        FooBar { x: n, y: OptionnelI32 :: AnI32(m)} =>
+            println!("Différents numéros: {} {}", n, m)!,
+        FooBar { x: _, y: OptionnelI32 :: Rien} =>
+            println!("Le deuxième numéro est rien!"),
+    }
+
+    /////////////////////
+    // 4. Flux de contrôle //
+    /////////////////////
+
+    // `for` boucles / itération
+    let array = [1, 2, 3];
+    for i in array.iter() {
+        println!("{}", i);
+    }
+
+    // Ranges
+    for i in 0u32..10 {
+        print!("{}", i);
+    }
+    println!("");
+    // imprime `0 1 2 3 4 5 6 7 8 9`
+
+    // `if`
+    if 1 == 1 {
+        println!("Maths est travaille!");
+    } else {
+        println!("Oh non ...!");
+    }
+
+    // `if` comme expression
+    let valeur = if true {
+        "bien"
+    } else {
+        "mal"
+    };
+
+    // `while` boucle
+    while 1 == 1 {
+        println!("L'univers fonctionne normalement.");
+    }
+
+    // Boucle infinie
+    loop {
+        println!("Bonjour!");
+    }
+
+    /////////////////////////////////
+    // 5. Sécurité & pointeurs mémoire //
+    /////////////////////////////////
+
+    // Pointeur occasion - une seule chose peut "posséder" pointeur à un moment.
+    // Cela signifie que lorsque le `Box` laisse son champ d'application, il
+    // peut être automatiquement libérée en toute sécurité.
+    let mut mien: Box<i32> = Box::new(3);
+    *mien = 5; // déréférencer
+    // Ici, `now_its_mine` prend possession de` mine`. En d'elses termes,
+    // `mien` est déplacé.
+    let mut now_its_mine = mien;
+    *now_its_mine += 2;
+
+    println!("{}", now_its_mine); // 7
+    // println!("{}", de la mine); // Cela ne compile pas parce
+    // que `now_its_mine` possède maintenant le pointeur
+
+    // Référence - un pointeur immutable qui fait référence à d'elses données.
+    // Quand une référence est prise à une valeur, nous disons que la valeur
+    // a été "emprunté".
+    // Même si une valeur est emprunté immutablement, il ne peut pas être
+    // muté ou déplacé.
+    // Un emprunt dure jusqu'à la fin de la portée, il a été créé.
+    let mut var = 4;
+    var = 3;
+    let ref_var: &i32 = &var;
+
+    println!("{}", var); // Contrairement `box`, `var` peut encore être utilisé
+    println!("{}", *ref_var);
+    // Var = 5; // Cela ne compile pas parce que `var` est emprunté.
+    // *ref_var = 6; // Ce ne serait pas non plus, parce que `ref_var` est une
+    // référence immutable.
+
+    // Référence Mutable
+    // Même si une valeur est mutably emprunté, il ne peut pas être
+    // accessible à tous.
+    let mut var2 = 4;
+    let ref_var2: &mut i32 = &mut var2;
+    // '*' est utilisé pour pointer vers le var2 mutably emprunté.
+    *ref_var2 += 2;
+
+    println!("{}", * ref_var2); // 6, // var2 ne serait pas compiler.
+    // ref_var2 est de type &mut i32 donc stocke il référence à i32,
+    // pas la valeur.
+    // var2 = 2; // Cela ne compile pas parce que `var2` est emprunté.
+}
+```
+
+## Autres lectures
+
+Il y a beaucoup plus à Rust -- ce est juste l'essentiel de Rust afin que vous puissiez comprendre
+les choses les plus importantes. Pour en savoir plus sur Rust, lire [La Programmation Rust
+Langue](http://doc.rust-lang.org/book/index.html) et etudier la
+[/r/rust](http://reddit.com/r/rust) subreddit. Les gens sur le canal de #rust sur
+irc.mozilla.org sont aussi toujours prêts à aider les nouveaux arrivants.
+
+Vous pouvez également essayer caractéristiques de Rust avec un compilateur en ligne sur le fonctionnaire
+[Rust parc](http://play.rust-lang.org) ou sur la principale
+[Site Rust](http://rust-lang.org).