From 5bff1e956ef8003eddfcb64ffdc1161ee3d622bc Mon Sep 17 00:00:00 2001
From: Alois <aloisdegouvello@live.fr>
Date: Thu, 30 Apr 2015 16:49:49 +0200
Subject: Create typescript-fr.html.markdown

Translate the reading block, the introduction part and the type part.
---
 fr-fr/typescript-fr.html.markdown | 171 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 171 insertions(+)
 create mode 100644 fr-fr/typescript-fr.html.markdown

(limited to 'fr-fr')

diff --git a/fr-fr/typescript-fr.html.markdown b/fr-fr/typescript-fr.html.markdown
new file mode 100644
index 00000000..e87bacac
--- /dev/null
+++ b/fr-fr/typescript-fr.html.markdown
@@ -0,0 +1,171 @@
+---
+language: TypeScript
+contributors:
+    - ["Philippe Vlérick", "https://github.com/pvlerick"]
+translators:
+    - ["Alois de Gouvello", "https://github.com/aloisdg"]
+filename: learntypescript-fr.ts
+lang: fr-fr
+---
+
+TypeScript est un langage visant à faciliter le developpement d'applications large  et scalable écrite en JavaScript.
+TypeScript ajoute des concepts classiques comme les classes, les modules, les interfaces, les génériques et le typage statique (optionel) à JavaScript.
+C'est une surcouche à JavaScript: tout le code JavaScript est valide en TypeScript ce qui permet de l'ajouter de façon transparente à n'importe quel projet. Le compilateur TypeScript émet du JavaScript. 
+
+Cet article se concentrera seulement sur la syntaxe supplémentaire de TypeScript, plutôt que celle de [JavaScript] (../javascript/).
+
+Pour tester le compilateur de TypeScript, rendez-vous au [Playground] (http://www.typescriptlang.org/Playground) où vous pourrez coder, profiter d'une autocomplétion et voir directement le rendu JavaScript.
+
+```js
+// Il y a 3 types basiques en in TypeScript
+var isDone: boolean = false;
+var lines: number = 42;
+var name: string = "Anders";
+
+// Quand c'est impossible de savoir, il ya le type `Any`
+var notSure: any = 4;
+notSure = "maybe a string instead";
+notSure = false; // ok, définitvement un booléen
+
+// Pour les collections, il y a les tableaux typés et les tableaux génériques
+var list: number[] = [1, 2, 3]; // Un tableaux typé
+var list: Array<number> = [1, 2, 3]; // un tableau générique
+
+// Pour les énumeration
+enum Color {Red, Green, Blue};
+var c: Color = Color.Green;
+
+// Enfin, `void` est utilisé dans le cas spécifique d'une fonction ne retournant rien
+function bigHorribleAlert(): void {
+  alert("I'm a little annoying box!");
+}
+
+// Functions are first class citizens, support the lambda "fat arrow" syntax and
+// use type inference
+
+// The following are equivalent, the same signature will be infered by the
+// compiler, and same JavaScript will be emitted
+var f1 = function(i: number): number { return i * i; }
+// Return type inferred
+var f2 = function(i: number) { return i * i; }
+var f3 = (i: number): number => { return i * i; }
+// Return type inferred
+var f4 = (i: number) => { return i * i; }
+// Return type inferred, one-liner means no return keyword needed
+var f5 = (i: number) =>  i * i;
+
+// Interfaces are structural, anything that has the properties is compliant with
+// the interface
+interface Person {
+  name: string;
+  // Optional properties, marked with a "?"
+  age?: number;
+  // And of course functions
+  move(): void;
+}
+
+// Object that implements the "Person" interface
+// Can be treated as a Person since it has the name and move properties
+var p: Person = { name: "Bobby", move: () => {} };
+// Objects that have the optional property:
+var validPerson: Person = { name: "Bobby", age: 42, move: () => {} };
+// Is not a person because age is not a number
+var invalidPerson: Person = { name: "Bobby", age: true };
+
+// Interfaces can also describe a function type
+interface SearchFunc {
+  (source: string, subString: string): boolean;
+}
+// Only the parameters' types are important, names are not important.
+var mySearch: SearchFunc;
+mySearch = function(src: string, sub: string) {
+  return src.search(sub) != -1;
+}
+
+// Classes - members are public by default
+class Point {
+  // Properties
+    x: number;
+
+    // Constructor - the public/private keywords in this context will generate
+    // the boiler plate code for the property and the initialization in the
+    // constructor.
+    // In this example, "y" will be defined just like "x" is, but with less code
+    // Default values are also supported
+
+    constructor(x: number, public y: number = 0) {
+        this.x = x;
+    }
+
+    // Functions
+    dist() { return Math.sqrt(this.x * this.x + this.y * this.y); }
+
+    // Static members
+    static origin = new Point(0, 0);
+}
+
+var p1 = new Point(10 ,20);
+var p2 = new Point(25); //y will be 0
+
+// Inheritance
+class Point3D extends Point {
+    constructor(x: number, y: number, public z: number = 0) {
+        super(x, y); // Explicit call to the super class constructor is mandatory
+    }
+
+    // Overwrite
+    dist() {
+        var d = super.dist();
+        return Math.sqrt(d * d + this.z * this.z);
+    }
+}
+
+// Modules, "." can be used as separator for sub modules
+module Geometry {
+  export class Square {
+    constructor(public sideLength: number = 0) {
+    }
+    area() {
+      return Math.pow(this.sideLength, 2);
+    }
+  }
+}
+
+var s1 = new Geometry.Square(5);
+
+// Local alias for referencing a module
+import G = Geometry;
+
+var s2 = new G.Square(10);
+
+// Generics
+// Classes
+class Tuple<T1, T2> {
+    constructor(public item1: T1, public item2: T2) {
+    }
+}
+
+// Interfaces
+interface Pair<T> {
+    item1: T;
+    item2: T;
+}
+
+// And functions
+var pairToTuple = function<T>(p: Pair<T>) {
+    return new Tuple(p.item1, p.item2);
+};
+
+var tuple = pairToTuple({ item1:"hello", item2:"world"});
+
+// Including references to a definition file:
+/// <reference path="jquery.d.ts" />
+
+```
+
+## Lectures complémentaires
+ * [Site officiel de TypeScript] (http://www.typescriptlang.org/)
+ * [Spécification du langage TypeScript (pdf)] (http://go.microsoft.com/fwlink/?LinkId=267238)
+ * [Anders Hejlsberg - Introducing TypeScript on Channel 9] (http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript)
+ * [Code source sur GitHub] (https://github.com/Microsoft/TypeScript)
+ * [Definitely Typed - repository for type definitions] (http://definitelytyped.org/)
-- 
cgit v1.2.3


From 6f96532a59012aa1041aaf671c160396a7819167 Mon Sep 17 00:00:00 2001
From: Alois <aloisdegouvello@live.fr>
Date: Thu, 30 Apr 2015 17:12:54 +0200
Subject: Update typescript-fr.html.markdown

Translate functions block
---
 fr-fr/typescript-fr.html.markdown | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/typescript-fr.html.markdown b/fr-fr/typescript-fr.html.markdown
index e87bacac..718a5e9a 100644
--- a/fr-fr/typescript-fr.html.markdown
+++ b/fr-fr/typescript-fr.html.markdown
@@ -10,19 +10,19 @@ lang: fr-fr
 
 TypeScript est un langage visant à faciliter le developpement d'applications large  et scalable écrite en JavaScript.
 TypeScript ajoute des concepts classiques comme les classes, les modules, les interfaces, les génériques et le typage statique (optionel) à JavaScript.
-C'est une surcouche à JavaScript: tout le code JavaScript est valide en TypeScript ce qui permet de l'ajouter de façon transparente à n'importe quel projet. Le compilateur TypeScript émet du JavaScript. 
+C'est une surcouche de JavaScript : tout le code JavaScript est valide en TypeScript ce qui permet de l'ajouter de façon transparente à n'importe quel projet. Le code TypeScript est transcompilé en JavaScript par le compilateur. 
 
 Cet article se concentrera seulement sur la syntaxe supplémentaire de TypeScript, plutôt que celle de [JavaScript] (../javascript/).
 
 Pour tester le compilateur de TypeScript, rendez-vous au [Playground] (http://www.typescriptlang.org/Playground) où vous pourrez coder, profiter d'une autocomplétion et voir directement le rendu JavaScript.
 
 ```js
-// Il y a 3 types basiques en in TypeScript
+// Il y a 3 types basiques en TypeScript
 var isDone: boolean = false;
 var lines: number = 42;
 var name: string = "Anders";
 
-// Quand c'est impossible de savoir, il ya le type `Any`
+// Quand c'est impossible à déterminer, on utilise le type `Any`
 var notSure: any = 4;
 notSure = "maybe a string instead";
 notSure = false; // ok, définitvement un booléen
@@ -40,18 +40,18 @@ function bigHorribleAlert(): void {
   alert("I'm a little annoying box!");
 }
 
-// Functions are first class citizens, support the lambda "fat arrow" syntax and
-// use type inference
+// Les fontions sont des entités de première classe. Elles supportent les expressions lambda et
+// utilisent l'inférence de types
 
-// The following are equivalent, the same signature will be infered by the
-// compiler, and same JavaScript will be emitted
+// Les fonctions ci-dessous sont équivalentes, une signature identique sera inférée par le compilateur,
+// et le même JavaScript sera généré
 var f1 = function(i: number): number { return i * i; }
-// Return type inferred
+// Retourne un type inféré
 var f2 = function(i: number) { return i * i; }
 var f3 = (i: number): number => { return i * i; }
-// Return type inferred
+// Retourne un type inféré
 var f4 = (i: number) => { return i * i; }
-// Return type inferred, one-liner means no return keyword needed
+// Retourne un type inféré, ici le mot clé `return` n'est pas nécessaire
 var f5 = (i: number) =>  i * i;
 
 // Interfaces are structural, anything that has the properties is compliant with
-- 
cgit v1.2.3


From 0964b9e1edff08d0d4bc570a9fad135e2da45d62 Mon Sep 17 00:00:00 2001
From: Alois <aloisdegouvello@live.fr>
Date: Thu, 30 Apr 2015 18:42:13 +0200
Subject: Update typescript-fr.html.markdown

Add classe block
---
 fr-fr/typescript-fr.html.markdown | 59 +++++++++++++++++++--------------------
 1 file changed, 28 insertions(+), 31 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/typescript-fr.html.markdown b/fr-fr/typescript-fr.html.markdown
index 718a5e9a..9e6ee171 100644
--- a/fr-fr/typescript-fr.html.markdown
+++ b/fr-fr/typescript-fr.html.markdown
@@ -32,7 +32,7 @@ var list: number[] = [1, 2, 3]; // Un tableaux typé
 var list: Array<number> = [1, 2, 3]; // un tableau générique
 
 // Pour les énumeration
-enum Color {Red, Green, Blue};
+enum Color { Red, Green, Blue };
 var c: Color = Color.Green;
 
 // Enfin, `void` est utilisé dans le cas spécifique d'une fonction ne retournant rien
@@ -54,73 +54,70 @@ var f4 = (i: number) => { return i * i; }
 // Retourne un type inféré, ici le mot clé `return` n'est pas nécessaire
 var f5 = (i: number) =>  i * i;
 
-// Interfaces are structural, anything that has the properties is compliant with
-// the interface
+// Les interfaces sont structurés, tout ce qui a les propriétés est compatible avec
+// l'interface
 interface Person {
   name: string;
-  // Optional properties, marked with a "?"
+  // Les propriétés optionnelles sont identifiées avec un "?"
   age?: number;
-  // And of course functions
+  // Et bien sûr, les fonctions
   move(): void;
 }
 
-// Object that implements the "Person" interface
-// Can be treated as a Person since it has the name and move properties
+// Un objet implémentant l'interface "Person" peut être traité comme 
+// une Person car il a les propriétés "name" et "move"
 var p: Person = { name: "Bobby", move: () => {} };
-// Objects that have the optional property:
-var validPerson: Person = { name: "Bobby", age: 42, move: () => {} };
-// Is not a person because age is not a number
-var invalidPerson: Person = { name: "Bobby", age: true };
+// Des objets implémentants la propriété optionnelle :
+var validPerson: Person = { name: "Bobby", age: 42, move: () => {} }; // valide car "age" est un nombre
+var invalidPerson: Person = { name: "Bobby", age: true }; // invalide car "age" n'est pas un nombre
 
-// Interfaces can also describe a function type
+// Les interfaces peuvent aussi décrire un type de fonction
 interface SearchFunc {
   (source: string, subString: string): boolean;
 }
-// Only the parameters' types are important, names are not important.
+// Seul les types des paramètres sont importants, les noms ne le sont pas
 var mySearch: SearchFunc;
 mySearch = function(src: string, sub: string) {
   return src.search(sub) != -1;
 }
 
-// Classes - members are public by default
+// Les membres des classes sont publiques par défaut
 class Point {
-  // Properties
+  // Propriétés
     x: number;
 
-    // Constructor - the public/private keywords in this context will generate
-    // the boiler plate code for the property and the initialization in the
-    // constructor.
-    // In this example, "y" will be defined just like "x" is, but with less code
-    // Default values are also supported
-
+    // Constructeur - Les mots clés "public" et "private" dans ce contexte génèrent
+    // le code de la propriété et son initialisation dans le constructeur.
+    // Dans cet exemple, "y" sera défini de la même façon que "x", mais avec moins de code
+    // Les valeurs par défaut sont supportées
     constructor(x: number, public y: number = 0) {
         this.x = x;
     }
 
-    // Functions
+    // Fonctions
     dist() { return Math.sqrt(this.x * this.x + this.y * this.y); }
 
-    // Static members
+    // Membres statiques
     static origin = new Point(0, 0);
 }
 
 var p1 = new Point(10 ,20);
 var p2 = new Point(25); //y will be 0
 
-// Inheritance
+// Héritage
 class Point3D extends Point {
     constructor(x: number, y: number, public z: number = 0) {
-        super(x, y); // Explicit call to the super class constructor is mandatory
+        super(x, y); // Un appel explicite au constructeur de la super classe est obligatoire.
     }
 
-    // Overwrite
+    // Redéfinition
     dist() {
         var d = super.dist();
         return Math.sqrt(d * d + this.z * this.z);
     }
 }
 
-// Modules, "." can be used as separator for sub modules
+// Modules, "." peut être utilisé comme un séparateur de sous modules.
 module Geometry {
   export class Square {
     constructor(public sideLength: number = 0) {
@@ -133,12 +130,12 @@ module Geometry {
 
 var s1 = new Geometry.Square(5);
 
-// Local alias for referencing a module
+// Alias local pour référencer un module
 import G = Geometry;
 
 var s2 = new G.Square(10);
 
-// Generics
+// Génériques
 // Classes
 class Tuple<T1, T2> {
     constructor(public item1: T1, public item2: T2) {
@@ -151,14 +148,14 @@ interface Pair<T> {
     item2: T;
 }
 
-// And functions
+// Et fonctions
 var pairToTuple = function<T>(p: Pair<T>) {
     return new Tuple(p.item1, p.item2);
 };
 
 var tuple = pairToTuple({ item1:"hello", item2:"world"});
 
-// Including references to a definition file:
+// Inclure des références à un fichier :
 /// <reference path="jquery.d.ts" />
 
 ```
-- 
cgit v1.2.3


From f5fec6341b9a7ed280a5dbfd86d9cc5ee4fa82cf Mon Sep 17 00:00:00 2001
From: Alois <aloisdegouvello@live.fr>
Date: Thu, 30 Apr 2015 18:47:21 +0200
Subject: Update typescript-fr.html.markdown

Fix translation
---
 fr-fr/typescript-fr.html.markdown | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/typescript-fr.html.markdown b/fr-fr/typescript-fr.html.markdown
index 9e6ee171..14caec7c 100644
--- a/fr-fr/typescript-fr.html.markdown
+++ b/fr-fr/typescript-fr.html.markdown
@@ -8,13 +8,13 @@ filename: learntypescript-fr.ts
 lang: fr-fr
 ---
 
-TypeScript est un langage visant à faciliter le developpement d'applications large  et scalable écrite en JavaScript.
-TypeScript ajoute des concepts classiques comme les classes, les modules, les interfaces, les génériques et le typage statique (optionel) à JavaScript.
-C'est une surcouche de JavaScript : tout le code JavaScript est valide en TypeScript ce qui permet de l'ajouter de façon transparente à n'importe quel projet. Le code TypeScript est transcompilé en JavaScript par le compilateur. 
+TypeScript est un langage visant à faciliter le développement d'applications large et scalable écrite en JavaScript.
+TypeScript ajoute des concepts classiques comme les classes, les modules, les interfaces, les génériques et le typage statique (optionnel) à JavaScript.
+C'est une sur-couche de JavaScript : tout le code JavaScript est valide en TypeScript ce qui permet de l'ajouter de façon transparente à n'importe quel projet. Le code TypeScript est transcompilé en JavaScript par le compilateur
 
 Cet article se concentrera seulement sur la syntaxe supplémentaire de TypeScript, plutôt que celle de [JavaScript] (../javascript/).
 
-Pour tester le compilateur de TypeScript, rendez-vous au [Playground] (http://www.typescriptlang.org/Playground) où vous pourrez coder, profiter d'une autocomplétion et voir directement le rendu JavaScript.
+Pour tester le compilateur de TypeScript, rendez-vous au [Playground] (http://www.typescriptlang.org/Playground) où vous pourrez coder, profiter d'une autocomplétion et accéder directement au rendu JavaScript.
 
 ```js
 // Il y a 3 types basiques en TypeScript
-- 
cgit v1.2.3


From abd5437b6d94a4635df8ade836ecde2206aa9625 Mon Sep 17 00:00:00 2001
From: Alois <aloisdegouvello@live.fr>
Date: Thu, 30 Apr 2015 18:54:07 +0200
Subject: Update typescript-fr.html.markdown

Adjust to 80 columns
---
 fr-fr/typescript-fr.html.markdown | 39 ++++++++++++++++++++++-----------------
 1 file changed, 22 insertions(+), 17 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/typescript-fr.html.markdown b/fr-fr/typescript-fr.html.markdown
index 14caec7c..63ed4c34 100644
--- a/fr-fr/typescript-fr.html.markdown
+++ b/fr-fr/typescript-fr.html.markdown
@@ -25,7 +25,7 @@ var name: string = "Anders";
 // Quand c'est impossible à déterminer, on utilise le type `Any`
 var notSure: any = 4;
 notSure = "maybe a string instead";
-notSure = false; // ok, définitvement un booléen
+notSure = false; // ok, définitivement un booléen
 
 // Pour les collections, il y a les tableaux typés et les tableaux génériques
 var list: number[] = [1, 2, 3]; // Un tableaux typé
@@ -35,16 +35,17 @@ var list: Array<number> = [1, 2, 3]; // un tableau générique
 enum Color { Red, Green, Blue };
 var c: Color = Color.Green;
 
-// Enfin, `void` est utilisé dans le cas spécifique d'une fonction ne retournant rien
+// Enfin, `void` est utilisé dans le cas spécifique
+// d'une fonction ne retournant rien
 function bigHorribleAlert(): void {
   alert("I'm a little annoying box!");
 }
 
-// Les fontions sont des entités de première classe. Elles supportent les expressions lambda et
-// utilisent l'inférence de types
+// Les fontions sont des entités de première classe. Elles supportent
+// les expressions lambda et utilisent l'inférence de types
 
-// Les fonctions ci-dessous sont équivalentes, une signature identique sera inférée par le compilateur,
-// et le même JavaScript sera généré
+// Les fonctions ci-dessous sont équivalentes, une signature identique
+// sera inférée par le compilateur, et le même JavaScript sera généré
 var f1 = function(i: number): number { return i * i; }
 // Retourne un type inféré
 var f2 = function(i: number) { return i * i; }
@@ -54,8 +55,8 @@ var f4 = (i: number) => { return i * i; }
 // Retourne un type inféré, ici le mot clé `return` n'est pas nécessaire
 var f5 = (i: number) =>  i * i;
 
-// Les interfaces sont structurés, tout ce qui a les propriétés est compatible avec
-// l'interface
+// Les interfaces sont structurés, tout ce qui a les propriétés est compatible
+// avec l'interface
 interface Person {
   name: string;
   // Les propriétés optionnelles sont identifiées avec un "?"
@@ -68,28 +69,30 @@ interface Person {
 // une Person car il a les propriétés "name" et "move"
 var p: Person = { name: "Bobby", move: () => {} };
 // Des objets implémentants la propriété optionnelle :
-var validPerson: Person = { name: "Bobby", age: 42, move: () => {} }; // valide car "age" est un nombre
-var invalidPerson: Person = { name: "Bobby", age: true }; // invalide car "age" n'est pas un nombre
+// valide car "age" est un nombre
+var validPerson: Person = { name: "Bobby", age: 42, move: () => {} };
+// invalide car "age" n'est pas un nombre
+var invalidPerson: Person = { name: "Bobby", age: true };
 
 // Les interfaces peuvent aussi décrire un type de fonction
 interface SearchFunc {
   (source: string, subString: string): boolean;
 }
-// Seul les types des paramètres sont importants, les noms ne le sont pas
+// Seul les types des paramètres sont importants, les noms ne le sont pas.
 var mySearch: SearchFunc;
 mySearch = function(src: string, sub: string) {
   return src.search(sub) != -1;
 }
 
-// Les membres des classes sont publiques par défaut
+// Les membres des classes sont publiques par défaut.
 class Point {
   // Propriétés
     x: number;
 
-    // Constructeur - Les mots clés "public" et "private" dans ce contexte génèrent
-    // le code de la propriété et son initialisation dans le constructeur.
-    // Dans cet exemple, "y" sera défini de la même façon que "x", mais avec moins de code
-    // Les valeurs par défaut sont supportées
+    // Constructeur - Les mots clés "public" et "private" dans ce contexte
+    //  génèrent le code de la propriété et son initialisation dans le
+    // constructeur. Ici, "y" sera défini de la même façon que "x",
+    // mais avec moins de code. Les valeurs par défaut sont supportées.
     constructor(x: number, public y: number = 0) {
         this.x = x;
     }
@@ -107,7 +110,9 @@ var p2 = new Point(25); //y will be 0
 // Héritage
 class Point3D extends Point {
     constructor(x: number, y: number, public z: number = 0) {
-        super(x, y); // Un appel explicite au constructeur de la super classe est obligatoire.
+        // Un appel explicite au constructeur de la super classe
+        // est obligatoire.
+        super(x, y);
     }
 
     // Redéfinition
-- 
cgit v1.2.3


From 288fcf7c2e03610400088381fae528294daa9f54 Mon Sep 17 00:00:00 2001
From: Alois <aloisdegouvello@live.fr>
Date: Sun, 3 May 2015 18:37:52 +0200
Subject: Create json-fr.html.markdown

---
 fr-fr/json-fr.html.markdown | 62 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 fr-fr/json-fr.html.markdown

(limited to 'fr-fr')

diff --git a/fr-fr/json-fr.html.markdown b/fr-fr/json-fr.html.markdown
new file mode 100644
index 00000000..9664dd73
--- /dev/null
+++ b/fr-fr/json-fr.html.markdown
@@ -0,0 +1,62 @@
+---
+language: json
+filename: learnjson-fr.json
+contributors:
+  - ["Anna Harren", "https://github.com/iirelu"]
+  - ["Marco Scannadinari", "https://github.com/marcoms"]
+  translators:
+  - ["Alois de Gouvello","https://github.com/aloisdg"]
+  lang: fr-fr
+---
+
+Comme JSON est un format d'échange de données êxtremement simple, ce Apprendre X en Y minutes
+est susceptible d'être le plus simple jamais réalisé.
+
+JSON dans son état le plus pur n'a aucun commentaire, mais la majorité des parseurs accepterons
+les commentaires du langage C (//, /\* \*/). Pour les besoins de ce document, cependant,
+tout sera du JSON 100% valide. Heureusement, il s'explique par lui-même.
+
+
+```json
+{
+  "Clé": "valeur",
+  
+  "Clés": "devront toujours être entourées par des guillemets",
+  "nombres": 0,
+  "chaînes de caractères": "Hellø, wørld. Tous les caractères Unicode sont autorisés, accompagné d'un \"caractère d'échappement\".",
+  "a des booléens ?": true,
+  "rien": null,
+
+  "grand nombre": 1.2e+100,
+
+  "objets": {
+    "commentaire": "La majorité de votre strucutre sera des objets.",
+
+    "tableau": [0, 1, 2, 3, "Les tableaux peuvent contenir n'importe quoi.", 5],
+
+    "un autre objet": {
+      "commentaire": "Ces choses peuvent être imbriquées. C'est très utile."
+    }
+  },
+
+  "bêtises": [
+    {
+      "sources de potassium": ["bananes"]
+    },
+    [
+      [1, 0, 0, 0],
+      [0, 1, 0, 0],
+      [0, 0, 1, "neo"],
+      [0, 0, 0, 1]
+    ]
+  ],
+  
+  "style alternatif": {
+    "commentaire": "regarde ça !"
+  , "position de la virgule": "n'a pas d'importance - aussi longtemps qu'elle est avant la valeur, alors elle est valide."
+  , "un autre commentaire": "comme c'est gentil"
+  },
+
+  "C'était court": "Et, vous avez terminé. Maintenant, vous savez tout ce que JSON a à offrir."
+}
+```
-- 
cgit v1.2.3


From c09e8af49e05cfba07a95e6cc471a874fe703563 Mon Sep 17 00:00:00 2001
From: Alois <aloisdegouvello@live.fr>
Date: Sun, 3 May 2015 18:49:19 +0200
Subject: Update json-fr.html.markdown

Thank you @vendethiel for your comments
---
 fr-fr/json-fr.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/json-fr.html.markdown b/fr-fr/json-fr.html.markdown
index 9664dd73..dc46e043 100644
--- a/fr-fr/json-fr.html.markdown
+++ b/fr-fr/json-fr.html.markdown
@@ -9,11 +9,11 @@ contributors:
   lang: fr-fr
 ---
 
-Comme JSON est un format d'échange de données êxtremement simple, ce Apprendre X en Y minutes
+Comme JSON est un format d'échange de données extrêmement simple, ce Apprendre X en Y minutes
 est susceptible d'être le plus simple jamais réalisé.
 
 JSON dans son état le plus pur n'a aucun commentaire, mais la majorité des parseurs accepterons
-les commentaires du langage C (//, /\* \*/). Pour les besoins de ce document, cependant,
+les commentaires du langage C (`//`, `\* \*`). Pour les besoins de ce document, cependant,
 tout sera du JSON 100% valide. Heureusement, il s'explique par lui-même.
 
 
-- 
cgit v1.2.3


From c0bfad80f0b9590081bf9e6a3cd9eea933632a29 Mon Sep 17 00:00:00 2001
From: Alois <aloisdegouvello@live.fr>
Date: Sun, 3 May 2015 20:43:17 +0200
Subject: Update typescript-fr.html.markdown

Add modifications from @vendethiel's comments. See #1075
---
 fr-fr/typescript-fr.html.markdown | 23 ++++++++++++-----------
 1 file changed, 12 insertions(+), 11 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/typescript-fr.html.markdown b/fr-fr/typescript-fr.html.markdown
index 63ed4c34..b8807104 100644
--- a/fr-fr/typescript-fr.html.markdown
+++ b/fr-fr/typescript-fr.html.markdown
@@ -8,9 +8,9 @@ filename: learntypescript-fr.ts
 lang: fr-fr
 ---
 
-TypeScript est un langage visant à faciliter le développement d'applications large et scalable écrite en JavaScript.
+TypeScript est un langage visant à faciliter le développement d'applications larges et scalables, écrites en JavaScript.
 TypeScript ajoute des concepts classiques comme les classes, les modules, les interfaces, les génériques et le typage statique (optionnel) à JavaScript.
-C'est une sur-couche de JavaScript : tout le code JavaScript est valide en TypeScript ce qui permet de l'ajouter de façon transparente à n'importe quel projet. Le code TypeScript est transcompilé en JavaScript par le compilateur
+C'est une surcouche de JavaScript : tout le code JavaScript est valide en TypeScript ce qui permet de l'ajouter de façon transparente à n'importe quel projet. Le code TypeScript est transcompilé en JavaScript par le compilateur.
 
 Cet article se concentrera seulement sur la syntaxe supplémentaire de TypeScript, plutôt que celle de [JavaScript] (../javascript/).
 
@@ -22,7 +22,7 @@ var isDone: boolean = false;
 var lines: number = 42;
 var name: string = "Anders";
 
-// Quand c'est impossible à déterminer, on utilise le type `Any`
+// Si nous ne pouvons pas déterminer le type, on utilise `Any`
 var notSure: any = 4;
 notSure = "maybe a string instead";
 notSure = false; // ok, définitivement un booléen
@@ -38,11 +38,11 @@ var c: Color = Color.Green;
 // Enfin, `void` est utilisé dans le cas spécifique
 // d'une fonction ne retournant rien
 function bigHorribleAlert(): void {
-  alert("I'm a little annoying box!");
+  alert("Je suis une petite boîte ennuyeuse !");
 }
 
-// Les fontions sont des entités de première classe. Elles supportent
-// les expressions lambda et utilisent l'inférence de types
+// Les fonctions sont des entités de première classe. Le langage supporte
+// les expressions lambda et utilise l'inférence de type
 
 // Les fonctions ci-dessous sont équivalentes, une signature identique
 // sera inférée par le compilateur, et le même JavaScript sera généré
@@ -55,8 +55,8 @@ var f4 = (i: number) => { return i * i; }
 // Retourne un type inféré, ici le mot clé `return` n'est pas nécessaire
 var f5 = (i: number) =>  i * i;
 
-// Les interfaces sont structurés, tout ce qui a les propriétés est compatible
-// avec l'interface
+// Les interfaces sont structurées, tout les objets qui ont ces propriétés
+// sont compatible avec l'interface
 interface Person {
   name: string;
   // Les propriétés optionnelles sont identifiées avec un "?"
@@ -78,7 +78,8 @@ var invalidPerson: Person = { name: "Bobby", age: true };
 interface SearchFunc {
   (source: string, subString: string): boolean;
 }
-// Seul les types des paramètres sont importants, les noms ne le sont pas.
+
+// Seul les types des paramètres sont importants. Les noms ne le sont pas.
 var mySearch: SearchFunc;
 mySearch = function(src: string, sub: string) {
   return src.search(sub) != -1;
@@ -86,7 +87,7 @@ mySearch = function(src: string, sub: string) {
 
 // Les membres des classes sont publiques par défaut.
 class Point {
-  // Propriétés
+    // Propriétés
     x: number;
 
     // Constructeur - Les mots clés "public" et "private" dans ce contexte
@@ -105,7 +106,7 @@ class Point {
 }
 
 var p1 = new Point(10 ,20);
-var p2 = new Point(25); //y will be 0
+var p2 = new Point(25); // y sera 0
 
 // Héritage
 class Point3D extends Point {
-- 
cgit v1.2.3


From 5042c531cc1ced74ae5e12dac225ba219ff713dc Mon Sep 17 00:00:00 2001
From: Alois <aloisdegouvello@live.fr>
Date: Sun, 3 May 2015 20:58:03 +0200
Subject: Fix Markdown

---
 fr-fr/json-fr.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'fr-fr')

diff --git a/fr-fr/json-fr.html.markdown b/fr-fr/json-fr.html.markdown
index dc46e043..41d79b18 100644
--- a/fr-fr/json-fr.html.markdown
+++ b/fr-fr/json-fr.html.markdown
@@ -13,7 +13,7 @@ Comme JSON est un format d'échange de données extrêmement simple, ce Apprendr
 est susceptible d'être le plus simple jamais réalisé.
 
 JSON dans son état le plus pur n'a aucun commentaire, mais la majorité des parseurs accepterons
-les commentaires du langage C (`//`, `\* \*`). Pour les besoins de ce document, cependant,
+les commentaires du langage C (`//`, `/* */`). Pour les besoins de ce document, cependant,
 tout sera du JSON 100% valide. Heureusement, il s'explique par lui-même.
 
 
-- 
cgit v1.2.3


From 86f406d99c829d0f3074f18346173387f1eb6064 Mon Sep 17 00:00:00 2001
From: Alois <aloisdegouvello@live.fr>
Date: Sun, 3 May 2015 20:59:27 +0200
Subject: Fix Header

---
 fr-fr/json-fr.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/json-fr.html.markdown b/fr-fr/json-fr.html.markdown
index 41d79b18..49c95820 100644
--- a/fr-fr/json-fr.html.markdown
+++ b/fr-fr/json-fr.html.markdown
@@ -4,9 +4,9 @@ filename: learnjson-fr.json
 contributors:
   - ["Anna Harren", "https://github.com/iirelu"]
   - ["Marco Scannadinari", "https://github.com/marcoms"]
-  translators:
+translators:
   - ["Alois de Gouvello","https://github.com/aloisdg"]
-  lang: fr-fr
+lang: fr-fr
 ---
 
 Comme JSON est un format d'échange de données extrêmement simple, ce Apprendre X en Y minutes
-- 
cgit v1.2.3


From afb44df97380cbfe037cdf5cf6bcb07355615552 Mon Sep 17 00:00:00 2001
From: chtiprog <chtiprog@free.fr>
Date: Sun, 7 Dec 2014 01:47:25 +0100
Subject: Add French translation for R

---
 fr-fr/r-fr.html.markdown | 721 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 721 insertions(+)
 create mode 100644 fr-fr/r-fr.html.markdown

(limited to 'fr-fr')

diff --git a/fr-fr/r-fr.html.markdown b/fr-fr/r-fr.html.markdown
new file mode 100644
index 00000000..8db78ef3
--- /dev/null
+++ b/fr-fr/r-fr.html.markdown
@@ -0,0 +1,721 @@
+---
+language: R
+contributors:
+    - ["e99n09", "http://github.com/e99n09"]
+    - ["isomorphismes", "http://twitter.com/isomorphisms"]
+translators:
+    - ["Anne-Catherine Dehier", "https://github.com/spellart"]
+filename: learnr-fr.r
+---
+
+R est un langage de programmation statistique. Il dispose de nombreuses
+librairies pour le téléchargement et le nettoyage des ensembles de données,
+l'exécution de procédures statistiques, et pour faire des graphiques.
+On peut également exécuter les commmandes R à l'aide d'un document LaTeX.
+
+
+```r
+
+# Les commentaires commencent avec des symboles numériques.
+
+# Il n'est pas possible de faire des commentaires multilignes,
+# mais on peut superposer plusieurs commentaires comme ceci.
+
+# Sur Windows ou Mac, taper COMMAND-ENTER pour exécuter une ligne
+
+
+
+#############################################################################
+# Les choses que vous pouvez faire sans rien comprendre à la programmation
+#############################################################################
+
+# In this section, we show off some of the cool stuff you can do in
+# Dans cette section, nous vous montrons quelques trucs cools que vous
+# pouvez faire avec R sans rien comprendre à la programmation.
+# Ne vous inquiétez pas si vous ne comprenez pas tout ce que le code fait.
+# Profitez simplement !
+
+data()	        # parcours les ensembles de données préchargées
+data(rivers)	# obtiens celui-ci: "Lengths of Major North American Rivers"
+ls()	        # notez que "rivers" apparaît maintenant dans votre espace de travail
+head(rivers)	# Jetez un coup d'oeil à l'ensemble de données
+# 735 320 325 392 524 450
+
+length(rivers)	# Combien de rivers ont été mesurées ?
+# 141
+summary(rivers) # quelles sont les statistiques sommaires ?
+#   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
+#  135.0   310.0   425.0   591.2   680.0  3710.0 
+
+# Fait un diagramme à tiges et à feuilles (visualisation de données de
+types histogramme)
+stem(rivers)
+
+
+#  Le point décimal est de 2 chiffres à droite du |
+#
+#   0 | 4
+#   2 | 011223334555566667778888899900001111223333344455555666688888999
+#   4 | 111222333445566779001233344567
+#   6 | 000112233578012234468
+#   8 | 045790018
+#  10 | 04507
+#  12 | 1471
+#  14 | 56
+#  16 | 7
+#  18 | 9
+#  20 | 
+#  22 | 25
+#  24 | 3
+#  26 | 
+#  28 | 
+#  30 | 
+#  32 | 
+#  34 | 
+#  36 | 1
+
+stem(log(rivers)) # Notez que les données ne sont ni normales ni lognormales !
+# Prenez-ça les fondamentalistes, la courbe en cloche
+
+#  Le point décimal est à 1 chiffre à gauche du |
+#
+#  48 | 1
+#  50 | 
+#  52 | 15578
+#  54 | 44571222466689
+#  56 | 023334677000124455789
+#  58 | 00122366666999933445777
+#  60 | 122445567800133459
+#  62 | 112666799035
+#  64 | 00011334581257889
+#  66 | 003683579
+#  68 | 0019156
+#  70 | 079357
+#  72 | 89
+#  74 | 84
+#  76 | 56
+#  78 | 4
+#  80 | 
+#  82 | 2
+
+# Fais un histogramme :
+hist(rivers, col="#333333", border="white", breaks=25) # amusez-vous avec ces parenthèses
+hist(log(rivers), col="#333333", border="white", breaks=25) # vous ferez plus de tracés plus tard
+
+# Ici d'autres données nettes qui viennent préchargées. R en a des tonnes.
+data(discoveries)
+plot(discoveries, col="#333333", lwd=3, xlab="Year",
+     main="Number of important discoveries per year")
+plot(discoveries, col="#333333", lwd=3, type = "h", xlab="Year",
+     main="Number of important discoveries per year")
+
+# Plutôt que de laisser l'ordre par défaut (par années)
+# Nous pourrions aussi trier pour voir ce qu'il y a de typique
+sort(discoveries)
+#  [1]  0  0  0  0  0  0  0  0  0  1  1  1  1  1  1  1  1  1  1  1  1  2  2  2  2
+# [26]  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  3  3  3
+# [51]  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  4  4  4  4  4  4  4  4
+# [76]  4  4  4  4  5  5  5  5  5  5  5  6  6  6  6  6  6  7  7  7  7  8  9 10 12
+
+stem(discoveries, scale=2)
+# 
+#  Le point décimale est à la |
+#
+#   0 | 000000000
+#   1 | 000000000000
+#   2 | 00000000000000000000000000
+#   3 | 00000000000000000000
+#   4 | 000000000000
+#   5 | 0000000
+#   6 | 000000
+#   7 | 0000
+#   8 | 0
+#   9 | 0
+#  10 | 0
+#  11 | 
+#  12 | 0
+
+max(discoveries)
+# 12
+summary(discoveries)
+#   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
+#    0.0     2.0     3.0     3.1     4.0    12.0 
+
+# Lance un dès quelques fois
+round(runif(7, min=.5, max=6.5))
+# 1 4 6 1 4 6 4
+# Vos numéros diffèreront des miens à moins que nous mettions le même random.seed(31337)
+
+# Dessine à partir d'une normale Gaussienne 9 fois
+rnorm(9)
+# [1]  0.07528471  1.03499859  1.34809556 -0.82356087  0.61638975 -1.88757271
+# [7] -0.59975593  0.57629164  1.08455362
+
+
+
+##################################################
+# les types de données et l'arithmétique de base
+##################################################
+
+# Now for the programming-oriented part of the tutorial.
+# In this section you will meet the important data types of R:
+# integers, numerics, characters, logicals, and factors.
+# There are others, but these are the bare minimum you need to
+# get started.
+
+# Maintenant pour la partie orientée programmation du tutoriel.
+# Dans cette section vous rencontrerez les types de données importants de R :
+# les entiers, les numériques, les caractères, les logiques, et les facteurs.
+
+# LES ENTIERS
+# Les entiers de mémoire longue sont écrit avec L
+5L # 5
+class(5L) # "integer"
+# (Essayez ?class pour plus d'information sur la fonction class().)
+# Avec R, chaque valeur seule, comme 5L, est considéré comme un vecteur de longueur 1
+length(5L) # 1
+# On peut avoir un vecteur d'entiers avec une longueur > 1 aussi :
+c(4L, 5L, 8L, 3L) # 4 5 8 3
+length(c(4L, 5L, 8L, 3L)) # 4
+class(c(4L, 5L, 8L, 3L)) # "integer"
+
+# LES NUMÉRIQUES
+# Un "numeric" est un nombre à virgule flottante avec une double précision
+5 # 5
+class(5) # "numeric"
+# Encore une fois, tout dans R est un vecteur ;
+# Vous pouvez faire un vecteur numérique avec plus d'un élément
+c(3,3,3,2,2,1) # 3 3 3 2 2 1
+# Vous pouvez utiliser la notation scientifique aussi
+5e4 # 50000
+6.02e23 # nombre d'Avogadro
+1.6e-35 # longueur de Planck
+# Vous pouvez également avoir des nombres infiniments grands ou petits
+class(Inf)	# "numeric"
+class(-Inf)	# "numeric"
+# Vous pouvez utiliser "Inf", par exemple, dans integrate(dnorm, 3, Inf);
+# Ça permet d'éviter des tableaux Z-scores.
+
+# ARITHMÉTIQUES DE BASE
+# Vous pouvez faire de l'arithmétique avec des nombres
+# Faire des opérations arithmétiques en mixant des entiers et des numériques
+# donne un autre numérique
+10L + 66L # 76      # un entier plus un entier donne un entier
+53.2 - 4  # 49.2    # un numérique moins un numérique donne un numérique
+2.0 * 2L  # 4       # un numérique multiplié par un entier donne un numérique
+3L / 4    # 0.75    # un entier sur un numérique donne un numérique
+3 %% 2	  # 1       # le reste de deux numériques est un autre numérique
+# Les opérations arithmétiques illégales rapportent un "Not A Number" :
+0 / 0 # NaN
+class(NaN) # "numeric"
+# You can do arithmetic on two vectors with length greater than 1,
+# Vous pouvez faire des opérations arithmétiques avec deux vecteurs d'une
+# longueur plus grande que 1, à condition que la longueur du plus grand
+# vecteur soit un multiple entier du plus petit
+c(1,2,3) + c(1,2,3) # 2 4 6
+
+# LES CARACTÈRES
+# Il n'y a pas de différences entre les chaînes de caractères et les caractères en R
+"Horatio" # "Horatio"
+class("Horatio") # "character"
+class('H') # "character"
+# Ceux-ci sont tous les deux des vecteurs de longueur 1
+# Ici un plus long :
+c('alef', 'bet', 'gimmel', 'dalet', 'he')
+# =>
+# "alef"   "bet"    "gimmel" "dalet"  "he"
+length(c("Call","me","Ishmael")) # 3
+# Vous pouvez faire des expressions rationnelles sur les vecteurs de caractères :
+substr("Fortuna multis dat nimis, nulli satis.", 9, 15) # "multis "
+gsub('u', 'ø', "Fortuna multis dat nimis, nulli satis.") # "Fortøna møltis dat nimis, nølli satis."
+# R possède plusieurs vecteurs de caractères préconstruits :
+letters
+# =>
+#  [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s"
+# [20] "t" "u" "v" "w" "x" "y" "z"
+month.abb # "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec"
+
+# LES TYPES LOGIQUES
+# En R, un "logical" est un booléen
+class(TRUE)	# "logical"
+class(FALSE)	# "logical"
+# Leur comportement est normal
+TRUE == TRUE	# TRUE
+TRUE == FALSE	# FALSE
+FALSE != FALSE	# FALSE
+FALSE != TRUE	# TRUE
+# Les données manquantes (NA) sont logiques également
+class(NA)	# "logical"
+# Ici nous avons un vecteur de type logique avec plusieurs éléments :
+c('Z', 'o', 'r', 'r', 'o') == "Zorro" # FALSE FALSE FALSE FALSE FALSE
+c('Z', 'o', 'r', 'r', 'o') == "Z" # TRUE FALSE FALSE FALSE FALSE
+
+# LES FACTEURS
+# The factor class is for categorical data
+# La classe facteur sert aux données catégorielles
+# les facteurs peuvent être ordonnés (comme les niveaux de catégorie d'enfants)
+# ou non ordonnés (comme le sexe)
+factor(c("female", "female", "male", NA, "female"))
+#  female female male   <NA>   female
+# Les niveaux : female male
+# Les "levels" sont les valeurs que les données catégorielles peuvent prendre
+# Notez que cette donnée manquante n'entre pas dans le niveau
+levels(factor(c("male", "male", "female", NA, "female"))) # "female" "male"
+# Si le vecteur de facteurs a une longueur 1, ses niveaux seront de longueur 1 également
+length(factor("male")) # 1
+length(levels(factor("male"))) # 1
+# On rencontre communément des facteurs dans des trames de données, 
+# une structure de données que nous couvrirons plus tard
+data(infert) # "Infertility after Spontaneous and Induced Abortion"
+levels(infert$education) # "0-5yrs"  "6-11yrs" "12+ yrs"
+
+# NULL
+# "NULL" est bizarre ; on l'utilise pour effacer un vecteur
+class(NULL)	# NULL
+parakeet
+# =>
+# [1] "beak"     "feathers" "wings"    "eyes"    
+parakeet <- NULL
+parakeet
+# =>
+# NULL
+
+# LES CONTRAINTES DE TYPES
+# Les contraintes de types servent à forcer une valeur à prendre un type différent
+as.character(c(6, 8)) # "6" "8"
+as.logical(c(1,0,1,1)) # TRUE FALSE  TRUE  TRUE
+# Si vous mettez des éléments de différents types dans un vecteur, des coercitions bizarres se produisent :
+c(TRUE, 4) # 1 4
+c("dog", TRUE, 4) # "dog"  "TRUE" "4"
+as.numeric("Bilbo")
+# =>
+# [1] NA
+# Message d'avertissement :
+# NAs est introduit par coercition
+
+# Notez également : ce n'étaient que des types de données basiques
+# Il y a beaucoup d'autres types de données, comme pour les dates, les séries de temps, etc ...
+
+
+
+##################################################
+# Variables, boucles , if/else
+##################################################
+
+# Une variable est comme une boîte où l'on garde une valeur pour l'utiliser plus tard.
+# Nous appellons ça "assigner" une valeur à une variable.
+# Avoir des variables nous permets d'écrire des boucles, des fonctions, et
+# des instructions conditionnelles (if/else)
+
+# LES VARIABLES
+# Beaucoup de façons d'assigner des choses :
+x = 5 # c'est possible
+y <- "1" # c'est préféré
+TRUE -> z # ça marche mais c'est bizarre
+
+# LES BOUCLES
+# Il y a les boucles for :
+for (i in 1:4) {
+  print(i)
+}
+# Il y a les boucles while :
+a <- 10
+while (a > 4) {
+	cat(a, "...", sep = "")
+	a <- a - 1
+}
+# Gardez à l'esprit que les boucles for et while s'exécute lentement en R
+# Des opérations sur des vecteurs entiers (ex un ligne entière, une colonne entière),
+# ou la fonction apply()-type (nous en parlerons plus tard), sont préférés
+
+# IF/ELSE
+# Encore une fois assez standard
+if (4 > 3) {
+	print("4 is greater than 3")
+} else {
+	print("4 is not greater than 3")
+}
+# =>
+# [1] "4 is greater than 3"
+
+# LES FONCTIONS
+# se définissent comme ceci :
+jiggle <- function(x) {
+	x = x + rnorm(1, sd=.1)	#add in a bit of (controlled) noise
+	return(x)
+}
+# Appelée comme n'importe quelle autre fonction R :
+jiggle(5)	# 5±ε. After set.seed(2716057), jiggle(5)==5.005043
+
+
+
+###########################################################################
+# Les structures de données : les vecteurs, les matrices, les trames de données et les tableaux
+###########################################################################
+
+# À UNE DIMENSION
+
+# Commençons par le tout début, et avec quelque chose que vous connaissez déjà : les vecteurs.
+vec <- c(8, 9, 10, 11)
+vec	#  8  9 10 11
+# Nous demandons des éléments spécifiques en les mettant entre crochets
+# (Notez que R commence à compter par 1)
+vec[1]		# 8
+letters[18]	# "r"
+LETTERS[13]	# "M"
+month.name[9]	# "September"
+c(6, 8, 7, 5, 3, 0, 9)[3]	# 7
+# Nous pouvons également rechercher des indices de composants spécifiques,
+which(vec %% 2 == 0)	# 1 3
+# Récupèrer seulement quelques premières ou dernières entrées du vecteur,
+head(vec, 1)	# 8
+tail(vec, 2)	# 10 11
+# ou trouver si un certaine valeur est dans le vecteur
+any(vec == 10) # TRUE
+# Si un index "dépasse" vous obtiendrez NA :
+vec[6]	# NA
+# Vous pouvez trouver la longueur de votre vecteur avec length()
+length(vec)	# 4
+# Vous pouvez réaliser des opérations sur des vecteurs entiers ou des sous-ensembles de vecteurs
+vec * 4	# 16 20 24 28
+vec[2:3] * 5	# 25 30
+any(vec[2:3] == 8) # FALSE
+# Et R a beaucoup de fonctions préconstruites pour résumer les vecteurs
+mean(vec)	# 9.5
+var(vec)	# 1.666667
+sd(vec)		# 1.290994
+max(vec)	# 11
+min(vec)	# 8
+sum(vec)	# 38
+# Quelques fonctions préconstruites sympas supplémentaires :
+5:15	# 5  6  7  8  9 10 11 12 13 14 15
+seq(from=0, to=31337, by=1337)
+# =>
+#  [1]     0  1337  2674  4011  5348  6685  8022  9359 10696 12033 13370 14707
+# [13] 16044 17381 18718 20055 21392 22729 24066 25403 26740 28077 29414 30751
+
+# À DEUX DIMENSIONS (TOUT DANS UNE CLASSE)
+
+# Vous pouvez faire une matrice de toutes les entrées du même type comme ceci :
+mat <- matrix(nrow = 3, ncol = 2, c(1,2,3,4,5,6))
+mat
+# =>
+#      [,1] [,2]
+# [1,]    1    4
+# [2,]    2    5
+# [3,]    3    6
+# Différemment du vecteur, la classe d'une matrice est "matrix",peut importe ce qu'elle contient
+class(mat) # => "matrix"
+# Demander la première ligne
+mat[1,]	# 1 4
+# Réaliser une opération sur la première colonne
+3 * mat[,1]	# 3 6 9
+# Ask for a specific cell
+mat[3,2]	# 6
+
+# Transposer la matrice entière
+t(mat)
+# =>
+#      [,1] [,2] [,3]
+# [1,]    1    2    3
+# [2,]    4    5    6
+
+# La multiplication de matrices
+mat %*% t(mat)
+# =>
+#      [,1] [,2] [,3]
+# [1,]   17   22   27
+# [2,]   22   29   36
+# [3,]   27   36   45
+
+# cbind() colle des vecteurs ensemble en colonne pour faire une matrice
+mat2 <- cbind(1:4, c("dog", "cat", "bird", "dog"))
+mat2
+# =>
+#      [,1] [,2]   
+# [1,] "1"  "dog"  
+# [2,] "2"  "cat"  
+# [3,] "3"  "bird" 
+# [4,] "4"  "dog"
+class(mat2)	# matrix
+# Encore une fois notez ce qui se passe !
+# Parce que les matrices peuvent contenir des entrées de toutes sortes de classes,
+# tout sera converti en classe caractère
+c(class(mat2[,1]), class(mat2[,2]))
+
+# rbind() colle des vecteurs ensemble par lignes pour faire une matrice
+mat3 <- rbind(c(1,2,4,5), c(6,7,0,4))
+mat3
+# =>
+#      [,1] [,2] [,3] [,4]
+# [1,]    1    2    4    5
+# [2,]    6    7    0    4
+# Ah, tout de la même classe. Pas de coercitions. Beaucoup mieux.
+
+# À DEUX DIMENSIONS (DE CLASSES DIFFÉRENTES)
+
+# Pour des colonnes de différents types, utiliser une trame de donnée
+# Cette structure de données est si utile pour la programmation statistique,
+# qu'une version a été ajoutée à Python dans le paquet "pandas".
+
+students <- data.frame(c("Cedric","Fred","George","Cho","Draco","Ginny"),
+                       c(3,2,2,1,0,-1),
+                       c("H", "G", "G", "R", "S", "G"))
+names(students) <- c("name", "year", "house") # name the columns
+class(students)	# "data.frame"
+students
+# =>
+#     name year house
+# 1 Cedric    3     H
+# 2   Fred    2     G
+# 3 George    2     G
+# 4    Cho    1     R
+# 5  Draco    0     S
+# 6  Ginny   -1     G
+class(students$year)	# "numeric"
+class(students[,3])	# "factor"
+# Trouver les dimensions
+nrow(students)	# 6
+ncol(students)	# 3
+dim(students)	# 6 3
+# La fonction data.frame() convertit les vecteurs caractères en vecteurs de facteurs
+# par défaut; désactiver cette fonction en règlant stringsAsFactors = FALSE
+# quand vous créer la data.frame
+?data.frame
+
+# Il y a plusieurs façons tortueuses de subdiviser les trames de données
+# toutes subtilement différentes
+students$year	# 3  2  2  1  0 -1
+students[,2]	# 3  2  2  1  0 -1
+students[,"year"]	# 3  2  2  1  0 -1
+
+# Une version augmentée de la structure data.frame est data.table
+# Si vous travaillez avec des données volumineuses ou des panels, ou avez 
+# besoin de fusionner quelques ensembles de données, data.table peut être
+# un bon choix. Ici un tour éclair :
+install.packages("data.table") # download the package from CRAN
+require(data.table) # load it
+students <- as.data.table(students)
+students # note the slightly different print-out
+# =>
+#      name year house
+# 1: Cedric    3     H
+# 2:   Fred    2     G
+# 3: George    2     G
+# 4:    Cho    1     R
+# 5:  Draco    0     S
+# 6:  Ginny   -1     G
+students[name=="Ginny"] # get rows with name == "Ginny"
+# =>
+#     name year house
+# 1: Ginny   -1     G
+students[year==2] # get rows with year == 2
+# =>
+#      name year house
+# 1:   Fred    2     G
+# 2: George    2     G
+# data.table facilite la fusion entre deux ensembles de données
+# Faisons un autre data.table pour fusionner students
+founders <- data.table(house=c("G","H","R","S"),
+                       founder=c("Godric","Helga","Rowena","Salazar"))
+founders
+# =>
+#    house founder
+# 1:     G  Godric
+# 2:     H   Helga
+# 3:     R  Rowena
+# 4:     S Salazar
+setkey(students, house)
+setkey(founders, house)
+students <- founders[students] # merge the two data sets by matching "house"
+setnames(students, c("house","houseFounderName","studentName","year"))
+students[,order(c("name","year","house","houseFounderName")), with=F]
+# =>
+#    studentName year house houseFounderName
+# 1:        Fred    2     G           Godric
+# 2:      George    2     G           Godric
+# 3:       Ginny   -1     G           Godric
+# 4:      Cedric    3     H            Helga
+# 5:         Cho    1     R           Rowena
+# 6:       Draco    0     S          Salazar
+
+# data.table facilite le sommaire des tableaux
+students[,sum(year),by=house]
+# =>
+#    house V1
+# 1:     G  3
+# 2:     H  3
+# 3:     R  1
+# 4:     S  0
+
+# Pour supprimer une colonne d'une data.frame ou data.table,
+# assignez-lui la valeur NULL
+students$houseFounderName <- NULL
+students
+# =>
+#    studentName year house
+# 1:        Fred    2     G
+# 2:      George    2     G
+# 3:       Ginny   -1     G
+# 4:      Cedric    3     H
+# 5:         Cho    1     R
+# 6:       Draco    0     S
+
+# Supprimer une ligne en subdivisant 
+# En utilisant data.table :
+students[studentName != "Draco"]
+# =>
+#    house studentName year
+# 1:     G        Fred    2
+# 2:     G      George    2
+# 3:     G       Ginny   -1
+# 4:     H      Cedric    3
+# 5:     R         Cho    1
+# En utilisant data.frame :
+students <- as.data.frame(students)
+students[students$house != "G",]
+# =>
+#   house houseFounderName studentName year
+# 4     H            Helga      Cedric    3
+# 5     R           Rowena         Cho    1
+# 6     S          Salazar       Draco    0
+
+# MULTI-DIMENSIONNELLE (TOUS ÉLÉMENTS D'UN TYPE)
+
+# Les arrays créent des tableaux de n dimensions
+# Tous les éléments doivent être du même type
+# Vous pouvez faire un tableau à 2 dimensions (une sorte de matrice)
+array(c(c(1,2,4,5),c(8,9,3,6)), dim=c(2,4))
+# =>
+#      [,1] [,2] [,3] [,4]
+# [1,]    1    4    8    3
+# [2,]    2    5    9    6
+# Vous pouvez utiliser array pour faire des matrices à 3 dimensions aussi
+array(c(c(c(2,300,4),c(8,9,0)),c(c(5,60,0),c(66,7,847))), dim=c(3,2,2))
+# =>
+# , , 1
+#
+#      [,1] [,2]
+# [1,]    2    8
+# [2,]  300    9
+# [3,]    4    0
+#
+# , , 2
+#
+#      [,1] [,2]
+# [1,]    5   66
+# [2,]   60    7
+# [3,]    0  847
+
+# LES LISTES (MULTI-DIMENSIONNELLES, ÉVENTUELLEMMENT DÉCHIRÉES, DE DIFFÉRENTS TYPES)
+
+# Enfin R a des listes (de vecteurs)
+list1 <- list(time = 1:40)
+list1$price = c(rnorm(40,.5*list1$time,4)) # random
+list1
+# Vous pouvez obtenir des éléments de la liste comme ceci
+list1$time # one way
+list1[["time"]] # another way
+list1[[1]] # yet another way
+# =>
+#  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
+# [34] 34 35 36 37 38 39 40
+# Vous pouvez subdiviser les éléments d'une liste comme n'importe quel vecteur
+list1$price[4]
+
+# Les listes ne sont pas les structures de données les plus efficaces
+# pour travailler en R;
+# À moins d'avoir une très bonne raison, vous devriez appliquer data.frames
+# Les listes sont souvent retournées par des fonctions qui effectuent des régressions linéaires
+
+##################################################
+# La famille de fonction apply()
+##################################################
+
+# Vous vous rappelez mat ?
+mat
+# =>
+#      [,1] [,2]
+# [1,]    1    4
+# [2,]    2    5
+# [3,]    3    6
+# Utilisez apply(X, MARGIN, FUN) pour appliquer la fonction FUN à la matrice X
+# sur les lignes (MAR = 1) ou les colonnes (MAR = 2)
+# R fait FUN à chaque lignes (ou colonnes) de X, beaucoup plus rapidement
+# qu'une bouce for ou while le ferait
+apply(mat, MAR = 2, jiggle)
+# =>
+#      [,1] [,2]
+# [1,]    3   15
+# [2,]    7   19
+# [3,]   11   23
+# D'autres fonctions : ?lapply, ?sapply
+ 
+# Ne soyez pas trop intimidé ; tout le monde reconnaît que c'est un peu déroutant
+
+# Le paque plyr vise à remplacer (et améliorer !) la famille *apply().
+install.packages("plyr")
+require(plyr)
+?plyr
+
+
+
+#########################
+# Charger des données
+#########################
+
+# "pets.csv" est un fichier sur internet
+# (mais il pourrait être tout aussi facilement sur votre ordinateur)
+pets <- read.csv("http://learnxinyminutes.com/docs/pets.csv")
+pets
+head(pets, 2) # first two rows
+tail(pets, 1) # last row
+
+# Pour sauver une trame de donnée ou une matrice en fichier .csv
+write.csv(pets, "pets2.csv") # to make a new .csv file
+# définir le répertoire de travail avec setwd(), le récupérer avec getwd()
+
+# Essayez ?read.csv et ?write.csv pour plus d'informations
+
+
+
+#########################
+# Les tracés
+#########################
+
+# LES FONCTIONS DE TRACÉS PRÉCONSTRUITES
+# Les diagrammes de dispersion !
+plot(list1$time, list1$price, main = "fake data")
+# Les régressions !
+linearModel <- lm(price  ~ time, data = list1)
+linearModel # sort le résultat de la régression
+# Tracer une ligne de regression sur une tracé existant
+abline(linearModel, col = "red")
+# Obtenir une variété de diagnostiques sympas
+plot(linearModel)
+# Les histogrammes !
+hist(rpois(n = 10000, lambda = 5), col = "thistle")
+# Les diagrammes en bâtons !
+barplot(c(1,4,5,1,2), names.arg = c("red","blue","purple","green","yellow"))
+
+# GGPLOT2
+# Mais ceux-ci ne sont même pas les plus jolis tracés de R
+# Essayez le paquet ggplot2 pour d'avantages de graphiques meilleurs
+install.packages("ggplot2")
+require(ggplot2)
+?ggplot2
+pp <- ggplot(students, aes(x=house))
+pp + geom_histogram()
+ll <- as.data.table(list1)
+pp <- ggplot(ll, aes(x=time,price))
+pp + geom_point()
+# ggplot2 a une documentation excellente (disponible sur http://docs.ggplot2.org/current/)
+
+
+
+```
+
+## How do I get R?
+
+* Get R and the R GUI from [http://www.r-project.org/](http://www.r-project.org/)
+* [RStudio](http://www.rstudio.com/ide/) is another GUI
-- 
cgit v1.2.3


From a6c01bf515c02522f3ff128a7d55806908ea3871 Mon Sep 17 00:00:00 2001
From: Chtiprog <chtiprog@free.fr>
Date: Sun, 3 May 2015 21:44:23 -0300
Subject: add french translation of R

---
 fr-fr/r-fr.html.markdown | 286 +++++++++++++++++++++++++----------------------
 1 file changed, 154 insertions(+), 132 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/r-fr.html.markdown b/fr-fr/r-fr.html.markdown
index 8db78ef3..d6879c1f 100644
--- a/fr-fr/r-fr.html.markdown
+++ b/fr-fr/r-fr.html.markdown
@@ -9,9 +9,9 @@ filename: learnr-fr.r
 ---
 
 R est un langage de programmation statistique. Il dispose de nombreuses
-librairies pour le téléchargement et le nettoyage des ensembles de données,
-l'exécution de procédures statistiques, et pour faire des graphiques.
-On peut également exécuter les commmandes R à l'aide d'un document LaTeX.
+librairies pour le téléchargement et le nettoyage d'ensembles de données,
+l'exécution de procédures statistiques, et la réalisation de graphiques.
+On peut également exécuter les commmandes `R` au sein d'un document LaTeX.
 
 
 ```r
@@ -25,30 +25,30 @@ On peut également exécuter les commmandes R à l'aide d'un document LaTeX.
 
 
 
-#############################################################################
-# Les choses que vous pouvez faire sans rien comprendre à la programmation
-#############################################################################
+########################################################################
+# Les choses que vous pouvez faire sans rien comprendre
+# à la programmation
+########################################################################
 
-# In this section, we show off some of the cool stuff you can do in
 # Dans cette section, nous vous montrons quelques trucs cools que vous
 # pouvez faire avec R sans rien comprendre à la programmation.
 # Ne vous inquiétez pas si vous ne comprenez pas tout ce que le code fait.
 # Profitez simplement !
 
-data()	        # parcours les ensembles de données préchargées
-data(rivers)	# obtiens celui-ci: "Lengths of Major North American Rivers"
-ls()	        # notez que "rivers" apparaît maintenant dans votre espace de travail
-head(rivers)	# Jetez un coup d'oeil à l'ensemble de données
+data()          # parcours les ensembles de données préchargées
+data(rivers)	# récupère ceci : "Lengths of Major North American Rivers"
+ls()            # notez que "rivers" apparaît maintenant dans votre espace de travail
+head(rivers)	# donne un aperçu des données
 # 735 320 325 392 524 450
 
 length(rivers)	# Combien de rivers ont été mesurées ?
 # 141
-summary(rivers) # quelles sont les statistiques sommaires ?
-#   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
-#  135.0   310.0   425.0   591.2   680.0  3710.0 
+summary(rivers) # Quels sont les principales données statistiques ?
+#   Min. 1st Qu.  Median    Mean 3rd Qu.    Max.
+#  135.0   310.0   425.0   591.2   680.0  3710.0
 
 # Fait un diagramme à tiges et à feuilles (visualisation de données de
-types histogramme)
+# types histogramme)
 stem(rivers)
 
 
@@ -64,23 +64,24 @@ stem(rivers)
 #  14 | 56
 #  16 | 7
 #  18 | 9
-#  20 | 
+#  20 |
 #  22 | 25
 #  24 | 3
-#  26 | 
-#  28 | 
-#  30 | 
-#  32 | 
-#  34 | 
+#  26 |
+#  28 |
+#  30 |
+#  32 |
+#  34 |
 #  36 | 1
 
-stem(log(rivers)) # Notez que les données ne sont ni normales ni lognormales !
-# Prenez-ça les fondamentalistes, la courbe en cloche
+stem(log(rivers)) # Notez que les données ne sont ni normales
+# ni lognormales !
+# Prenez-ça, la courbe en cloche
 
 #  Le point décimal est à 1 chiffre à gauche du |
 #
 #  48 | 1
-#  50 | 
+#  50 |
 #  52 | 15578
 #  54 | 44571222466689
 #  56 | 023334677000124455789
@@ -95,14 +96,14 @@ stem(log(rivers)) # Notez que les données ne sont ni normales ni lognormales !
 #  74 | 84
 #  76 | 56
 #  78 | 4
-#  80 | 
+#  80 |
 #  82 | 2
 
 # Fais un histogramme :
-hist(rivers, col="#333333", border="white", breaks=25) # amusez-vous avec ces parenthèses
+hist(rivers, col="#333333", border="white", breaks=25) # amusez-vous avec ces paramètres
 hist(log(rivers), col="#333333", border="white", breaks=25) # vous ferez plus de tracés plus tard
 
-# Ici d'autres données nettes qui viennent préchargées. R en a des tonnes.
+# Ici d'autres données qui viennent préchargées. R en a des tonnes.
 data(discoveries)
 plot(discoveries, col="#333333", lwd=3, xlab="Year",
      main="Number of important discoveries per year")
@@ -118,7 +119,7 @@ sort(discoveries)
 # [76]  4  4  4  4  5  5  5  5  5  5  5  6  6  6  6  6  6  7  7  7  7  8  9 10 12
 
 stem(discoveries, scale=2)
-# 
+#
 #  Le point décimale est à la |
 #
 #   0 | 000000000
@@ -132,19 +133,20 @@ stem(discoveries, scale=2)
 #   8 | 0
 #   9 | 0
 #  10 | 0
-#  11 | 
+#  11 |
 #  12 | 0
 
 max(discoveries)
 # 12
 summary(discoveries)
-#   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
-#    0.0     2.0     3.0     3.1     4.0    12.0 
+#   Min. 1st Qu.  Median    Mean 3rd Qu.    Max.
+#    0.0     2.0     3.0     3.1     4.0    12.0
 
-# Lance un dès quelques fois
+# Lance un dès plusieurs fois
 round(runif(7, min=.5, max=6.5))
 # 1 4 6 1 4 6 4
-# Vos numéros diffèreront des miens à moins que nous mettions le même random.seed(31337)
+# Vos numéros diffèreront des miens à moins que nous mettions
+# le même random.seed(31337)
 
 # Dessine à partir d'une normale Gaussienne 9 fois
 rnorm(9)
@@ -153,15 +155,9 @@ rnorm(9)
 
 
 
-##################################################
+##############################################################
 # les types de données et l'arithmétique de base
-##################################################
-
-# Now for the programming-oriented part of the tutorial.
-# In this section you will meet the important data types of R:
-# integers, numerics, characters, logicals, and factors.
-# There are others, but these are the bare minimum you need to
-# get started.
+##############################################################
 
 # Maintenant pour la partie orientée programmation du tutoriel.
 # Dans cette section vous rencontrerez les types de données importants de R :
@@ -171,22 +167,23 @@ rnorm(9)
 # Les entiers de mémoire longue sont écrit avec L
 5L # 5
 class(5L) # "integer"
-# (Essayez ?class pour plus d'information sur la fonction class().)
-# Avec R, chaque valeur seule, comme 5L, est considéré comme un vecteur de longueur 1
+# (Essayez ?class pour plus d'informations sur la fonction class().)
+# Avec R, chaque valeur seule, comme 5L, est considéré comme
+# un vecteur de longueur 1
 length(5L) # 1
-# On peut avoir un vecteur d'entiers avec une longueur > 1 aussi :
+# On peut avoir un vecteur d'entiers avec une longueur > 1 :
 c(4L, 5L, 8L, 3L) # 4 5 8 3
 length(c(4L, 5L, 8L, 3L)) # 4
 class(c(4L, 5L, 8L, 3L)) # "integer"
 
 # LES NUMÉRIQUES
-# Un "numeric" est un nombre à virgule flottante avec une double précision
+# Un "numeric" est un nombre à virgule flottante d'une précision double
 5 # 5
 class(5) # "numeric"
 # Encore une fois, tout dans R est un vecteur ;
 # Vous pouvez faire un vecteur numérique avec plus d'un élément
 c(3,3,3,2,2,1) # 3 3 3 2 2 1
-# Vous pouvez utiliser la notation scientifique aussi
+# Vous pouvez aussi utiliser la notation scientifique
 5e4 # 50000
 6.02e23 # nombre d'Avogadro
 1.6e-35 # longueur de Planck
@@ -198,24 +195,25 @@ class(-Inf)	# "numeric"
 
 # ARITHMÉTIQUES DE BASE
 # Vous pouvez faire de l'arithmétique avec des nombres
-# Faire des opérations arithmétiques en mixant des entiers et des numériques
+# Faire des opérations arithmétiques en mixant des entiers
+# et des numériques
 # donne un autre numérique
 10L + 66L # 76      # un entier plus un entier donne un entier
 53.2 - 4  # 49.2    # un numérique moins un numérique donne un numérique
 2.0 * 2L  # 4       # un numérique multiplié par un entier donne un numérique
 3L / 4    # 0.75    # un entier sur un numérique donne un numérique
-3 %% 2	  # 1       # le reste de deux numériques est un autre numérique
-# Les opérations arithmétiques illégales rapportent un "Not A Number" :
+3 %% 2    # 1       # le reste de deux numériques est un autre numérique
+# Les opérations arithmétiques illégales donnent un "Not A Number" :
 0 / 0 # NaN
 class(NaN) # "numeric"
-# You can do arithmetic on two vectors with length greater than 1,
 # Vous pouvez faire des opérations arithmétiques avec deux vecteurs d'une
 # longueur plus grande que 1, à condition que la longueur du plus grand
 # vecteur soit un multiple entier du plus petit
 c(1,2,3) + c(1,2,3) # 2 4 6
 
 # LES CARACTÈRES
-# Il n'y a pas de différences entre les chaînes de caractères et les caractères en R
+# Il n'y a pas de différences entre les chaînes de caractères et
+# les caractères en R
 "Horatio" # "Horatio"
 class("Horatio") # "character"
 class('H') # "character"
@@ -225,7 +223,7 @@ c('alef', 'bet', 'gimmel', 'dalet', 'he')
 # =>
 # "alef"   "bet"    "gimmel" "dalet"  "he"
 length(c("Call","me","Ishmael")) # 3
-# Vous pouvez faire des expressions rationnelles sur les vecteurs de caractères :
+# Vous pouvez utiliser des expressions rationnelles sur les vecteurs de caractères :
 substr("Fortuna multis dat nimis, nulli satis.", 9, 15) # "multis "
 gsub('u', 'ø', "Fortuna multis dat nimis, nulli satis.") # "Fortøna møltis dat nimis, nølli satis."
 # R possède plusieurs vecteurs de caractères préconstruits :
@@ -246,45 +244,57 @@ FALSE != FALSE	# FALSE
 FALSE != TRUE	# TRUE
 # Les données manquantes (NA) sont logiques également
 class(NA)	# "logical"
+# On utilise | et & pour les operations logiques.
+# OR
+TRUE | FALSE	# TRUE
+# AND
+TRUE & FALSE	# FALSE
+# Vous pouvez tester si x est TRUE
+isTRUE(TRUE)	# TRUE
 # Ici nous avons un vecteur de type logique avec plusieurs éléments :
 c('Z', 'o', 'r', 'r', 'o') == "Zorro" # FALSE FALSE FALSE FALSE FALSE
 c('Z', 'o', 'r', 'r', 'o') == "Z" # TRUE FALSE FALSE FALSE FALSE
 
 # LES FACTEURS
-# The factor class is for categorical data
-# La classe facteur sert aux données catégorielles
-# les facteurs peuvent être ordonnés (comme les niveaux de catégorie d'enfants)
+# La classe facteur sert pour les données catégorielles
+# les facteurs peuvent être ordonnés (comme les niveaux de
+# catégorie d'enfants)
 # ou non ordonnés (comme le sexe)
 factor(c("female", "female", "male", NA, "female"))
 #  female female male   <NA>   female
 # Les niveaux : female male
-# Les "levels" sont les valeurs que les données catégorielles peuvent prendre
-# Notez que cette donnée manquante n'entre pas dans le niveau
+# Les "levels" sont les valeurs que les données catégorielles
+# peuvent prendre
+# Notez que les données manquantes n'entrent pas dans le niveau
 levels(factor(c("male", "male", "female", NA, "female"))) # "female" "male"
-# Si le vecteur de facteurs a une longueur 1, ses niveaux seront de longueur 1 également
+# Si le vecteur de facteurs a une longueur 1, ses niveaux seront
+# de longueur 1 également
 length(factor("male")) # 1
 length(levels(factor("male"))) # 1
-# On rencontre communément des facteurs dans des trames de données, 
-# une structure de données que nous couvrirons plus tard
+# On rencontre communément des facteurs dans des "data frame",
+# un type de données que nous couvrirons plus tard
 data(infert) # "Infertility after Spontaneous and Induced Abortion"
 levels(infert$education) # "0-5yrs"  "6-11yrs" "12+ yrs"
 
 # NULL
 # "NULL" est bizarre ; on l'utilise pour effacer un vecteur
 class(NULL)	# NULL
+parakeet = c("beak", "feathers", "wings", "eyes")
 parakeet
 # =>
-# [1] "beak"     "feathers" "wings"    "eyes"    
+# [1] "beak"     "feathers" "wings"    "eyes"
 parakeet <- NULL
 parakeet
 # =>
 # NULL
 
 # LES CONTRAINTES DE TYPES
-# Les contraintes de types servent à forcer une valeur à prendre un type différent
+# Les contraintes de types servent à forcer une valeur à prendre
+# un type différent
 as.character(c(6, 8)) # "6" "8"
 as.logical(c(1,0,1,1)) # TRUE FALSE  TRUE  TRUE
-# Si vous mettez des éléments de différents types dans un vecteur, des coercitions bizarres se produisent :
+# Si vous mettez des éléments de différents types dans un vecteur,
+# des coercitions bizarres se produisent :
 c(TRUE, 4) # 1 4
 c("dog", TRUE, 4) # "dog"  "TRUE" "4"
 as.numeric("Bilbo")
@@ -294,17 +304,19 @@ as.numeric("Bilbo")
 # NAs est introduit par coercition
 
 # Notez également : ce n'étaient que des types de données basiques
-# Il y a beaucoup d'autres types de données, comme pour les dates, les séries de temps, etc ...
+# Il y a beaucoup d'autres types de données, comme pour les dates,
+# les séries temporelles, etc ...
 
 
 
-##################################################
+#######################################
 # Variables, boucles , if/else
-##################################################
+#######################################
 
-# Une variable est comme une boîte où l'on garde une valeur pour l'utiliser plus tard.
+# Une variable est comme une boîte dans laquelle on garde une valeur
+# pour l'utiliser plus tard.
 # Nous appellons ça "assigner" une valeur à une variable.
-# Avoir des variables nous permets d'écrire des boucles, des fonctions, et
+# Avoir des variables nous permet d'écrire des boucles, des fonctions, et
 # des instructions conditionnelles (if/else)
 
 # LES VARIABLES
@@ -321,19 +333,22 @@ for (i in 1:4) {
 # Il y a les boucles while :
 a <- 10
 while (a > 4) {
-	cat(a, "...", sep = "")
-	a <- a - 1
+    cat(a, "...", sep = "")
+    a <- a - 1
 }
-# Gardez à l'esprit que les boucles for et while s'exécute lentement en R
-# Des opérations sur des vecteurs entiers (ex un ligne entière, une colonne entière),
-# ou la fonction apply()-type (nous en parlerons plus tard), sont préférés
+# Gardez à l'esprit que les boucles for et while s'exécutent lentement
+# en R
+# Des opérations sur des vecteurs entiers (ex une ligne entière,
+# une colonne entière),
+# ou les fonctions de type apply() (nous en parlerons plus tard),
+# sont préférées
 
 # IF/ELSE
 # Encore une fois assez standard
 if (4 > 3) {
-	print("4 is greater than 3")
+    print("4 is greater than 3")
 } else {
-	print("4 is not greater than 3")
+    print("4 is not greater than 3")
 }
 # =>
 # [1] "4 is greater than 3"
@@ -341,25 +356,27 @@ if (4 > 3) {
 # LES FONCTIONS
 # se définissent comme ceci :
 jiggle <- function(x) {
-	x = x + rnorm(1, sd=.1)	#add in a bit of (controlled) noise
-	return(x)
+    x = x + rnorm(1, sd=.1)	#add in a bit of (controlled) noise
+    return(x)
 }
-# Appelée comme n'importe quelle autre fonction R :
+# Appelées comme n'importe quelles autres fonction R :
 jiggle(5)	# 5±ε. After set.seed(2716057), jiggle(5)==5.005043
 
 
 
-###########################################################################
-# Les structures de données : les vecteurs, les matrices, les trames de données et les tableaux
-###########################################################################
+##########################################################################
+# Les structures de données : les vecteurs, les matrices,
+# les data frame et les tableaux
+##########################################################################
 
 # À UNE DIMENSION
 
-# Commençons par le tout début, et avec quelque chose que vous connaissez déjà : les vecteurs.
+# Commençons par le tout début, et avec quelque chose que
+# vous connaissez déjà : les vecteurs.
 vec <- c(8, 9, 10, 11)
 vec	#  8  9 10 11
 # Nous demandons des éléments spécifiques en les mettant entre crochets
-# (Notez que R commence à compter par 1)
+# (Notez que R commence à compter à partir de 1)
 vec[1]		# 8
 letters[18]	# "r"
 LETTERS[13]	# "M"
@@ -367,7 +384,7 @@ month.name[9]	# "September"
 c(6, 8, 7, 5, 3, 0, 9)[3]	# 7
 # Nous pouvons également rechercher des indices de composants spécifiques,
 which(vec %% 2 == 0)	# 1 3
-# Récupèrer seulement quelques premières ou dernières entrées du vecteur,
+# Récupèrer seulement les premières ou dernières entrées du vecteur,
 head(vec, 1)	# 8
 tail(vec, 2)	# 10 11
 # ou trouver si un certaine valeur est dans le vecteur
@@ -376,7 +393,8 @@ any(vec == 10) # TRUE
 vec[6]	# NA
 # Vous pouvez trouver la longueur de votre vecteur avec length()
 length(vec)	# 4
-# Vous pouvez réaliser des opérations sur des vecteurs entiers ou des sous-ensembles de vecteurs
+# Vous pouvez réaliser des opérations sur des vecteurs entiers ou des
+# sous-ensembles de vecteurs
 vec * 4	# 16 20 24 28
 vec[2:3] * 5	# 25 30
 any(vec[2:3] == 8) # FALSE
@@ -396,7 +414,7 @@ seq(from=0, to=31337, by=1337)
 
 # À DEUX DIMENSIONS (TOUT DANS UNE CLASSE)
 
-# Vous pouvez faire une matrice de toutes les entrées du même type comme ceci :
+# Vous pouvez créer une matrice à partir d'entrées du même type comme ceci :
 mat <- matrix(nrow = 3, ncol = 2, c(1,2,3,4,5,6))
 mat
 # =>
@@ -404,13 +422,14 @@ mat
 # [1,]    1    4
 # [2,]    2    5
 # [3,]    3    6
-# Différemment du vecteur, la classe d'une matrice est "matrix",peut importe ce qu'elle contient
+# Différemment du vecteur, la classe d'une matrice est "matrix",
+# peut importe ce qu'elle contient
 class(mat) # => "matrix"
 # Demander la première ligne
 mat[1,]	# 1 4
 # Réaliser une opération sur la première colonne
 3 * mat[,1]	# 3 6 9
-# Ask for a specific cell
+# Demander une cellule spécifique
 mat[3,2]	# 6
 
 # Transposer la matrice entière
@@ -432,15 +451,15 @@ mat %*% t(mat)
 mat2 <- cbind(1:4, c("dog", "cat", "bird", "dog"))
 mat2
 # =>
-#      [,1] [,2]   
-# [1,] "1"  "dog"  
-# [2,] "2"  "cat"  
-# [3,] "3"  "bird" 
+#      [,1] [,2]
+# [1,] "1"  "dog"
+# [2,] "2"  "cat"
+# [3,] "3"  "bird"
 # [4,] "4"  "dog"
 class(mat2)	# matrix
-# Encore une fois notez ce qui se passe !
-# Parce que les matrices peuvent contenir des entrées de toutes sortes de classes,
-# tout sera converti en classe caractère
+# Encore une fois regardez ce qui se passe !
+# Parce que les matrices peuvent contenir des entrées de toutes sortes de
+# classes, tout sera converti en classe caractère
 c(class(mat2[,1]), class(mat2[,2]))
 
 # rbind() colle des vecteurs ensemble par lignes pour faire une matrice
@@ -454,7 +473,7 @@ mat3
 
 # À DEUX DIMENSIONS (DE CLASSES DIFFÉRENTES)
 
-# Pour des colonnes de différents types, utiliser une trame de donnée
+# Pour des colonnes de différents types, utiliser une data frame
 # Cette structure de données est si utile pour la programmation statistique,
 # qu'une version a été ajoutée à Python dans le paquet "pandas".
 
@@ -478,25 +497,25 @@ class(students[,3])	# "factor"
 nrow(students)	# 6
 ncol(students)	# 3
 dim(students)	# 6 3
-# La fonction data.frame() convertit les vecteurs caractères en vecteurs de facteurs
-# par défaut; désactiver cette fonction en règlant stringsAsFactors = FALSE
-# quand vous créer la data.frame
+# La fonction data.frame() convertit les vecteurs caractères en vecteurs de
+# facteurs par défaut; désactiver cette fonction en règlant
+# stringsAsFactors = FALSE quand vous créer la data.frame
 ?data.frame
 
-# Il y a plusieurs façons tortueuses de subdiviser les trames de données
+# Il y a plusieurs façons de subdiviser les trames de données
 # toutes subtilement différentes
 students$year	# 3  2  2  1  0 -1
 students[,2]	# 3  2  2  1  0 -1
 students[,"year"]	# 3  2  2  1  0 -1
 
 # Une version augmentée de la structure data.frame est data.table
-# Si vous travaillez avec des données volumineuses ou des panels, ou avez 
+# Si vous travaillez avec des données volumineuses ou des panels, ou avez
 # besoin de fusionner quelques ensembles de données, data.table peut être
 # un bon choix. Ici un tour éclair :
-install.packages("data.table") # download the package from CRAN
-require(data.table) # load it
+install.packages("data.table") # télécharge le paquet depuis CRAN
+require(data.table) # le charge
 students <- as.data.table(students)
-students # note the slightly different print-out
+students # regardez la différence à l'impression
 # =>
 #      name year house
 # 1: Cedric    3     H
@@ -505,17 +524,17 @@ students # note the slightly different print-out
 # 4:    Cho    1     R
 # 5:  Draco    0     S
 # 6:  Ginny   -1     G
-students[name=="Ginny"] # get rows with name == "Ginny"
+students[name=="Ginny"] # obtiens les lignes avec name == "Ginny"
 # =>
 #     name year house
 # 1: Ginny   -1     G
-students[year==2] # get rows with year == 2
+students[year==2] # obtiens les lignes avec year == 2
 # =>
 #      name year house
 # 1:   Fred    2     G
 # 2: George    2     G
 # data.table facilite la fusion entre deux ensembles de données
-# Faisons un autre data.table pour fusionner students
+# Faisons une autre data.table pour fusionner students
 founders <- data.table(house=c("G","H","R","S"),
                        founder=c("Godric","Helga","Rowena","Salazar"))
 founders
@@ -527,7 +546,7 @@ founders
 # 4:     S Salazar
 setkey(students, house)
 setkey(founders, house)
-students <- founders[students] # merge the two data sets by matching "house"
+students <- founders[students] # merge les deux ensembles de données qui matchent "house"
 setnames(students, c("house","houseFounderName","studentName","year"))
 students[,order(c("name","year","house","houseFounderName")), with=F]
 # =>
@@ -539,7 +558,7 @@ students[,order(c("name","year","house","houseFounderName")), with=F]
 # 5:         Cho    1     R           Rowena
 # 6:       Draco    0     S          Salazar
 
-# data.table facilite le sommaire des tableaux
+# data.table facilite le résumé des tableaux
 students[,sum(year),by=house]
 # =>
 #    house V1
@@ -561,7 +580,7 @@ students
 # 5:         Cho    1     R
 # 6:       Draco    0     S
 
-# Supprimer une ligne en subdivisant 
+# Supprimer une ligne en subdivisant
 # En utilisant data.table :
 students[studentName != "Draco"]
 # =>
@@ -607,16 +626,17 @@ array(c(c(c(2,300,4),c(8,9,0)),c(c(5,60,0),c(66,7,847))), dim=c(3,2,2))
 # [2,]   60    7
 # [3,]    0  847
 
-# LES LISTES (MULTI-DIMENSIONNELLES, ÉVENTUELLEMMENT DÉCHIRÉES, DE DIFFÉRENTS TYPES)
+# LES LISTES (MULTI-DIMENSIONNELLES, ÉVENTUELLEMMENT DÉCHIRÉES,
+# DE DIFFÉRENTS TYPES)
 
 # Enfin R a des listes (de vecteurs)
 list1 <- list(time = 1:40)
 list1$price = c(rnorm(40,.5*list1$time,4)) # random
 list1
 # Vous pouvez obtenir des éléments de la liste comme ceci
-list1$time # one way
-list1[["time"]] # another way
-list1[[1]] # yet another way
+list1$time # une façon
+list1[["time"]] # une autre façon
+list1[[1]] # encore une façon différente
 # =>
 #  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
 # [34] 34 35 36 37 38 39 40
@@ -624,13 +644,14 @@ list1[[1]] # yet another way
 list1$price[4]
 
 # Les listes ne sont pas les structures de données les plus efficaces
-# pour travailler en R;
-# À moins d'avoir une très bonne raison, vous devriez appliquer data.frames
-# Les listes sont souvent retournées par des fonctions qui effectuent des régressions linéaires
+# à utiliser avec R;
+# À moins d'avoir une très bonne raison, vous devriez utiliser data.frames
+# Les listes sont souvent retournées par des fonctions qui effectuent
+# des régressions linéaires
 
-##################################################
+##########################################
 # La famille de fonction apply()
-##################################################
+##########################################
 
 # Vous vous rappelez mat ?
 mat
@@ -641,8 +662,8 @@ mat
 # [3,]    3    6
 # Utilisez apply(X, MARGIN, FUN) pour appliquer la fonction FUN à la matrice X
 # sur les lignes (MAR = 1) ou les colonnes (MAR = 2)
-# R fait FUN à chaque lignes (ou colonnes) de X, beaucoup plus rapidement
-# qu'une bouce for ou while le ferait
+# R exécute FUN à chaque lignes (ou colonnes) de X, beaucoup plus rapidement
+# que le ferait une boucle for ou while
 apply(mat, MAR = 2, jiggle)
 # =>
 #      [,1] [,2]
@@ -650,7 +671,7 @@ apply(mat, MAR = 2, jiggle)
 # [2,]    7   19
 # [3,]   11   23
 # D'autres fonctions : ?lapply, ?sapply
- 
+
 # Ne soyez pas trop intimidé ; tout le monde reconnaît que c'est un peu déroutant
 
 # Le paque plyr vise à remplacer (et améliorer !) la famille *apply().
@@ -660,9 +681,9 @@ require(plyr)
 
 
 
-#########################
+############################
 # Charger des données
-#########################
+############################
 
 # "pets.csv" est un fichier sur internet
 # (mais il pourrait être tout aussi facilement sur votre ordinateur)
@@ -671,7 +692,7 @@ pets
 head(pets, 2) # first two rows
 tail(pets, 1) # last row
 
-# Pour sauver une trame de donnée ou une matrice en fichier .csv
+# Pour sauvegarder une data frame ou une matrice en fichier .csv
 write.csv(pets, "pets2.csv") # to make a new .csv file
 # définir le répertoire de travail avec setwd(), le récupérer avec getwd()
 
@@ -679,9 +700,9 @@ write.csv(pets, "pets2.csv") # to make a new .csv file
 
 
 
-#########################
+################
 # Les tracés
-#########################
+################
 
 # LES FONCTIONS DE TRACÉS PRÉCONSTRUITES
 # Les diagrammes de dispersion !
@@ -700,7 +721,7 @@ barplot(c(1,4,5,1,2), names.arg = c("red","blue","purple","green","yellow"))
 
 # GGPLOT2
 # Mais ceux-ci ne sont même pas les plus jolis tracés de R
-# Essayez le paquet ggplot2 pour d'avantages de graphiques meilleurs
+# Essayez le paquet ggplot2 pour d'avantages de graphiques
 install.packages("ggplot2")
 require(ggplot2)
 ?ggplot2
@@ -709,13 +730,14 @@ pp + geom_histogram()
 ll <- as.data.table(list1)
 pp <- ggplot(ll, aes(x=time,price))
 pp + geom_point()
-# ggplot2 a une documentation excellente (disponible sur http://docs.ggplot2.org/current/)
+# ggplot2 a une documentation excellente
+#(disponible sur http://docs.ggplot2.org/current/)
 
 
 
 ```
 
-## How do I get R?
+## Comment j'obtiens R ?
 
-* Get R and the R GUI from [http://www.r-project.org/](http://www.r-project.org/)
-* [RStudio](http://www.rstudio.com/ide/) is another GUI
+* Obtiens R et R GUI depuis [http://www.r-project.org/](http://www.r-project.org/)
+* [RStudio](http://www.rstudio.com/ide/) est un autre GUI
-- 
cgit v1.2.3


From a0ca5283d69be29bf7fa26ddd082ff927068883b Mon Sep 17 00:00:00 2001
From: Chtiprog <chtiprog@free.fr>
Date: Mon, 18 May 2015 00:03:52 -0300
Subject: Refactor r french translation

---
 fr-fr/r-fr.html.markdown | 85 +++++++++++++++++++++++++-----------------------
 1 file changed, 44 insertions(+), 41 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/r-fr.html.markdown b/fr-fr/r-fr.html.markdown
index d6879c1f..3f225a0f 100644
--- a/fr-fr/r-fr.html.markdown
+++ b/fr-fr/r-fr.html.markdown
@@ -9,9 +9,9 @@ filename: learnr-fr.r
 ---
 
 R est un langage de programmation statistique. Il dispose de nombreuses
-librairies pour le téléchargement et le nettoyage d'ensembles de données,
+bibliothèques pour le téléchargement et le nettoyage d'ensembles de données,
 l'exécution de procédures statistiques, et la réalisation de graphiques.
-On peut également exécuter les commmandes `R` au sein d'un document LaTeX.
+On peut également exécuter des commmandes `R` au sein d'un document LaTeX.
 
 
 ```r
@@ -19,9 +19,11 @@ On peut également exécuter les commmandes `R` au sein d'un document LaTeX.
 # Les commentaires commencent avec des symboles numériques.
 
 # Il n'est pas possible de faire des commentaires multilignes,
-# mais on peut superposer plusieurs commentaires comme ceci.
+# mais on peut placer plusieurs commentaires les uns en dessous
+# des autres comme ceci.
 
-# Sur Windows ou Mac, taper COMMAND-ENTER pour exécuter une ligne
+# Sur Mac, taper COMMAND-ENTER pour exécuter une ligne
+# et sur Windows taper CTRL-ENTER
 
 
 
@@ -43,7 +45,7 @@ head(rivers)	# donne un aperçu des données
 
 length(rivers)	# Combien de rivers ont été mesurées ?
 # 141
-summary(rivers) # Quels sont les principales données statistiques ?
+summary(rivers) # Quelles sont les principales données statistiques ?
 #   Min. 1st Qu.  Median    Mean 3rd Qu.    Max.
 #  135.0   310.0   425.0   591.2   680.0  3710.0
 
@@ -99,7 +101,7 @@ stem(log(rivers)) # Notez que les données ne sont ni normales
 #  80 |
 #  82 | 2
 
-# Fais un histogramme :
+# Fait un histogramme :
 hist(rivers, col="#333333", border="white", breaks=25) # amusez-vous avec ces paramètres
 hist(log(rivers), col="#333333", border="white", breaks=25) # vous ferez plus de tracés plus tard
 
@@ -110,7 +112,7 @@ plot(discoveries, col="#333333", lwd=3, xlab="Year",
 plot(discoveries, col="#333333", lwd=3, type = "h", xlab="Year",
      main="Number of important discoveries per year")
 
-# Plutôt que de laisser l'ordre par défaut (par années)
+# Plutôt que de laisser l'ordre par défaut (par année)
 # Nous pourrions aussi trier pour voir ce qu'il y a de typique
 sort(discoveries)
 #  [1]  0  0  0  0  0  0  0  0  0  1  1  1  1  1  1  1  1  1  1  1  1  2  2  2  2
@@ -142,7 +144,7 @@ summary(discoveries)
 #   Min. 1st Qu.  Median    Mean 3rd Qu.    Max.
 #    0.0     2.0     3.0     3.1     4.0    12.0
 
-# Lance un dès plusieurs fois
+# Lance un dé plusieurs fois
 round(runif(7, min=.5, max=6.5))
 # 1 4 6 1 4 6 4
 # Vos numéros diffèreront des miens à moins que nous mettions
@@ -164,11 +166,11 @@ rnorm(9)
 # les entiers, les numériques, les caractères, les logiques, et les facteurs.
 
 # LES ENTIERS
-# Les entiers de mémoire longue sont écrit avec L
+# Les entiers de type long sont écrits avec L
 5L # 5
 class(5L) # "integer"
 # (Essayez ?class pour plus d'informations sur la fonction class().)
-# Avec R, chaque valeur seule, comme 5L, est considéré comme
+# Avec R, chaque valeur seule, comme 5L, est considérée comme
 # un vecteur de longueur 1
 length(5L) # 1
 # On peut avoir un vecteur d'entiers avec une longueur > 1 :
@@ -191,7 +193,7 @@ c(3,3,3,2,2,1) # 3 3 3 2 2 1
 class(Inf)	# "numeric"
 class(-Inf)	# "numeric"
 # Vous pouvez utiliser "Inf", par exemple, dans integrate(dnorm, 3, Inf);
-# Ça permet d'éviter des tableaux Z-scores.
+# Ça permet d'éviter de réaliser une table de la loi normale.
 
 # ARITHMÉTIQUES DE BASE
 # Vous pouvez faire de l'arithmétique avec des nombres
@@ -233,7 +235,7 @@ letters
 # [20] "t" "u" "v" "w" "x" "y" "z"
 month.abb # "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec"
 
-# LES TYPES LOGIQUES
+# LES TYPES BOOLÉENS
 # En R, un "logical" est un booléen
 class(TRUE)	# "logical"
 class(FALSE)	# "logical"
@@ -256,15 +258,16 @@ c('Z', 'o', 'r', 'r', 'o') == "Zorro" # FALSE FALSE FALSE FALSE FALSE
 c('Z', 'o', 'r', 'r', 'o') == "Z" # TRUE FALSE FALSE FALSE FALSE
 
 # LES FACTEURS
-# La classe facteur sert pour les données catégorielles
-# les facteurs peuvent être ordonnés (comme les niveaux de
-# catégorie d'enfants)
-# ou non ordonnés (comme le sexe)
+# Les facteurs sont généralement utilisés pour y stocker des
+# variables qualitatives (catégorielles).
+# Les facteurs peuvent être ordonnés (comme le niveau scolaire
+# des enfants) ou non ordonnés (comme le sexe)
 factor(c("female", "female", "male", NA, "female"))
 #  female female male   <NA>   female
 # Les niveaux : female male
-# Les "levels" sont les valeurs que les données catégorielles
-# peuvent prendre
+# Les facteurs possèdent un attribut appelé niveau ("level").
+# Les niveaux sont des vecteurs contenant toutes les valeurs
+# que peuvent prendre les données catégorielles.
 # Notez que les données manquantes n'entrent pas dans le niveau
 levels(factor(c("male", "male", "female", NA, "female"))) # "female" "male"
 # Si le vecteur de facteurs a une longueur 1, ses niveaux seront
@@ -288,8 +291,8 @@ parakeet
 # =>
 # NULL
 
-# LES CONTRAINTES DE TYPES
-# Les contraintes de types servent à forcer une valeur à prendre
+# LES CONVERSIONS DE TYPES
+# Les conversions de types servent à forcer une valeur à prendre
 # un type différent
 as.character(c(6, 8)) # "6" "8"
 as.logical(c(1,0,1,1)) # TRUE FALSE  TRUE  TRUE
@@ -304,7 +307,7 @@ as.numeric("Bilbo")
 # NAs est introduit par coercition
 
 # Notez également : ce n'étaient que des types de données basiques
-# Il y a beaucoup d'autres types de données, comme pour les dates,
+# Il y a beaucoup d'autres types de données, comme les dates,
 # les séries temporelles, etc ...
 
 
@@ -321,7 +324,7 @@ as.numeric("Bilbo")
 
 # LES VARIABLES
 # Beaucoup de façons d'assigner des choses :
-x = 5 # c'est possible
+x = 5 # c'est correct
 y <- "1" # c'est préféré
 TRUE -> z # ça marche mais c'est bizarre
 
@@ -337,11 +340,11 @@ while (a > 4) {
     a <- a - 1
 }
 # Gardez à l'esprit que les boucles for et while s'exécutent lentement
-# en R
-# Des opérations sur des vecteurs entiers (ex une ligne entière,
+# en R.
+# Des opérations sur la totalité d'un vecteur (ex une ligne entière,
 # une colonne entière),
 # ou les fonctions de type apply() (nous en parlerons plus tard),
-# sont préférées
+# sont préférées.
 
 # IF/ELSE
 # Encore une fois assez standard
@@ -356,7 +359,7 @@ if (4 > 3) {
 # LES FONCTIONS
 # se définissent comme ceci :
 jiggle <- function(x) {
-    x = x + rnorm(1, sd=.1)	#add in a bit of (controlled) noise
+    x = x + rnorm(1, sd=.1)	# ajoute un peu de bruit (contrôlé)
     return(x)
 }
 # Appelées comme n'importe quelles autres fonction R :
@@ -366,7 +369,7 @@ jiggle(5)	# 5±ε. After set.seed(2716057), jiggle(5)==5.005043
 
 ##########################################################################
 # Les structures de données : les vecteurs, les matrices,
-# les data frame et les tableaux
+# les data frames et les tableaux
 ##########################################################################
 
 # À UNE DIMENSION
@@ -387,7 +390,7 @@ which(vec %% 2 == 0)	# 1 3
 # Récupèrer seulement les premières ou dernières entrées du vecteur,
 head(vec, 1)	# 8
 tail(vec, 2)	# 10 11
-# ou trouver si un certaine valeur est dans le vecteur
+# ou vérifier si un certaine valeur est dans le vecteur
 any(vec == 10) # TRUE
 # Si un index "dépasse" vous obtiendrez NA :
 vec[6]	# NA
@@ -398,7 +401,7 @@ length(vec)	# 4
 vec * 4	# 16 20 24 28
 vec[2:3] * 5	# 25 30
 any(vec[2:3] == 8) # FALSE
-# Et R a beaucoup de fonctions préconstruites pour résumer les vecteurs
+# Et R a beaucoup de méthodes statistiques pré-construites pour les vecteurs :
 mean(vec)	# 9.5
 var(vec)	# 1.666667
 sd(vec)		# 1.290994
@@ -425,7 +428,7 @@ mat
 # Différemment du vecteur, la classe d'une matrice est "matrix",
 # peut importe ce qu'elle contient
 class(mat) # => "matrix"
-# Demander la première ligne
+# Récupérer la première ligne
 mat[1,]	# 1 4
 # Réaliser une opération sur la première colonne
 3 * mat[,1]	# 3 6 9
@@ -502,13 +505,13 @@ dim(students)	# 6 3
 # stringsAsFactors = FALSE quand vous créer la data.frame
 ?data.frame
 
-# Il y a plusieurs façons de subdiviser les trames de données
+# Il y a plusieurs façons de subdiviser les data frames,
 # toutes subtilement différentes
 students$year	# 3  2  2  1  0 -1
 students[,2]	# 3  2  2  1  0 -1
 students[,"year"]	# 3  2  2  1  0 -1
 
-# Une version augmentée de la structure data.frame est data.table
+# Une version améliorée de la structure data.frame est data.table.
 # Si vous travaillez avec des données volumineuses ou des panels, ou avez
 # besoin de fusionner quelques ensembles de données, data.table peut être
 # un bon choix. Ici un tour éclair :
@@ -601,15 +604,15 @@ students[students$house != "G",]
 
 # MULTI-DIMENSIONNELLE (TOUS ÉLÉMENTS D'UN TYPE)
 
-# Les arrays créent des tableaux de n dimensions
-# Tous les éléments doivent être du même type
+# Les arrays créent des tableaux de n dimensions.
+# Tous les éléments doivent être du même type.
 # Vous pouvez faire un tableau à 2 dimensions (une sorte de matrice)
 array(c(c(1,2,4,5),c(8,9,3,6)), dim=c(2,4))
 # =>
 #      [,1] [,2] [,3] [,4]
 # [1,]    1    4    8    3
 # [2,]    2    5    9    6
-# Vous pouvez utiliser array pour faire des matrices à 3 dimensions aussi
+# Vous pouvez aussi utiliser array pour faire des matrices à 3 dimensions :
 array(c(c(c(2,300,4),c(8,9,0)),c(c(5,60,0),c(66,7,847))), dim=c(3,2,2))
 # =>
 # , , 1
@@ -629,7 +632,7 @@ array(c(c(c(2,300,4),c(8,9,0)),c(c(5,60,0),c(66,7,847))), dim=c(3,2,2))
 # LES LISTES (MULTI-DIMENSIONNELLES, ÉVENTUELLEMMENT DÉCHIRÉES,
 # DE DIFFÉRENTS TYPES)
 
-# Enfin R a des listes (de vecteurs)
+# Enfin, R a des listes (de vecteurs)
 list1 <- list(time = 1:40)
 list1$price = c(rnorm(40,.5*list1$time,4)) # random
 list1
@@ -644,10 +647,10 @@ list1[[1]] # encore une façon différente
 list1$price[4]
 
 # Les listes ne sont pas les structures de données les plus efficaces
-# à utiliser avec R;
+# à utiliser avec R ;
 # À moins d'avoir une très bonne raison, vous devriez utiliser data.frames
 # Les listes sont souvent retournées par des fonctions qui effectuent
-# des régressions linéaires
+# des régressions linéaires.
 
 ##########################################
 # La famille de fonction apply()
@@ -674,7 +677,7 @@ apply(mat, MAR = 2, jiggle)
 
 # Ne soyez pas trop intimidé ; tout le monde reconnaît que c'est un peu déroutant
 
-# Le paque plyr vise à remplacer (et améliorer !) la famille *apply().
+# Le paquet plyr vise à remplacer (et améliorer !) la famille *apply().
 install.packages("plyr")
 require(plyr)
 ?plyr
@@ -704,7 +707,7 @@ write.csv(pets, "pets2.csv") # to make a new .csv file
 # Les tracés
 ################
 
-# LES FONCTIONS DE TRACÉS PRÉCONSTRUITES
+# LES FONCTIONS DE TRACÉ PRÉCONSTRUITES
 # Les diagrammes de dispersion !
 plot(list1$time, list1$price, main = "fake data")
 # Les régressions !
@@ -737,7 +740,7 @@ pp + geom_point()
 
 ```
 
-## Comment j'obtiens R ?
+## Comment obtenir R ?
 
 * Obtiens R et R GUI depuis [http://www.r-project.org/](http://www.r-project.org/)
 * [RStudio](http://www.rstudio.com/ide/) est un autre GUI
-- 
cgit v1.2.3


From 1aa91a6420b17d6d982fb3361ba938511355fc7c Mon Sep 17 00:00:00 2001
From: Julien Cretel <j.cretel@umail.ucc.ie>
Date: Thu, 28 May 2015 20:40:39 +0200
Subject: [erlang/fr] Add french translation

---
 fr-fr/erlang-fr.html.markdown | 325 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 325 insertions(+)
 create mode 100644 fr-fr/erlang-fr.html.markdown

(limited to 'fr-fr')

diff --git a/fr-fr/erlang-fr.html.markdown b/fr-fr/erlang-fr.html.markdown
new file mode 100644
index 00000000..564e176f
--- /dev/null
+++ b/fr-fr/erlang-fr.html.markdown
@@ -0,0 +1,325 @@
+---
+language: erlang
+contributors:
+    - ["Giovanni Cappellotto", "http://www.focustheweb.com/"]
+translators:
+    - ["Julien Cretel", "https://github.com/Jubobs"]
+filename: learnerlang-fr.erl
+lang: fr-fr
+---
+
+```erlang
+% Un signe pour cent marque le début d'un commentaire de fin de ligne.
+
+%% Deux signes pour cent sont utilisés pour commenter les fonctions.
+
+%%% Trois signes pour cent sont utilisés pour commenter les modules.
+
+% Trois types de ponctuation sont utilisés en Erlang.
+% Les virgules (`,`) servent à séparer les paramètres dans les appels de
+% fonctions, les contructeurs, et les motifs.
+% Les points (`.`) (suivis par des caractères blancs) servent à séparer
+% les fonctions et les expressions dans l'interpréteur.
+% Les points-virgules (`;`) servent à séparer les clauses. Ces dernières
+% apparaissent dans différent cas de figure : définitions de fonctions et
+% expressions `case`, `if`, `try..catch`, et `receive`.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% 1. Variables et filtrage par motif.
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+Nb = 42.  % Chaque nom de variable doit commencer par une lettre majuscule.
+
+% Les variables Erlang ne peuvent être affectées qu'une seule fois ; si vous
+% essayez d'affecter une autre valeur à la variable `Nb`, vous obtiendrez
+% une erreur.
+Nb = 43. % ** exception error: no match of right hand side value 43
+
+% Dans la plupart des languages, `=` indique une affectation. En Erlang,
+% cependant, `=` indique un filtrage par motif. En fait, `Gauche = Droit`
+% signifie ce qui suit : évalue le côté droit (`Droit`), et ensuite filtre le
+% résultat à l'aide du motif du côté gauche (`Gauche`).
+Nb = 7 * 6.
+
+% Nombre en virgule flottante.
+Pi = 3.14159.
+
+% Les atomes représentent des valeurs constantes non-numériques. Un atome
+% commence par une lettre minuscule, suivie d'une séquence composée de
+% caractères alphanumériques, de tirets bas (`_`), ou d'arobases (`@`).
+Bonjour = bonjour.
+AutreNoeud = exemple@noeud.
+
+% Les atomes de valeur autre qu'alphanumérique peuvent être délimités par
+% des guillemets droits simples.
+AtomeAvecEspace = 'un atome contenant des espaces'.
+
+% Les tuples sont similaires aux enregistrements du language C.
+Point = {point, 10, 45}.
+
+% Pour extraire des valeurs d'un tuple, on filtre par motif avec
+% l'opérateur `=`.
+{point, X, Y} = Point.  % X = 10, Y = 45
+
+% On peut utiliser `_` comme caractère joker pour les variables qui ne nous
+% intéressent pas. Le symbol `_` est appelé variable muette. Contrairement
+% aux variables normales, de multiples apparitions de `_` dans un même motif
+% ne lient pas nécessairement à la même valeur.
+Personne = {personne, {nom, {prenom, joe}, {famille, armstrong}},
+                      {pointure, 42}}.
+{_, {_, {_, Qui}, _}, _} = Personne.  % Qui = joe
+
+% Pour créer une liste, on écrit les éléments de la liste entre crochets, en
+% les séparant par des virgules.
+% Les éléments d'une liste peuvent avoir n'importe quel type.
+% Le premier élément d'une liste est appelé la tête de la liste. Si on retire
+% la tête d'une liste, ce qui reste est appelée la queue de la liste.
+Articles = [{pommes, 10}, {poires, 6}, {lait, 3}].
+
+% Si `Q` est une liste, alors `[T|Q]` est aussi une liste dont la tête est `T`
+% et dont la queue est `Q`. La barre verticale (`|`) sépare la tête d'une
+% liste de sa queue.
+% `[]` est la liste vide.
+% On peut extraire des éléments d'une liste par filtrage de motif. Si `L` est
+% une liste non vide, alors l'expression `[X|Y] = L`, où `X` et `Y` sont des
+% variables non affectées, va extraire la tête de la liste dans `X` et la
+% queue de la liste dans `Y`.
+[PremierArticle|AutresArticles] = Articles.
+% PremierArticle = {pommmes, 10}
+% AutresArticles = [{poires, 6}, {lait, 3}]
+
+% Il n'y a pas de chaînes de caractères en Erlang. Les chaînes de caractères
+% ne sont rien de plus que des listes d'entiers.
+% Les chaînes de caractères sont délimitées par des guillemets droits doubles
+% (`"`).
+Nom = "Bonjour".
+[66, 111, 110, 106, 111, 117, 114] = "Bonjour".
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% 2. Programmation séquentielle.
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+% Les modules constituent l'unité de base d'un programme Erlang. Toutes les
+% fonctions que l'on écrit sont sauvées dans des modules. Les modules sont
+% enregistrés dans des fichiers avec une extension `.erl`.
+% Les modules doivent être compilés afin d'éxecuter le programme.
+% Un module compilé a une extension `.beam`.
+-module(geometrie).
+-export([aire/1]). % la liste des fonctions exportées par le module.
+
+% La fonction `aire` est composée de deux clauses. Les clauses sont séparées
+% par un point-virgule, et la dernière clause est suivie d'un point et un
+% espace blanc. Chaque clause a une en-tête et un corps ; l'en-tête consiste
+% en un nom de fonction suivi d'un motif (entre parenthèses), et le corps
+% consiste en une séquence d'expressions, qui sont évaluées si le motif de
+% l'en-tête est cohérent par rapport à la valeur des paramètres d'appel.
+% L'expression est filtrée séquentiellement par les différents motifs, dans
+% l'ordre dans lequel ils apparaissent dans la définition de la fonction.
+aire({rectangle, Largeur, Hauteur}) -> Largeur * Hauteur;
+aire({cercle, R})                   -> 3.14159 * R * R.
+
+% Compilation du code du fichier geometrie.erl.
+c(geometrie).  % {ok,geometrie}
+
+% Le nom du module doit être inclus avec le nom de la fonction afin
+% d'identifier précisément quelle fonction on souhaite appeler.
+geometrie:aire({rectangle, 10, 5}).  % 50
+geometrie:area({cercle, 1.4}).  % 6.15752
+
+% En Erlang, deux fonctions portant le même nom mais ayant des arités
+% différentes (c'est à dire ne prenant pas le même nombre de paramètres)
+% au sein d'un même module représentent des fonctions complètement
+% différentes.
+-module(lib_divers).
+-export([somme/1]). % exporte la fonction `somme` d'arité 1
+                    % acceptant un paramètre : une liste d'entiers.
+somme(L) -> somme(L, 0).
+somme([], N)    -> N;
+somme([T|Q], N) -> somme(Q, T+N).
+
+% Les funs sont des fonctions "anonymes" ; elles sont appelées ainsi parce
+% qu'elles n'ont pas de noms. Cependant, elles peuvent être affectées à des
+% variables.
+Doubler = fun(X) -> 2 * X end. % `Doubler` pointe vers une fonction anonyme
+                               % dont le handle est : #Fun<erl_eval.6.17052888>
+Doubler(2).  % 4
+
+% Les fonctions peuvent prendre des funs comme paramètres et peuvent renvoyer
+% des funs.
+Mult = fun(Fois) -> ( fun(X) -> X * Fois end ) end.
+Tripler = Mult(3).
+Tripler(5).  % 15
+
+% Les listes en compréhension sont des expressions qui créent des listes sans
+% requérir ni funs, ni maps, ni filters.
+% La notation `[F(X) || X <- L]` signifie "la liste des `F(X)` où `X` est
+% extrait de la liste `L`."
+L = [1,2,3,4,5].
+[2 * X || X <- L].  % [2,4,6,8,10]
+% Une liste en compréhension peut avoir des générateurs, ainsi que des gardes,
+% qui sélectionnent un sous-ensemble des valeurs générées.
+NombresPairs = [N || N <- [1, 2, 3, 4], N rem 2 == 0]. % [2, 4]
+
+% La garde est un élément syntaxique qui rend le filtrage par motif encore
+% plus puissant. Les gardes permettent de d'effectuer de simple tests et
+% comparaisons sur les variables d'un motif. Les gardes peuvent être
+% utilisées dans les en-têtes de fonctions, au sein desquelles elles sont
+% introduites par le mot-clé `when`, ou encore à n'importe quel endroit où
+% une expression est autorisée.
+max(X, Y) when X > Y -> X;
+max(X, Y) -> Y.
+
+% Une garde est une série d'expressions gardes, séparées par des virgules (`,`).
+% La garde `ExprGarde1, ExprGarde2, ..., ExprGardeN` est vraie si toutes les
+% expressions gardes `ExprGarde1`, `ExprGarde2, ..., `ExprGardeN` ont pour
+% valeur `true`.
+est_chat(A) when is_atom(A), A =:= chat -> true;
+est_chat(A) -> false.
+est_chien(A) when is_atom(A), A =:= chien -> true;
+est_chien(A) -> false.
+
+% Une séquence de gardes est composée soit d'une seule garde ou bien d'une
+% série de gardes, séparées par des points-virgules (`;`). La séquence de
+% gardes `G1; G2; ...; Gn` est vraie si au moins l'une des gardes `G1`, `G2`,
+% ..., `Gn` a pour valeur `true`.
+est_animal(A) when is_atom(A), (A =:= chien) or (A =:= chat) -> true;
+est_animal(A)                                                -> false.
+
+% Attention : les expressions Erlang valides ne peuvent pas toutes être
+% utilisées comme expressions gardes ; en particulier, nos fonctions
+% `est_chat` et `est_chien` ne sont pas autorisées au sein de la séquence de
+% gardes dans la définition de `est_animal`. Pour plus de détails sur les
+% expressions autorisées ands les séquences de gardes, voir cette
+% [section](http://erlang.org/doc/reference_manual/expressions.html#id81912)
+% du manuel Erlang.
+
+% Les enregistrements permettent d'associer un nom à un certain élément dans
+% un tuple.
+% Les enregistrements peuvent être définis dans des fichiers sources Erlang
+% ou bien dans des fichiers avec une extension `.hrl`, qui sont ensuite inclus
+% dans des fichiers sources Erlang.
+-record(afaire, {
+  statut = rappel,  % Valeur par défaut
+  qui = joe,
+  texte
+}).
+
+% Les définitions d'enregistrements doivent être lues dans l'interpreteur
+% pour qu'on puisse définir un enregistrement. On utilise la fonction `rr`
+% (abbréviation de *read records* en anglais, ou *lire enregistrements* en
+% français) pour ça.
+rr("enregistrements.hrl").  % [afaire]
+
+% Création et mise à jour d'enregistrements :
+X = #afaire{}.
+% #afaire{statut = rappel, qui = joe, texte = undefined}
+X1 = #afaire{statut = urgent, texte = "Corriger erreurs dans livre"}.
+% #afaire{statut = urgent, qui = joe, texte = "Corriger erreurs dans livre"}
+X2 = X1#afaire{statut = fini}.
+% #afaire{statut = fini, qui = joe, texte = "Corriger erreurs dans livre"}
+
+% Expressions `case`.
+% `filter` renvoie une liste de tous les éléments `X` d'une liste `L` pour
+% lesquels `P(X)` est vrai.
+filter(P, [H|T]) ->
+  case P(H) of
+    true -> [H|filter(P, T)];
+    false -> filter(P, T)
+  end;
+filter(P, []) -> [].
+filter(fun(X) -> X rem 2 == 0 end, [1, 2, 3, 4]). % [2, 4]
+
+% Expressions `if`.
+max(X, Y) ->
+  if
+    X > Y -> X;
+    X < Y -> Y;
+    true -> nil
+  end.
+
+% Attention : au moins l'une des gardes dans l'expression `if` doit avoir pour
+% valeur `true` ; autrement, une exception sera lancée.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% 3. Exceptions.
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+% Des exceptions sont lancées par le système quand des erreurs internes
+% surviennent, ou de manière explicite dans le programme en appelant
+% `throw(Exception)`, `exit(Exception)`, ou `erlang:error(Exception)`.
+generer_exception(1) -> a;
+generer_exception(2) -> throw(a);
+generer_exception(3) -> exit(a);
+generer_exception(4) -> {'EXIT', a};
+generer_exception(5) -> erlang:error(a).
+
+% Erlang dispose de deux méthodes pour capturer une exception. La première
+% consiste à inclure l'appel de de la fonction qui lance l'exception dans une
+% expression `try...catch`.
+catcher(N) ->
+  try generer_exception(N) of
+    Val -> {N, normal, Val}
+  catch
+    throw:X -> {N, caught, thrown, X};
+    exit:X -> {N, caught, exited, X};
+    error:X -> {N, caught, error, X}
+  end.
+
+% L'autre méthode consiste à inclure l'appel dans une expression `catch`.
+% Quand une exception est capturée, elle est convertie en un tuple qui décrit
+% l'erreur.
+catcher(N) -> catch generer_exception(N).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% 4. Concurrence
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+% Erlang est basé sur le modèle d'acteur pour la concurrence. Seulement trois
+% opérations sont requises pour écrire des programmes concurrents en Erlang :
+% la création de processus, l'envoi de messages, et la réception de messages.
+
+% Pour démarrer un nouveau processus, on utilise la fonction `spawn`, qui
+% prend une fonction comme paramètre.
+
+F = fun() -> 2 + 2 end. % #Fun<erl_eval.20.67289768>
+spawn(F). % <0.44.0>
+
+% `spawn` renvoie un pid (*process identifier* en anglais, ou *identifiant de
+% processus* en français), qui peut être utilisé pour envoyer des messages au
+% processus en question. Pour passer des messages, on utilise l'opérateur `!`.
+% Pour que cela soit utile, on doit aussi être en mesure de recevoir des
+% messages, ce qui est accompli grâce à une clause `receive` :
+
+-module(calculerGeometrie).
+-compile(export_all).
+calculerAire() ->
+    receive
+      {rectangle, W, H} ->
+        W * H;
+      {cercle, R} ->
+        3.14 * R * R;
+      _ ->
+        io:format("Seule l'aire d'un rectangle / cercle peut etre calculee.")
+    end.
+
+% Compilation du module and création d'un processus qui évalue `calculerAire`
+% dans l'interpréteur.
+c(calculerGeometrie).
+CalculerAire = spawn(calculerGeometrie, calculerAire, []).
+CalculerAire ! {cercle, 2}. % 12.56000000000000049738
+
+% L'interpréteur est lui-même un processus ; on peut utiliser `self` pour
+% obtenir le pid actuel.
+self(). % <0.41.0>
+
+```
+
+## Références
+
+* ["Learn You Some Erlang for great good!"](http://learnyousomeerlang.com/)
+* ["Programming Erlang: Software for a Concurrent World" by Joe Armstrong](http://pragprog.com/book/jaerlang/programming-erlang)
+* [Erlang/OTP Reference Documentation](http://www.erlang.org/doc/)
+* [Erlang - Programming Rules and Conventions](http://www.erlang.se/doc/programming_rules.shtml)
-- 
cgit v1.2.3


From e191446b333856afff0456349edb71da9634f6aa Mon Sep 17 00:00:00 2001
From: Geoff Liu <g@geoffliu.me>
Date: Thu, 11 Jun 2015 17:35:20 -0600
Subject: Add language marking for R

---
 fr-fr/r-fr.html.markdown | 1 +
 1 file changed, 1 insertion(+)

(limited to 'fr-fr')

diff --git a/fr-fr/r-fr.html.markdown b/fr-fr/r-fr.html.markdown
index 3f225a0f..7d30a48d 100644
--- a/fr-fr/r-fr.html.markdown
+++ b/fr-fr/r-fr.html.markdown
@@ -6,6 +6,7 @@ contributors:
 translators:
     - ["Anne-Catherine Dehier", "https://github.com/spellart"]
 filename: learnr-fr.r
+lang: fr-fr
 ---
 
 R est un langage de programmation statistique. Il dispose de nombreuses
-- 
cgit v1.2.3


From 9c6aec3ceb41a207e77a36b3b22b8bcab99fa86d Mon Sep 17 00:00:00 2001
From: Julien Cretel <j.cretel@umail.ucc.ie>
Date: Sun, 14 Jun 2015 13:24:24 +0100
Subject: [erlang/fr] Integrate feedback on PR

---
 fr-fr/erlang-fr.html.markdown | 32 +++++++++++++++++---------------
 1 file changed, 17 insertions(+), 15 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/erlang-fr.html.markdown b/fr-fr/erlang-fr.html.markdown
index 564e176f..55453c56 100644
--- a/fr-fr/erlang-fr.html.markdown
+++ b/fr-fr/erlang-fr.html.markdown
@@ -15,19 +15,21 @@ lang: fr-fr
 
 %%% Trois signes pour cent sont utilisés pour commenter les modules.
 
-% Trois types de ponctuation sont utilisés en Erlang.
+% Trois symboles de ponctuation sont utilisés en Erlang.
 % Les virgules (`,`) servent à séparer les paramètres dans les appels de
 % fonctions, les contructeurs, et les motifs.
-% Les points (`.`) (suivis par des caractères blancs) servent à séparer
-% les fonctions et les expressions dans l'interpréteur.
+% Les points (`.`) (suivis par des blancs) servent à séparer les fonctions et
+% les expressions dans l'interpréteur.
 % Les points-virgules (`;`) servent à séparer les clauses. Ces dernières
 % apparaissent dans différent cas de figure : définitions de fonctions et
-% expressions `case`, `if`, `try..catch`, et `receive`.
+% expressions `case`, `if`, `try..catch`, `receive`.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% 1. Variables et filtrage par motif.
+%% 1. Variables et filtrage par motif
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
+(L'équivalent anglais de *filtrage par motif* est *pattern patching*.)
+
 Nb = 42.  % Chaque nom de variable doit commencer par une lettre majuscule.
 
 % Les variables Erlang ne peuvent être affectées qu'une seule fois ; si vous
@@ -101,7 +103,7 @@ Nom = "Bonjour".
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 % Les modules constituent l'unité de base d'un programme Erlang. Toutes les
-% fonctions que l'on écrit sont sauvées dans des modules. Les modules sont
+% fonctions que l'on écrit sont enregistrées dans des modules. Les modules sont
 % enregistrés dans des fichiers avec une extension `.erl`.
 % Les modules doivent être compilés afin d'éxecuter le programme.
 % Un module compilé a une extension `.beam`.
@@ -138,27 +140,27 @@ somme(L) -> somme(L, 0).
 somme([], N)    -> N;
 somme([T|Q], N) -> somme(Q, T+N).
 
-% Les funs sont des fonctions "anonymes" ; elles sont appelées ainsi parce
-% qu'elles n'ont pas de noms. Cependant, elles peuvent être affectées à des
+% Les `fun`s sont des fonctions "anonymes" ; elles sont appelées ainsi parce
+% qu'elles n'ont pas de nom. Cependant, elles peuvent être affectées à des
 % variables.
 Doubler = fun(X) -> 2 * X end. % `Doubler` pointe vers une fonction anonyme
                                % dont le handle est : #Fun<erl_eval.6.17052888>
 Doubler(2).  % 4
 
-% Les fonctions peuvent prendre des funs comme paramètres et peuvent renvoyer
-% des funs.
+% Les fonctions peuvent prendre des `fun`s comme paramètres et peuvent renvoyer
+% des `fun`s.
 Mult = fun(Fois) -> ( fun(X) -> X * Fois end ) end.
 Tripler = Mult(3).
 Tripler(5).  % 15
 
 % Les listes en compréhension sont des expressions qui créent des listes sans
-% requérir ni funs, ni maps, ni filters.
+% requérir ni `fun`s, ni maps, ni filters.
 % La notation `[F(X) || X <- L]` signifie "la liste des `F(X)` où `X` est
 % extrait de la liste `L`."
 L = [1,2,3,4,5].
 [2 * X || X <- L].  % [2,4,6,8,10]
-% Une liste en compréhension peut avoir des générateurs, ainsi que des gardes,
-% qui sélectionnent un sous-ensemble des valeurs générées.
+% Une liste en compréhension peut être constituée de générateurs, ainsi que de
+% gardes, qui sélectionnent un sous-ensemble des valeurs générées.
 NombresPairs = [N || N <- [1, 2, 3, 4], N rem 2 == 0]. % [2, 4]
 
 % La garde est un élément syntaxique qui rend le filtrage par motif encore
@@ -186,7 +188,7 @@ est_chien(A) -> false.
 est_animal(A) when is_atom(A), (A =:= chien) or (A =:= chat) -> true;
 est_animal(A)                                                -> false.
 
-% Attention : les expressions Erlang valides ne peuvent pas toutes être
+% Attention : toutes les expressions Erlang valides ne peuvent pas être
 % utilisées comme expressions gardes ; en particulier, nos fonctions
 % `est_chat` et `est_chien` ne sont pas autorisées au sein de la séquence de
 % gardes dans la définition de `est_animal`. Pour plus de détails sur les
@@ -317,7 +319,7 @@ self(). % <0.41.0>
 
 ```
 
-## Références
+## Ressources (en anglais)
 
 * ["Learn You Some Erlang for great good!"](http://learnyousomeerlang.com/)
 * ["Programming Erlang: Software for a Concurrent World" by Joe Armstrong](http://pragprog.com/book/jaerlang/programming-erlang)
-- 
cgit v1.2.3


From 6066176a9f5dd7c487bee439ec0db3b4dd9afa46 Mon Sep 17 00:00:00 2001
From: Morgan <morgan.bohn@unistra.fr>
Date: Wed, 8 Jul 2015 10:54:37 +0200
Subject: [livescript/fr] initial commit

---
 fr-fr/livescript-fr.html.markdown | 351 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 351 insertions(+)
 create mode 100644 fr-fr/livescript-fr.html.markdown

(limited to 'fr-fr')

diff --git a/fr-fr/livescript-fr.html.markdown b/fr-fr/livescript-fr.html.markdown
new file mode 100644
index 00000000..0ed9763b
--- /dev/null
+++ b/fr-fr/livescript-fr.html.markdown
@@ -0,0 +1,351 @@
+---
+language: LiveScript
+filename: learnLivescript-fr.ls
+contributors:
+    - ["Christina Whyte", "http://github.com/kurisuwhyte/"]
+    - ["Morgan Bohn", "https://github.com/morganbohn"]
+lang: fr-fr
+---
+
+LiveScript est un langage qui se compile en JavaScript. Il a un rapport direct 
+avec JavaScript, et vous permet d'écrire du JavaScript de façon considérables 
+sans répétitivité. LiveScript ajoute non seulement des fonctionnalités pour 
+écrire du code fonctionnel, mais possède aussi nombre d'améliorations pour la 
+programmation orientée objet et la programmation impérative.
+
+LiveScript est un descendant indirect de [CoffeeScript][], direct de [Coco][] 
+avec beaucoup plus de compatibilité.
+
+[Coco]: http://satyr.github.io/coco/
+[CoffeeScript]: http://coffeescript.org/
+
+Vous pouvez contacter l'auteur du guide original en anglais ici :
+[@kurisuwhyte](https://twitter.com/kurisuwhyte)
+
+
+```coffeescript
+# Comme son cousin CoffeeScript, LiveScript utilise le symbole dièse pour les 
+# commentaires sur une ligne.
+
+/*
+ Les commentaires sur plusieurs lignes utilisent la syntaxe du C. Utilisez-les
+ si vous voulez préserver les commentaires dans la sortie JavaScript.
+ */
+```
+```coffeescript
+# LiveScript utilise l'indentation pour délimiter les blocs de code plutôt que 
+# les accolades, et les espaces pour appliquer les fonctions, plutôt que les 
+# parenthèses.
+
+
+########################################################################
+## 1. Valeurs basiques
+########################################################################
+
+# Les valeurs non définies sont représentées par le mot clé `void` à la place de
+# `undefined`
+void            # comme `undefined` mais plus sûr (ne peut pas être redéfini)
+
+# Une valeur non valide est représentée par Null.
+null
+
+
+# Les booléens se déclarent de la façon suivante:
+true
+false
+
+# Et il existe divers alias les représentant également:
+on; off
+yes; no
+
+
+# Puis viennent les nombres entiers et décimaux.
+10
+0.4     # Notez que le `0` est requis
+
+# Dans un souci de lisibilité, vous pouvez utiliser les tirets bas et les 
+# suffixes sur les nombres. Il seront ignorés à la compilation.
+12_344km
+
+
+# Les chaînes sont des séquences immutables de caractères, comme en JS:
+"Christina"             # Les apostrophes fonctionnent également!
+"""Multi-line
+   strings
+   are
+   okay
+   too."""
+
+# De temps à autre, vous voulez encoder un mot clé; la notation en backslash 
+# rend cela facile:
+\keyword                # => 'keyword'
+
+
+# Les tableaux sont des collections ordonnées de valeurs.
+fruits =
+  * \apple
+  * \orange
+  * \pear
+
+# Il peuvent être écrits de manière plus consises à l'aide des crochets:
+fruits = [ \apple, \orange, \pear ]
+
+# Vous pouvez également utiliser la syntaxe suivante, à l'aide d'espaces, pour 
+# créer votre liste de valeurs:
+fruits = <[ apple orange pear ]>
+
+# Vous pouvez récupérer une entrée à l'aide de son index:
+fruits[0]       # => "apple"
+
+# Les objets sont une collection non ordonnées de paires clé/valeur, et 
+# d'autres choses (que nous verrons plus tard).
+person =
+  name: "Christina"
+  likes:
+    * "kittens"
+    * "and other cute stuff"
+
+# A nouveau, vous pouvez utiliser une expression plus consise à l'aide des 
+# accolades:
+person = {name: "Christina", likes: ["kittens", "and other cute stuff"]}
+
+# Vous pouvez récupérer une entrée via sa clé:
+person.name     # => "Christina"
+person["name"]  # => "Christina"
+
+
+# Les expressions régulières utilisent la même syntaxe que JavaScript:
+trailing-space = /\s$/          # les mots-composés deviennent motscomposés
+
+# A l'exception que vous pouvez pouvez utiliser des expressions sur plusieurs
+# lignes!
+# (les commentaires et les espaces seront ignorés)
+funRE = //
+        function\s+(.+)         # nom
+        \s* \((.*)\) \s*        # arguments
+        { (.*) }                # corps
+        //
+
+
+########################################################################
+## 2. Les opérations basiques
+########################################################################
+
+# Les opérateurs arithmétiques sont les mêmes que pour JavaScript:
+1 + 2   # => 3
+2 - 1   # => 1
+2 * 3   # => 6
+4 / 2   # => 2
+3 % 2   # => 1
+
+
+# Les comparaisons sont presque identiques, à l'exception que `==` équivaut au
+# `===` de JS, là où le `==` de JS est `~=` en LiveScript, et `===` active la 
+# comparaison d'objets et de tableaux, ainsi que les comparaisons strictes
+2 == 2          # => true
+2 == "2"        # => false
+2 ~= "2"        # => true
+2 === "2"       # => false
+
+[1,2,3] == [1,2,3]        # => false
+[1,2,3] === [1,2,3]       # => true
+
++0 == -0     # => true
++0 === -0    # => false
+
+# Les opérateurs suivants sont également disponibles: <, <=, > et >=
+
+# Les valeurs logiques peuvent être combinéees grâce aux opérateurs logiques 
+# `or`, `and` et `not`
+true and false  # => false
+false or true   # => true
+not false       # => true
+
+
+# Les collections ont également des opérateurs additionnels
+[1, 2] ++ [3, 4]                # => [1, 2, 3, 4]
+'a' in <[ a b c ]>              # => true
+'name' of { name: 'Chris' }     # => true
+
+
+########################################################################
+## 3. Fonctions
+########################################################################        
+
+# Puisque LiveScript est fonctionnel, vous vous attendez à une bonne prise en 
+# charge des fonctions. En LiveScript, il est encore plus évident que les 
+# fonctions sont de premier ordre:
+add = (left, right) -> left + right
+add 1, 2        # => 3
+
+# Les fonctions qui ne prennent pas d'arguments sont appelées avec un point 
+# d'exclamation!
+two = -> 2
+two!
+
+# LiveScript utilise l'environnement de la fonction, comme JavaScript.
+# A l'inverse de JavaScript, le `=` fonctionne comme un opérateur de 
+# déclaration, et il déclarera toujours la variable située à gauche. 
+
+# L'opérateur `:=` est disponible pour réutiliser un nom provenant de 
+# l'environnement parent.
+
+
+# Vous pouvez "déballer" les arguments d'une fonction pour récupérer 
+# rapidement les valeurs qui vous intéressent dans une structure de données 
+# complexe:
+tail = ([head, ...rest]) -> rest
+tail [1, 2, 3]  # => [2, 3]
+
+# Vous pouvez également transformer les arguments en utilisant les opérateurs
+# binaires. Définir des arguments par défaut est aussi possible.
+foo = (a = 1, b = 2) -> a + b
+foo!    # => 3
+
+# You pouvez utiliser cela pour cloner un argument en particulier pour éviter 
+# les effets secondaires. Par exemple:
+copy = (^^target, source) ->
+  for k,v of source => target[k] = v
+  target
+a = { a: 1 }
+copy a, { b: 2 }        # => { a: 1, b: 2 }
+a                       # => { a: 1 }
+
+
+# Une fonction peut être réduite en utilisant une longue flèche à la place
+# d'une courte:
+add = (left, right) --> left + right
+add1 = add 1
+add1 2          # => 3
+
+# Les fonctions ont un argument `it` implicite si vous n'en déclarez pas:
+identity = -> it
+identity 1      # => 1
+
+# Les opérateurs ne sont pas des fonctions en LiveScript, mais vous pouvez 
+# facilement les transformer en fonction:
+divide-by-two = (/ 2)
+[2, 4, 8, 16].map(divide-by-two) .reduce (+)
+
+# Comme dans tout bon langage fonctionnel, vous pouvez créer des fonctions 
+# composées d'autres fonctions:
+double-minus-one = (- 1) . (* 2)
+
+# En plus de la formule mathématique `f . g`, vous avez les opérateurs `>>`
+# et `<<`, qui décrivent l'ordre d'application des fonctions. 
+double-minus-one = (* 2) >> (- 1)
+double-minus-one = (- 1) << (* 2)
+
+
+# Pour appliquer une valeur à une fonction, vous pouvez utiliser les opérateurs
+# `|>` et `<|`:
+map = (f, xs) --> xs.map f
+[1 2 3] |> map (* 2)            # => [2 4 6]
+
+# You pouvez aussi choisir où vous voulez que la valeur soit placée, en 
+# marquant la position avec un tiret bas (_):
+reduce = (f, xs, initial) --> xs.reduce f, initial
+[1 2 3] |> reduce (+), _, 0     # => 6
+
+
+# Le tiret bas est également utilisé pour l'application régulière partielle,
+# que vous pouvez utiliser pour toute fonction:
+div = (left, right) -> left / right
+div-by-two = div _, 2
+div-by-two 4      # => 2
+
+
+# Pour conclure, LiveScript vous permet d'utiliser les fonctions de rappel
+# (mais vous devriez essayer des approches plus fonctionnelles, comme 
+# Promises):
+readFile = (name, f) -> f name
+a <- readFile 'foo'
+b <- readFile 'bar'
+console.log a + b
+
+# Equivalent à:
+readFile 'foo', (a) -> readFile 'bar', (b) -> console.log a + b
+
+
+########################################################################
+## 4. Conditionnalités
+########################################################################
+
+# Vous pouvez faire de la conditionnalité à l'aide de l'expression `if...else`:
+x = if n > 0 then \positive else \negative
+
+# A la place de `then`, vous pouvez utiliser `=>`
+x = if n > 0 => \positive
+    else        \negative
+
+# Pour les conditions complexes, il vaut mieux utiliser l'expresssion `switch`:
+y = {}
+x = switch
+  | (typeof y) is \number => \number
+  | (typeof y) is \string => \string
+  | 'length' of y         => \array
+  | otherwise             => \object      # `otherwise` et `_` correspondent.
+
+# Le corps des fonctions, les déclarations et les assignements disposent d'un
+# `switch` implicite, donc vous n'avez pas besoin de le réécrire: 
+take = (n, [x, ...xs]) -->
+                        | n == 0 => []
+                        | _      => [x] ++ take (n - 1), xs
+
+
+########################################################################
+## 5. Compréhensions
+########################################################################
+
+# Comme en python, vous allez pouvoir utiliser les listes en compréhension,
+# ce qui permet de générer rapidement et de manière élégante une liste de 
+# valeurs:
+oneToTwenty = [1 to 20]
+evens       = [x for x in oneToTwenty when x % 2 == 0]
+
+# `when` et `unless` peuvent être utilisés comme des filtres.
+
+# Cette technique fonctionne sur les objets de la même manière, via la syntaxe 
+# suivante:
+copy = { [k, v] for k, v of source }
+
+
+########################################################################
+## 4. Programmation orientée objet
+########################################################################
+
+# Bien que LiveScript soit un langage fonctionnel, il dispose d'intéressants
+# outils pour la programmation objet. La syntaxe de déclaration d'une classe
+# est héritée de CoffeeScript:
+class Animal
+  (@name, kind) ->
+    @kind = kind
+  action: (what) -> "*#{@name} (a #{@kind}) #{what}*"
+
+class Cat extends Animal
+  (@name) -> super @name, 'cat'
+  purr: -> @action 'purrs'
+
+kitten = new Cat 'Mei'
+kitten.purr!      # => "*Mei (a cat) purrs*"
+
+# En plus de l'héritage classique, vous pouvez utiliser autant de mixins
+# que vous voulez pour votre classe. Les mixins sont justes des objets:
+Huggable =
+  hug: -> @action 'is hugged'
+
+class SnugglyCat extends Cat implements Huggable
+
+kitten = new SnugglyCat 'Purr'
+kitten.hug!     # => "*Mei (a cat) is hugged*"
+```
+
+## Lectures complémentaires
+
+Il y a beaucoup plus de choses à dire sur LiveScript, mais ce guide devrait 
+suffire pour démarrer l'écriture de petites fonctionnalités.
+Le [site officiel](http://livescript.net/) dispose de beaucoup d'information,
+ainsi que d'un compilateur en ligne vous permettant de tester le langage!
+
+Jetez également un coup d'oeil à [prelude.ls](http://gkz.github.io/prelude-ls/),
+et consultez le channel `#livescript` sur le réseau Freenode.
-- 
cgit v1.2.3


From 93486c8e7ab1bbfe2af08bcb27bde6b198a18b1c Mon Sep 17 00:00:00 2001
From: Morgan <morgan.bohn@unistra.fr>
Date: Wed, 8 Jul 2015 11:16:07 +0200
Subject: [livescript/fr] add translators, correct intro

---
 fr-fr/livescript-fr.html.markdown | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/livescript-fr.html.markdown b/fr-fr/livescript-fr.html.markdown
index 0ed9763b..c6a115ee 100644
--- a/fr-fr/livescript-fr.html.markdown
+++ b/fr-fr/livescript-fr.html.markdown
@@ -3,18 +3,20 @@ language: LiveScript
 filename: learnLivescript-fr.ls
 contributors:
     - ["Christina Whyte", "http://github.com/kurisuwhyte/"]
+translators:
     - ["Morgan Bohn", "https://github.com/morganbohn"]
 lang: fr-fr
 ---
 
-LiveScript est un langage qui se compile en JavaScript. Il a un rapport direct 
-avec JavaScript, et vous permet d'écrire du JavaScript de façon considérables 
-sans répétitivité. LiveScript ajoute non seulement des fonctionnalités pour 
-écrire du code fonctionnel, mais possède aussi nombre d'améliorations pour la 
-programmation orientée objet et la programmation impérative.
+LiveScript est un langage qui compile en JavaScript. Il a un rapport direct 
+avec JavaScript, et vous permet d'écrire du JavaScript plus simplement, plus 
+efficacement et sans répétitivité. LiveScript ajoute non seulement des 
+fonctionnalités pour écrire du code fonctionnel, mais possède aussi nombre 
+d'améliorations pour la programmation orientée objet et la programmation 
+impérative.
 
-LiveScript est un descendant indirect de [CoffeeScript][], direct de [Coco][] 
-avec beaucoup plus de compatibilité.
+LiveScript est un descendant direct de [Coco][], indirect de [CoffeeScript][],
+avec lequel il a beaucoup plus de compatibilité.
 
 [Coco]: http://satyr.github.io/coco/
 [CoffeeScript]: http://coffeescript.org/
-- 
cgit v1.2.3


From 71cdcb34436925d59258144404080b6c83f74bc4 Mon Sep 17 00:00:00 2001
From: Morgan <morgan.bohn@unistra.fr>
Date: Wed, 8 Jul 2015 13:41:15 +0200
Subject: [livescript/fr] corrections

---
 fr-fr/livescript-fr.html.markdown | 47 ++++++++++++++++++++++-----------------
 1 file changed, 27 insertions(+), 20 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/livescript-fr.html.markdown b/fr-fr/livescript-fr.html.markdown
index c6a115ee..5760332d 100644
--- a/fr-fr/livescript-fr.html.markdown
+++ b/fr-fr/livescript-fr.html.markdown
@@ -36,8 +36,8 @@ Vous pouvez contacter l'auteur du guide original en anglais ici :
 ```
 ```coffeescript
 # LiveScript utilise l'indentation pour délimiter les blocs de code plutôt que 
-# les accolades, et les espaces pour appliquer les fonctions, plutôt que les 
-# parenthèses.
+# les accolades, et les espaces pour appliquer les fonctions (bien que les 
+# parenthèses soient utilisables).
 
 
 ########################################################################
@@ -52,7 +52,7 @@ void            # comme `undefined` mais plus sûr (ne peut pas être redéfini)
 null
 
 
-# Les booléens se déclarent de la façon suivante:
+# Les booléens s'utilisent de la façon suivante:
 true
 false
 
@@ -143,7 +143,8 @@ funRE = //
 
 # Les comparaisons sont presque identiques, à l'exception que `==` équivaut au
 # `===` de JS, là où le `==` de JS est `~=` en LiveScript, et `===` active la 
-# comparaison d'objets et de tableaux, ainsi que les comparaisons strictes
+# comparaison d'objets et de tableaux, ainsi que les comparaisons strictes 
+# (sans conversion de type)
 2 == 2          # => true
 2 == "2"        # => false
 2 ~= "2"        # => true
@@ -180,27 +181,28 @@ not false       # => true
 add = (left, right) -> left + right
 add 1, 2        # => 3
 
-# Les fonctions qui ne prennent pas d'arguments sont appelées avec un point 
-# d'exclamation!
+# Les fonctions qui ne prennent pas d'arguments peuvent être appelées avec un 
+# point d'exclamation!
 two = -> 2
 two!
 
 # LiveScript utilise l'environnement de la fonction, comme JavaScript.
 # A l'inverse de JavaScript, le `=` fonctionne comme un opérateur de 
-# déclaration, et il déclarera toujours la variable située à gauche. 
+# déclaration, et il déclarera toujours la variable située à gauche (sauf si
+# la variable a été déclarée dans l'environnement parent). 
 
 # L'opérateur `:=` est disponible pour réutiliser un nom provenant de 
 # l'environnement parent.
 
 
-# Vous pouvez "déballer" les arguments d'une fonction pour récupérer 
+# Vous pouvez extraire les arguments d'une fonction pour récupérer 
 # rapidement les valeurs qui vous intéressent dans une structure de données 
 # complexe:
 tail = ([head, ...rest]) -> rest
 tail [1, 2, 3]  # => [2, 3]
 
 # Vous pouvez également transformer les arguments en utilisant les opérateurs
-# binaires. Définir des arguments par défaut est aussi possible.
+# binaires et unaires. Définir des arguments par défaut est aussi possible.
 foo = (a = 1, b = 2) -> a + b
 foo!    # => 3
 
@@ -214,7 +216,7 @@ copy a, { b: 2 }        # => { a: 1, b: 2 }
 a                       # => { a: 1 }
 
 
-# Une fonction peut être réduite en utilisant une longue flèche à la place
+# Une fonction peut être curryfiée en utilisant une longue flèche à la place
 # d'une courte:
 add = (left, right) --> left + right
 add1 = add 1
@@ -227,14 +229,14 @@ identity 1      # => 1
 # Les opérateurs ne sont pas des fonctions en LiveScript, mais vous pouvez 
 # facilement les transformer en fonction:
 divide-by-two = (/ 2)
-[2, 4, 8, 16].map(divide-by-two) .reduce (+)
+[2, 4, 8, 16].map(divide-by-two).reduce (+)
 
 # Comme dans tout bon langage fonctionnel, vous pouvez créer des fonctions 
 # composées d'autres fonctions:
 double-minus-one = (- 1) . (* 2)
 
 # En plus de la formule mathématique `f . g`, vous avez les opérateurs `>>`
-# et `<<`, qui décrivent l'ordre d'application des fonctions. 
+# et `<<`, qui décrivent l'ordre d'application des fonctions composées. 
 double-minus-one = (* 2) >> (- 1)
 double-minus-one = (- 1) << (* 2)
 
@@ -244,22 +246,27 @@ double-minus-one = (- 1) << (* 2)
 map = (f, xs) --> xs.map f
 [1 2 3] |> map (* 2)            # => [2 4 6]
 
+# La version sans pipe correspont à:
+((map (* 2)) [1, 2, 3])
+
 # You pouvez aussi choisir où vous voulez que la valeur soit placée, en 
 # marquant la position avec un tiret bas (_):
 reduce = (f, xs, initial) --> xs.reduce f, initial
 [1 2 3] |> reduce (+), _, 0     # => 6
 
 
-# Le tiret bas est également utilisé pour l'application régulière partielle,
+# Le tiret bas est également utilisé pour l'application partielle,
 # que vous pouvez utiliser pour toute fonction:
 div = (left, right) -> left / right
 div-by-two = div _, 2
 div-by-two 4      # => 2
 
 
-# Pour conclure, LiveScript vous permet d'utiliser les fonctions de rappel
+# Pour conclure, LiveScript vous permet d'utiliser les fonctions de rappel.
 # (mais vous devriez essayer des approches plus fonctionnelles, comme 
-# Promises):
+# Promises).
+# Un fonction de rappel est une fonction qui est passée en argument à une autre
+# fonction:
 readFile = (name, f) -> f name
 a <- readFile 'foo'
 b <- readFile 'bar'
@@ -291,8 +298,8 @@ x = switch
 # Le corps des fonctions, les déclarations et les assignements disposent d'un
 # `switch` implicite, donc vous n'avez pas besoin de le réécrire: 
 take = (n, [x, ...xs]) -->
-                        | n == 0 => []
-                        | _      => [x] ++ take (n - 1), xs
+    | n == 0 => []
+    | _      => [x] ++ take (n - 1), xs
 
 
 ########################################################################
@@ -307,8 +314,8 @@ evens       = [x for x in oneToTwenty when x % 2 == 0]
 
 # `when` et `unless` peuvent être utilisés comme des filtres.
 
-# Cette technique fonctionne sur les objets de la même manière, via la syntaxe 
-# suivante:
+# Cette technique fonctionne sur les objets de la même manière. Vous allez
+# pouvoir générer l'ensemble de paires clé/valeur via la syntaxe suivante:
 copy = { [k, v] for k, v of source }
 
 
@@ -332,7 +339,7 @@ kitten = new Cat 'Mei'
 kitten.purr!      # => "*Mei (a cat) purrs*"
 
 # En plus de l'héritage classique, vous pouvez utiliser autant de mixins
-# que vous voulez pour votre classe. Les mixins sont justes des objets:
+# que vous voulez pour votre classe. Les mixins sont juste des objets:
 Huggable =
   hug: -> @action 'is hugged'
 
-- 
cgit v1.2.3


From f63aa01211010b865bf663fa7a6b5128b49e2282 Mon Sep 17 00:00:00 2001
From: Morgan <morgan.bohn@unistra.fr>
Date: Wed, 8 Jul 2015 13:43:17 +0200
Subject: [livescript/fr] corrections

---
 fr-fr/livescript-fr.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'fr-fr')

diff --git a/fr-fr/livescript-fr.html.markdown b/fr-fr/livescript-fr.html.markdown
index 5760332d..9c3b8003 100644
--- a/fr-fr/livescript-fr.html.markdown
+++ b/fr-fr/livescript-fr.html.markdown
@@ -246,7 +246,7 @@ double-minus-one = (- 1) << (* 2)
 map = (f, xs) --> xs.map f
 [1 2 3] |> map (* 2)            # => [2 4 6]
 
-# La version sans pipe correspont à:
+# La version sans pipe correspond à:
 ((map (* 2)) [1, 2, 3])
 
 # You pouvez aussi choisir où vous voulez que la valeur soit placée, en 
-- 
cgit v1.2.3


From 01d5e4d6dd7a60142fb1342637c851c943f62530 Mon Sep 17 00:00:00 2001
From: TsT <tst2005@gmail.com>
Date: Fri, 7 Aug 2015 17:56:09 +0200
Subject: =?UTF-8?q?Quelques=20corrections=20et=20am=C3=A9liorations?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 fr-fr/lua-fr.html.markdown | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/lua-fr.html.markdown b/fr-fr/lua-fr.html.markdown
index b4e2a161..1f592320 100644
--- a/fr-fr/lua-fr.html.markdown
+++ b/fr-fr/lua-fr.html.markdown
@@ -434,9 +434,9 @@ les librairies standard:
 
 Autres références complémentaires:
 
-* <a href="http://nova-fusion.com/2012/08/27/lua-for-programmers-part-1/">Lua for programmers</a>
-* <a href="lua-users.org/files/wiki_insecure/users/thomasl/luarefv51.pdf">Courte de référence de Lua</a>
-* <a href="http://www.lua.org/pil/contents.html">Programming In Lua</a>
+* <a href="http://nova-fusion.com/2012/08/27/lua-for-programmers-part-1/">Lua pour programmeurs</a>
+* <a href="lua-users.org/files/wiki_insecure/users/thomasl/luarefv51.pdf">Référence condensée de Lua</a>
+* <a href="http://www.lua.org/pil/contents.html">Programmer en Lua</a>
 * <a href="http://www.lua.org/manual/">Les manuels de référence Lua</a>
 
 A propos, ce fichier est exécutable. Sauvegardez-le sous le nom *learn.lua* et
@@ -446,4 +446,4 @@ Ce tutoriel a été originalement écrit pour <a href="tylerneylon.com">tylerney
 disponible en tant que <a href="https://gist.github.com/tylerneylon/5853042">gist</a>.
 Il a été traduit en français par Roland Yonaba (voir son <a href="http://github.com/Yonaba">github</a>).
 
-Amusez-vous bien avec Lua!
\ No newline at end of file
+Amusez-vous bien avec Lua!
-- 
cgit v1.2.3


From 4904ab4dee44633407aad6183954907b89129add Mon Sep 17 00:00:00 2001
From: TsT <tst2005@gmail.com>
Date: Fri, 7 Aug 2015 18:04:32 +0200
Subject: typo fix

---
 fr-fr/markdown.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'fr-fr')

diff --git a/fr-fr/markdown.html.markdown b/fr-fr/markdown.html.markdown
index 29c0d65d..e5e7c73a 100644
--- a/fr-fr/markdown.html.markdown
+++ b/fr-fr/markdown.html.markdown
@@ -177,7 +177,7 @@ des syntaxes spécifiques -->
 
 \`\`\`ruby 
 <!-- mais enlevez les backslashes quand vous faites ça, 
-gardez juste ```ruby ( ou nom de la synatxe correspondant à votre code )-->
+gardez juste ```ruby ( ou nom de la syntaxe correspondant à votre code )-->
 def foobar
 puts "Hello world!"
 end
-- 
cgit v1.2.3


From 6f29bcc20175a348f3b1dd606d8a0ace5d48fe54 Mon Sep 17 00:00:00 2001
From: Matthias Bussonnier <bussonniermatthias@gmail.com>
Date: Sat, 3 Oct 2015 15:39:37 -0700
Subject: Update Python-fr.html.markdown

Add Link to Python3 English article.
---
 fr-fr/python-fr.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'fr-fr')

diff --git a/fr-fr/python-fr.html.markdown b/fr-fr/python-fr.html.markdown
index 58a036ba..26cab55f 100644
--- a/fr-fr/python-fr.html.markdown
+++ b/fr-fr/python-fr.html.markdown
@@ -15,7 +15,7 @@ Je suis tombé amoureux de Python de par la clarté de sa syntaxe. C'est pratiqu
 Vos retours sont grandement appréciés. Vous pouvez me contacter sur Twitter [@louiedinh](http://twitter.com/louiedinh) ou par e-mail: louiedinh [at] [google's email service]
 
 NB: Cet artice s'applique spécifiquement à Python 2.7, mais devrait s'appliquer pour toute version Python 2.x
-Vous pourrez bientôt trouver un article pour Python 3!
+Vous pourrez bientôt trouver un article pour Python 3 an Français. Pour le moment vous pouvez jettez un coup d'oeil à l'article [Python 3 en Anglais](http://learnxinyminutes.com/docs/python3/).
 
 ```python
 # Une ligne simple de commentaire commence par un dièse
-- 
cgit v1.2.3


From 998fdfdfcdff05cb0721841215addbcdd94d30b0 Mon Sep 17 00:00:00 2001
From: Matthias Bussonnier <bussonniermatthias@gmail.com>
Date: Sat, 3 Oct 2015 15:40:41 -0700
Subject: typo

---
 fr-fr/python-fr.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'fr-fr')

diff --git a/fr-fr/python-fr.html.markdown b/fr-fr/python-fr.html.markdown
index 26cab55f..5a03ecfc 100644
--- a/fr-fr/python-fr.html.markdown
+++ b/fr-fr/python-fr.html.markdown
@@ -15,7 +15,7 @@ Je suis tombé amoureux de Python de par la clarté de sa syntaxe. C'est pratiqu
 Vos retours sont grandement appréciés. Vous pouvez me contacter sur Twitter [@louiedinh](http://twitter.com/louiedinh) ou par e-mail: louiedinh [at] [google's email service]
 
 NB: Cet artice s'applique spécifiquement à Python 2.7, mais devrait s'appliquer pour toute version Python 2.x
-Vous pourrez bientôt trouver un article pour Python 3 an Français. Pour le moment vous pouvez jettez un coup d'oeil à l'article [Python 3 en Anglais](http://learnxinyminutes.com/docs/python3/).
+Vous pourrez bientôt trouver un article pour Python 3 en Français. Pour le moment vous pouvez jettez un coup d'oeil à l'article [Python 3 en Anglais](http://learnxinyminutes.com/docs/python3/).
 
 ```python
 # Une ligne simple de commentaire commence par un dièse
-- 
cgit v1.2.3


From b1984042c845a73333972715e88a3d7a2e8cfdd7 Mon Sep 17 00:00:00 2001
From: Guntbert Reiter <guntbert@gmx.at>
Date: Sun, 4 Oct 2015 16:44:24 +0200
Subject: Put demonstrative condition into ternary expression

It should be made clear that the part before the ternary operator is
indeed a condition, most often created as some comparison expression.
---
 fr-fr/csharp-fr.html.markdown | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'fr-fr')

diff --git a/fr-fr/csharp-fr.html.markdown b/fr-fr/csharp-fr.html.markdown
index e51eacc8..58b3f386 100644
--- a/fr-fr/csharp-fr.html.markdown
+++ b/fr-fr/csharp-fr.html.markdown
@@ -239,7 +239,8 @@ sur une nouvelle ligne! ""Wow!"", quel style";
             // Opérateur ternaire
             // Un simple if/else peut s'écrire :
             // <condition> ? <valeur si true> : <valeur si false>
-            string isTrue = (true) ? "True" : "False";
+            int toCompare = 17;
+            string isTrue = toCompare == 17 ? "True" : "False";
 
             // Boucle while
             int fooWhile = 0;
-- 
cgit v1.2.3


From e848adf9d53e8af5863497438753d704d30f7c5c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Gerson=20L=C3=A1zaro?= <gersonlazaro@gersonlazaro.com>
Date: Mon, 5 Oct 2015 15:20:35 -0500
Subject: Fix for issue #1248 [fa-ir, zh-cn, ko-kr, es-es, ru-ru, fr-fr, de-de]

---
 fr-fr/javascript-fr.html.markdown | 3 ---
 1 file changed, 3 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/javascript-fr.html.markdown b/fr-fr/javascript-fr.html.markdown
index 2e18d0be..15478cdb 100644
--- a/fr-fr/javascript-fr.html.markdown
+++ b/fr-fr/javascript-fr.html.markdown
@@ -469,9 +469,6 @@ myNumber === myNumberObj; // = false
 if (0){
     // 0 est falsy, le code ne fonctionnera pas.
 }
-if (Number(0)){
-    // Parce que Number(0) est truthy, le code fonctionnera
-}
 
 // Cependant, vous pouvez ajouter des fonctionnalités aux types de bases grâce à
 // cette particularité.
-- 
cgit v1.2.3


From ca85ca56da67faacb06dee27c19b9e465c987538 Mon Sep 17 00:00:00 2001
From: Pascal Boutin <pboutin@pilogiq.com>
Date: Tue, 6 Oct 2015 00:13:29 -0400
Subject: first draft of the french version of the PHP manual

---
 fr-fr/php.html.markdown | 690 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 690 insertions(+)
 create mode 100644 fr-fr/php.html.markdown

(limited to 'fr-fr')

diff --git a/fr-fr/php.html.markdown b/fr-fr/php.html.markdown
new file mode 100644
index 00000000..b7b41ebe
--- /dev/null
+++ b/fr-fr/php.html.markdown
@@ -0,0 +1,690 @@
+---
+language: PHP
+contributors:
+    - ["Pascal Boutin", "http://pboutin.net/"]
+filename: learnphp.php
+lang: fr-fr
+---
+
+This document describes PHP 5+.
+
+```php
+ // Le code PHP doit être placé à l'intérieur de tags '<?php'
+
+// Si votre fichier php ne contient que du code PHP, il est
+// généralement recommandé de ne pas fermer le tag '?>'
+
+// Deux barres obliques amorcent un commentaire simple.
+
+# Le dièse également, bien que les barres obliques soient plus courantes
+
+/*
+    Les barres obliques et les astérisques peuvent être utilisés
+    pour faire un commentaire multi-ligne.
+*/
+
+// Utilisez "echo" ou "print" afficher une sortie
+print('Hello '); // Affiche "Hello " sans retour à la ligne
+
+// Les parenthèses sont facultatives pour print et echo
+echo "World\n"; // Affiche "World" avec un retour à la ligne
+// tout les instructions doivent se terminer par un point-virgule
+
+// Tout ce qui se trouve en dehors des <?php ?> est automatiquement
+// affiché en sortie
+Hello World Again!
+<?php
+
+
+/************************************
+ * Types & Variables
+ */
+
+// Les noms de variables débutent par le symbole $
+// Un nom de variable valide commence par une lettre ou un souligné,
+// suivi de n'importe quelle lettre, nombre ou soulignés.
+
+// Les valeurs booléenes ne sont pas sensibles à la casse
+$boolean = true;  // ou TRUE ou True
+$boolean = false; // ou FALSE ou False
+
+// Entiers (integers)
+$int1 = 12;   // => 12
+$int2 = -12;  // => -12
+$int3 = 012;  // => 10 (un 0 devant la valeur désigne une valeur octale)
+$int4 = 0x0F; // => 15 (un 0x devant la valeur désigne une valeur hexadécimale)
+
+// Réels (floats, doubles)
+$float = 1.234;
+$float = 1.2e3;
+$float = 7E-10;
+
+// Suppression d'une variable
+unset($int1);
+
+// Arithmétique
+$sum        = 1 + 1; // 2 (addition)
+$difference = 2 - 1; // 1 (soustraction)
+$product    = 2 * 2; // 4 (produit)
+$quotient   = 2 / 1; // 2 (division)
+
+// Arithmétique (raccourcis)
+$number = 0;
+$number += 2;      // Incrémente $number de 2
+echo $number++;    // Affiche 1 (incrémente après l'évaluation)
+echo ++$number;    // Affiche 3 (incrémente après l'évaluation)
+$number /= $float; // Divise et assigne le quotient à $number
+
+// Les chaînes de caractères (strings) doivent être à
+// l'intérieur d'une paire d'apostrophes
+$sgl_quotes = '$String'; // => '$String'
+
+// Évitez les guillemets sauf pour inclure le contenu d'une autre variable
+$dbl_quotes = "This is a $sgl_quotes."; // => 'This is a $String.'
+
+// Les caractères spéciaux sont seulement échappé avec des guillemets
+$escaped   = "This contains a \t tab character.";
+$unescaped = 'This just contains a slash and a t: \t';
+
+// En cas de besoins, placez la variable dans des accolades
+$money = "I have $${number} in the bank.";
+
+// Depuis PHP 5.3, nowdocs peut être utilisé pour faire des chaînes
+// multi-lignes non-interprétées
+$nowdoc = <<<'END'
+Multi line
+string
+END;
+
+// Heredocs peut être utilisé pour faire des chaînes multi-lignes interprétées
+$heredoc = <<<END
+Multi line
+$sgl_quotes
+END;
+
+// La concaténation de chaînes se fait avec un .
+echo 'This string ' . 'is concatenated';
+
+
+/********************************
+ * Constantes
+ */
+
+// Une constante est déclarée avec define()
+// et ne peut jamais être changée durant l'exécution
+
+// un nom valide de constante commence par une lettre ou un souligné,
+// suivi de n'importe quelle lettre, nombre ou soulignés.
+define("FOO",     "something");
+
+// on peut accéder à une constante en utilisant directement son nom
+echo 'This outputs '.FOO;
+
+
+/********************************
+ * Tableaux (array)
+ */
+
+// Tout les tableaux en PHP sont associatifs (hashmaps),
+
+// Fonctionne dans tout les versions de PHP
+$associative = array('One' => 1, 'Two' => 2, 'Three' => 3);
+
+// PHP 5.4 a introduit une nouvelle syntaxe
+$associative = ['One' => 1, 'Two' => 2, 'Three' => 3];
+
+echo $associative['One']; // affiche 1
+
+// Dans une liste simple, l'index est automatiquement attribué en tant que clé
+$array = ['One', 'Two', 'Three'];
+echo $array[0]; // => "One"
+
+// Ajoute un élément à la fin du tableau
+$array[] = 'Four';
+
+// Retrait d'un élément d'un tableau
+unset($array[3]);
+
+/********************************
+ * Affichage
+ */
+
+echo('Hello World!');
+// Affiche Hello World! dans stdout.
+// Stdout est la page web si on exécute depuis un navigateur.
+
+print('Hello World!'); // Pareil à "écho"
+
+// Pour écho, vous n'avez pas besoin des parenthèses
+echo 'Hello World!';
+print 'Hello World!'; // Pour print non plus
+
+$paragraph = 'paragraph';
+
+echo 100;        // Affichez un scalaire directement
+echo $paragraph; // ou des variables
+
+// Si le raccourci de sortie est configuré, ou si votre version de PHP est
+// 5.4.0+, vous pouvez utiliser ceci:
+?>
+<p><?= $paragraph ?></p>
+<?php
+
+$x = 1;
+$y = 2;
+$x = $y; // $x contient maintenant la même valeur que $y
+$z = &$y;
+// $z contient une référence vers $y. Changer la valeur de
+// $z changerait également la valeur de $y, et vice-versa.
+// $x resterait inchangé comme la valeur initiale de $y
+
+echo $x; // => 2
+echo $z; // => 2
+$y = 0;
+echo $x; // => 2
+echo $z; // => 0
+
+// Affiche le type et la valeur de la variable dans stdout
+var_dump($z); // prints int(0)
+
+// Affiche la variable dans stdout dans un format plus accessible
+print_r($array); // prints: Array ( [0] => One [1] => Two [2] => Three )
+
+/********************************
+ * Logique
+ */
+$a = 0;
+$b = '0';
+$c = '1';
+$d = '1';
+
+// assert affiche un avertissement dans son argument n'est pas vrai
+
+// Ces comparaisons vont toujours être vrais, même si leurs
+// types ne sont pas les mêmes.
+assert($a == $b); // égalité
+assert($c != $a); // inégalité
+assert($c <> $a); // inégalité (moins courant)
+assert($a < $c);
+assert($c > $b);
+assert($a <= $b);
+assert($c >= $d);
+
+// Ces comparaisons vont seulement être vrais si les types concordent.
+assert($c === $d);
+assert($a !== $d);
+assert(1 === '1');
+assert(1 !== '1');
+
+// Opérateur 'spaceship' depuis PHP 7
+$a = 100;
+$b = 1000;
+
+echo $a <=> $a; // 0 car ils sont égaux
+echo $a <=> $b; // -1 car $a < $b
+echo $b <=> $a; // 1 car $b > $a
+
+// Les variables peuvent être transtypées dépendant de leur usage.
+
+$integer = 1;
+echo $integer + $integer; // => 2
+
+$string = '1';
+echo $string + $string; // => 2
+
+$string = 'one';
+echo $string + $string; // => 0
+// Donne 0 car l'opérateur + ne peut pas transtyper la chaîne 'one' en un nombre
+
+// On peut également transtyper manuellement pour utiliser
+// une variable dans un autre type
+
+$boolean = (boolean) 1; // => true
+
+$zero = 0;
+$boolean = (boolean) $zero; // => false
+
+// Il y a également des fonctions dédiées pour transtyper
+$integer = 5;
+$string = strval($integer);
+
+$var = null; // Valeur Null
+
+
+/********************************
+ * Structures de contrôle
+ */
+
+if (true) {
+    print 'Je suis affiché';
+}
+
+if (false) {
+    print 'Je ne le suis pas';
+} else {
+    print 'Je suis affiché';
+}
+
+if (false) {
+    print 'Je ne suis pas affiché';
+} elseif (true) {
+    print 'Je le suis';
+}
+
+// Opérateur ternaire
+print (false ? 'N\'est pas affiché' : 'L\'est');
+
+// Opérateur ternaire depuis PHP 5.3
+// équivalent de $x ? $x : 'Does'
+$x = false;
+print($x ?: 'Does');
+
+// depuis PHP 7, on peut facilement vérifier si une valeur est nulle
+$a = null;
+$b = 'Hello World';
+echo $a ?? 'a is not set'; // Affiche 'a is not set'
+echo $b ?? 'b is not set'; // Affiche 'Hello World'
+
+
+$x = 0;
+if ($x === '0') {
+    print 'Pas affiché';
+} elseif($x == '1') {
+    print 'Pas affiché';
+} else {
+    print 'Affiché';
+}
+
+
+// Cette syntaxe alternative est particulièrement utile avec du HTML:
+?>
+
+<?php if ($x): ?>
+<p>Ceci est affiché si $x est vrai</p>
+<?php else: ?>
+<p>Sinon ce sera ceci</p>
+<?php endif; ?>
+
+<?php
+
+// On peut également utiliser une condition multiple (switch case)
+switch ($x) {
+    case '0':
+        print 'Les switch font du transtypage implicite';
+        break; // Il est important de déclaré un 'break', sinon les cas
+               // 'two' et 'three' seront évalués
+    case 'two':
+    case 'three':
+        // Si $x == 'two' || $x == 'three'
+        break;
+    default:
+        // Si aucun cas n'a été vrai
+}
+
+// Structures itératives (for, while, do while)
+$i = 0;
+while ($i < 5) {
+    echo $i++;
+}; // Affiche "01234"
+
+echo "\n";
+
+$i = 0;
+do {
+    echo $i++;
+} while ($i < 5); // Affiche "01234"
+
+echo "\n";
+
+for ($x = 0; $x < 10; $x++) {
+    echo $x;
+} // Affiche "0123456789"
+
+echo "\n";
+
+$wheels = ['bicycle' => 2, 'car' => 4];
+
+// Les boucles 'foreach' sont utiles pour parcourir les tableaux
+foreach ($wheels as $wheel_count) {
+    echo $wheel_count;
+} // Affiche "24"
+
+echo "\n";
+
+// Il est également possible d'accéder aux clés du tableau
+foreach ($wheels as $vehicle => $wheel_count) {
+    echo "Le $vehicle a $wheel_count roues";
+}
+
+echo "\n";
+
+$i = 0;
+while ($i < 5) {
+    if ($i === 3) {
+        break; // Permet d'arrêter la boucle
+    }
+    echo $i++;
+} // Affiche "012"
+
+for ($i = 0; $i < 5; $i++) {
+    if ($i === 3) {
+        continue; // Permet de passer imédiatement à l'itération suivante
+    }
+    echo $i;
+} // Affiche "0124"
+
+
+/********************************
+ * Fonctions
+ */
+
+// On peut déclarer une fonction avec le mot clé 'function'
+function my_function () {
+  return 'Hello';
+}
+
+echo my_function(); // => "Hello"
+
+// Un nom de fonction valide doit débuter par une lettre ou un souligné,
+// suivi de n'importe, quelles lettres, nombres ou soulignés.
+
+function add ($x, $y = 1) { // $y est facultatif et sa valeur par défaut est 1
+  $result = $x + $y;
+  return $result;
+}
+
+echo add(4); // => 5
+echo add(4, 2); // => 6
+
+// $result n'est pas accessible en dehors de la fonction
+// print $result; // Retourne un avertissement
+
+// Depuis PHP 5.3 on peut déclarer des fonctions anonymes
+$inc = function ($x) {
+  return $x + 1;
+};
+
+echo $inc(2); // => 3
+
+function foo ($x, $y, $z) {
+  echo "$x - $y - $z";
+}
+
+// Une fonction peut retourner une fonction
+function bar ($x, $y) {
+  // On peut utiliser 'use' pour passer des variables externes
+  return function ($z) use ($x, $y) {
+    foo($x, $y, $z);
+  };
+}
+
+$bar = bar('A', 'B');
+$bar('C'); // Affiche "A - B - C"
+
+// On peut exécuter une fonction par son nom en chaîne de caractères
+$function_name = 'add';
+echo $function_name(1, 2); // => 3
+// Utile pour déterminer par programmation quelle fonction exécuter.
+
+// On peut également utiliser
+call_user_func(callable $callback [, $parameter [, ... ]]);
+
+/********************************
+ * Insertions
+ */
+
+<?php
+// Le PHP se trouvant dans un fichier inclus doit
+// également commencer par un tag PHP.
+
+include 'my-file.php';
+// Le code se trouvant dans my-file.php est maintenant disponible dans
+// le contexte courant. Si le fichier ne peut pas être inclus
+// (ex. non trouvé), un avertissement sera émit.
+
+include_once 'my-file.php';
+// Si le code dans my-file.php a déjà été inclus ailleur, il ne va pas
+// être inclus de nouveau.
+
+require 'my-file.php';
+require_once 'my-file.php';
+// Même comportement que include() mais déclenche une érreur fatale si le fichier ne peux pas être inclus.
+
+// Contenu de my-include.php:
+<?php
+
+return 'Anything you like.';
+// Fin de my-include.php
+
+// include() et require() peuvent également retourner une valeur
+$value = include('my-include.php');
+
+// Les fichiers sont inclus depuis le chemin donné ou, si aucun chemin n'est donné,
+// la configuration 'include_path'. Si le fichier n'est pas trouvé dans le 'include_path',
+// include va finalement vérifier dans le répertoire courant avant d'échouer.
+
+/********************************
+ * Classes
+ */
+
+// Les classes sont définies avec le mot clé 'class'
+
+class MyClass
+{
+    const MY_CONST      = 'value'; // Une constante
+
+    static $staticVar   = 'static';
+
+    // Variables statiques et leur visibilité
+    public static $publicStaticVar = 'publicStatic';
+    // Accessible à l'intérieur de la classe seulement
+    private static $privateStaticVar = 'privateStatic';
+    // Accessible à l'intérieur de la classe et des classes enfants
+    protected static $protectedStaticVar = 'protectedStatic';
+
+    // Les attributs doivent définir leur visibilité
+    public $property = 'public';
+    public $instanceProp;
+    protected $prot = 'protected';
+    private $priv   = 'private';
+
+    // Déclaration d'un constructeur avec __construct
+    public function __construct($instanceProp) {
+        // Access instance variables with $this
+        $this->instanceProp = $instanceProp;
+    }
+
+    // Les méthodes sont déclarés par des fonctions au sein de la classe
+    public function myMethod()
+    {
+        print 'MyClass';
+    }
+
+    // le mot clé 'final' rend la function impossible à surcharger
+    final function youCannotOverrideMe()
+    {
+    }
+
+/*
+ * Les attributs et méthodes statiques peuvent être accédés sans devoir
+ * instancier la classe. Les attributs statiques ne sont pas accessibles depuis
+ * une instance, même si les méthodes statiques le sont.
+ */
+
+    public static function myStaticMethod()
+    {
+        print 'I am static';
+    }
+}
+
+// Les constantes d'une classe peuvent toujours être utilisé de façon statique
+echo MyClass::MY_CONST;    // Outputs 'value';
+
+echo MyClass::$staticVar;  // Retourne 'static';
+MyClass::myStaticMethod(); // Retourne 'I am static';
+
+// On peut instancier une classe en utilisant le mot clé 'new'
+$my_class = new MyClass('An instance property');
+
+// On peut accéder aux attributs/méthodes d'une instance avec ->
+echo $my_class->property;     // => "public"
+echo $my_class->instanceProp; // => "An instance property"
+$my_class->myMethod();        // => "MyClass"
+
+
+// On peut hériter d'une classe en utilisant 'extends'
+class MyOtherClass extends MyClass
+{
+    function printProtectedProperty()
+    {
+        echo $this->prot;
+    }
+
+    // Surcharge d'une méthode
+    function myMethod()
+    {
+        parent::myMethod();
+        print ' > MyOtherClass';
+    }
+}
+
+$my_other_class = new MyOtherClass('Instance prop');
+$my_other_class->printProtectedProperty(); // => Retourne "protected"
+$my_other_class->myMethod();               // Retourne "MyClass > MyOtherClass"
+
+final class YouCannotExtendMe
+{
+}
+
+// On peut utiliser des "méthodes magiques" pour se faire des accesseurs
+class MyMapClass
+{
+    private $property;
+
+    public function __get($key)
+    {
+        return $this->$key;
+    }
+
+    public function __set($key, $value)
+    {
+        $this->$key = $value;
+    }
+}
+
+$x = new MyMapClass();
+echo $x->property; // Va utiliser la méthode __get()
+$x->property = 'Something'; // Va utiliser la méthode __set()
+
+// Les classes peuvent être abstraites (en utilisant le mot clé 'abstract'), ou
+// elle peuvent implémenter une interface (en utilisant le mot clé 'implement').
+
+// Une interface peut être déclarée avec le mot clé 'interface'
+
+interface InterfaceOne
+{
+    public function doSomething();
+}
+
+interface InterfaceTwo
+{
+    public function doSomethingElse();
+}
+
+// Les interfaces peuvent hériter d'autres interfaces
+interface InterfaceThree extends InterfaceTwo
+{
+    public function doAnotherContract();
+}
+
+abstract class MyAbstractClass implements InterfaceOne
+{
+    public $x = 'doSomething';
+}
+
+class MyConcreteClass extends MyAbstractClass implements InterfaceTwo
+{
+    public function doSomething()
+    {
+        echo $x;
+    }
+
+    public function doSomethingElse()
+    {
+        echo 'doSomethingElse';
+    }
+}
+
+
+// Les classes peuvent implémenter plusieurs interfaces à la fois
+class SomeOtherClass implements InterfaceOne, InterfaceTwo
+{
+    public function doSomething()
+    {
+        echo 'doSomething';
+    }
+
+    public function doSomethingElse()
+    {
+        echo 'doSomethingElse';
+    }
+}
+
+/********************************
+ * Espaces de noms (namespaces)
+ */
+
+// Cette section est séparée, car une déclaration d'espace de nom doit être
+// la première chose que l'on retrouve dans un fichier PHP,
+// imaginons que c'est le cas
+
+<?php
+
+// Par défaut, les classes existent dans l'espace de nom global et peuvent
+// être appelé explicitement avec un antislash.
+
+$cls = new \MyClass();
+
+
+
+// On peut spécifier l'espace de nom d'un fichier comme cela
+namespace My\Namespace;
+
+class MyClass
+{
+}
+
+// (depuis un autre fichier...)
+$cls = new My\Namespace\MyClass;
+
+// Ou depuis un autre espace de nom
+namespace My\Other\Namespace;
+
+use My\Namespace\MyClass;
+
+$cls = new MyClass();
+
+// On peut également utiliser un alias sur un espace de nom
+
+namespace My\Other\Namespace;
+
+use My\Namespace as SomeOtherNamespace;
+
+$cls = new SomeOtherNamespace\MyClass();
+
+*/
+
+```
+
+## Pour plus d'informations
+
+Visitez la [documentation officielle](http://www.php.net/manual/fr)..
+
+Si vous êtes intéressé aux bonnes pratiques, visitez
+[PHP The Right Way](http://www.phptherightway.com/) (anglais seulement).
+
+Si vous êtes habitué d'utiliser de bons gestionaires de dépendances, regardez
+[Composer](http://getcomposer.org/).
+
+Pour les standards, visitez "the PHP Framework Interoperability Group's"
+[PSR standards](https://github.com/php-fig/fig-standards).
-- 
cgit v1.2.3


From 00624c1a9ba385ce960e248622621f5042d5a6d9 Mon Sep 17 00:00:00 2001
From: Florent Espanet <florent.esp@gmail.com>
Date: Tue, 6 Oct 2015 09:25:12 +0200
Subject: Update python-fr.html.markdown

Fix typo
---
 fr-fr/python-fr.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'fr-fr')

diff --git a/fr-fr/python-fr.html.markdown b/fr-fr/python-fr.html.markdown
index 5a03ecfc..3f6dcabb 100644
--- a/fr-fr/python-fr.html.markdown
+++ b/fr-fr/python-fr.html.markdown
@@ -19,7 +19,7 @@ Vous pourrez bientôt trouver un article pour Python 3 en Français. Pour le mom
 
 ```python
 # Une ligne simple de commentaire commence par un dièse
-""" Les lignes de commenatires multipes peuvent être écrites
+""" Les lignes de commentaires multipes peuvent être écrites
     en utilisant 3 guillemets ("), et sont souvent utilisées
     pour les commentaires
 """
-- 
cgit v1.2.3


From 08ba654955824ae6daecd169608a6ff645b18d39 Mon Sep 17 00:00:00 2001
From: Pascal Boutin <pboutin@webcliniq.com>
Date: Tue, 6 Oct 2015 15:11:34 -0400
Subject: Quick review for the fr-fr php page

---
 fr-fr/php.html.markdown | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/php.html.markdown b/fr-fr/php.html.markdown
index b7b41ebe..6574a36f 100644
--- a/fr-fr/php.html.markdown
+++ b/fr-fr/php.html.markdown
@@ -2,7 +2,6 @@
 language: PHP
 contributors:
     - ["Pascal Boutin", "http://pboutin.net/"]
-filename: learnphp.php
 lang: fr-fr
 ---
 
@@ -16,11 +15,11 @@ This document describes PHP 5+.
 
 // Deux barres obliques amorcent un commentaire simple.
 
-# Le dièse également, bien que les barres obliques soient plus courantes
+# Le dièse aussi, bien que les barres obliques soient plus courantes
 
 /*
     Les barres obliques et les astérisques peuvent être utilisés
-    pour faire un commentaire multi-ligne.
+    pour faire un commentaire multi-lignes.
 */
 
 // Utilisez "echo" ou "print" afficher une sortie
@@ -28,6 +27,7 @@ print('Hello '); // Affiche "Hello " sans retour à la ligne
 
 // Les parenthèses sont facultatives pour print et echo
 echo "World\n"; // Affiche "World" avec un retour à la ligne
+
 // tout les instructions doivent se terminer par un point-virgule
 
 // Tout ce qui se trouve en dehors des <?php ?> est automatiquement
@@ -248,7 +248,7 @@ $boolean = (boolean) $zero; // => false
 $integer = 5;
 $string = strval($integer);
 
-$var = null; // Valeur Null
+$var = null; // Valeur nulle
 
 
 /********************************
@@ -353,7 +353,7 @@ echo "\n";
 
 // Il est également possible d'accéder aux clés du tableau
 foreach ($wheels as $vehicle => $wheel_count) {
-    echo "Le $vehicle a $wheel_count roues";
+    echo "The $vehicle have $wheel_count wheels";
 }
 
 echo "\n";
-- 
cgit v1.2.3


From 7ffea42953466151202155d3979f17b6b9b76bb1 Mon Sep 17 00:00:00 2001
From: pboutin <pboutin@internap.com>
Date: Tue, 6 Oct 2015 17:18:10 -0400
Subject: fixed grammar errors following the comments of vendethiel

---
 fr-fr/php.html.markdown | 57 ++++++++++++++++++++++++++-----------------------
 1 file changed, 30 insertions(+), 27 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/php.html.markdown b/fr-fr/php.html.markdown
index 6574a36f..1c8db89a 100644
--- a/fr-fr/php.html.markdown
+++ b/fr-fr/php.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: PHP
-contributors:
+translators:
     - ["Pascal Boutin", "http://pboutin.net/"]
 lang: fr-fr
 ---
@@ -8,10 +8,10 @@ lang: fr-fr
 This document describes PHP 5+.
 
 ```php
- // Le code PHP doit être placé à l'intérieur de tags '<?php'
+ // Le code PHP doit être placé à l'intérieur de balises '<?php'
 
 // Si votre fichier php ne contient que du code PHP, il est
-// généralement recommandé de ne pas fermer le tag '?>'
+// généralement recommandé de ne pas fermer la balise '?>'
 
 // Deux barres obliques amorcent un commentaire simple.
 
@@ -28,7 +28,7 @@ print('Hello '); // Affiche "Hello " sans retour à la ligne
 // Les parenthèses sont facultatives pour print et echo
 echo "World\n"; // Affiche "World" avec un retour à la ligne
 
-// tout les instructions doivent se terminer par un point-virgule
+// toutes les instructions doivent se terminer par un point-virgule
 
 // Tout ce qui se trouve en dehors des <?php ?> est automatiquement
 // affiché en sortie
@@ -42,7 +42,7 @@ Hello World Again!
 
 // Les noms de variables débutent par le symbole $
 // Un nom de variable valide commence par une lettre ou un souligné,
-// suivi de n'importe quelle lettre, nombre ou soulignés.
+// suivi de n'importe quelle lettre, nombre ou de soulignés.
 
 // Les valeurs booléenes ne sont pas sensibles à la casse
 $boolean = true;  // ou TRUE ou True
@@ -71,8 +71,8 @@ $quotient   = 2 / 1; // 2 (division)
 // Arithmétique (raccourcis)
 $number = 0;
 $number += 2;      // Incrémente $number de 2
-echo $number++;    // Affiche 1 (incrémente après l'évaluation)
-echo ++$number;    // Affiche 3 (incrémente après l'évaluation)
+echo $number++;    // Affiche 2 (incrémente après l'évaluation)
+echo ++$number;    // Affiche 4 (incrémente avant l'évaluation)
 $number /= $float; // Divise et assigne le quotient à $number
 
 // Les chaînes de caractères (strings) doivent être à
@@ -82,21 +82,21 @@ $sgl_quotes = '$String'; // => '$String'
 // Évitez les guillemets sauf pour inclure le contenu d'une autre variable
 $dbl_quotes = "This is a $sgl_quotes."; // => 'This is a $String.'
 
-// Les caractères spéciaux sont seulement échappé avec des guillemets
+// Les caractères spéciaux sont seulement échappés avec des guillemets
 $escaped   = "This contains a \t tab character.";
 $unescaped = 'This just contains a slash and a t: \t';
 
-// En cas de besoins, placez la variable dans des accolades
+// En cas de besoin, placez la variable dans des accolades
 $money = "I have $${number} in the bank.";
 
-// Depuis PHP 5.3, nowdocs peut être utilisé pour faire des chaînes
+// Depuis PHP 5.3, Nowdoc peut être utilisé pour faire des chaînes
 // multi-lignes non-interprétées
 $nowdoc = <<<'END'
 Multi line
 string
 END;
 
-// Heredocs peut être utilisé pour faire des chaînes multi-lignes interprétées
+// Heredoc peut être utilisé pour faire des chaînes multi-lignes interprétées
 $heredoc = <<<END
 Multi line
 $sgl_quotes
@@ -125,9 +125,9 @@ echo 'This outputs '.FOO;
  * Tableaux (array)
  */
 
-// Tout les tableaux en PHP sont associatifs (hashmaps),
+// Tous les tableaux en PHP sont associatifs (hashmaps),
 
-// Fonctionne dans tout les versions de PHP
+// Fonctionne dans toutes les versions de PHP
 $associative = array('One' => 1, 'Two' => 2, 'Three' => 3);
 
 // PHP 5.4 a introduit une nouvelle syntaxe
@@ -142,7 +142,7 @@ echo $array[0]; // => "One"
 // Ajoute un élément à la fin du tableau
 $array[] = 'Four';
 
-// Retrait d'un élément d'un tableau
+// Retrait d'un élément du tableau
 unset($array[3]);
 
 /********************************
@@ -187,7 +187,7 @@ echo $z; // => 0
 // Affiche le type et la valeur de la variable dans stdout
 var_dump($z); // prints int(0)
 
-// Affiche la variable dans stdout dans un format plus accessible
+// Affiche la variable dans stdout dans un format plus convivial
 print_r($array); // prints: Array ( [0] => One [1] => Two [2] => Three )
 
 /********************************
@@ -200,7 +200,7 @@ $d = '1';
 
 // assert affiche un avertissement dans son argument n'est pas vrai
 
-// Ces comparaisons vont toujours être vrais, même si leurs
+// Ces comparaisons vont toujours être vraies, même si leurs
 // types ne sont pas les mêmes.
 assert($a == $b); // égalité
 assert($c != $a); // inégalité
@@ -210,7 +210,7 @@ assert($c > $b);
 assert($a <= $b);
 assert($c >= $d);
 
-// Ces comparaisons vont seulement être vrais si les types concordent.
+// Ces comparaisons vont seulement être vraies si les types concordent.
 assert($c === $d);
 assert($a !== $d);
 assert(1 === '1');
@@ -224,7 +224,7 @@ echo $a <=> $a; // 0 car ils sont égaux
 echo $a <=> $b; // -1 car $a < $b
 echo $b <=> $a; // 1 car $b > $a
 
-// Les variables peuvent être transtypées dépendant de leur usage.
+// Les variables peuvent être transtypées dépendamment de leur usage.
 
 $integer = 1;
 echo $integer + $integer; // => 2
@@ -302,7 +302,7 @@ if ($x === '0') {
 <?php if ($x): ?>
 <p>Ceci est affiché si $x est vrai</p>
 <?php else: ?>
-<p>Sinon ce sera ceci</p>
+<p>Ceci est affiché si $x est faux</p>
 <?php endif; ?>
 
 <?php
@@ -368,7 +368,7 @@ while ($i < 5) {
 
 for ($i = 0; $i < 5; $i++) {
     if ($i === 3) {
-        continue; // Permet de passer imédiatement à l'itération suivante
+        continue; // Permet de passer immédiatement à l'itération suivante
     }
     echo $i;
 } // Affiche "0124"
@@ -385,8 +385,10 @@ function my_function () {
 
 echo my_function(); // => "Hello"
 
-// Un nom de fonction valide doit débuter par une lettre ou un souligné,
-// suivi de n'importe, quelles lettres, nombres ou soulignés.
+
+// Les noms de fonction débutent par le symbole $
+// Un nom de variable valide commence par une lettre ou un souligné,
+// suivi de n'importe quelle lettre, nombre ou de soulignés.
 
 function add ($x, $y = 1) { // $y est facultatif et sa valeur par défaut est 1
   $result = $x + $y;
@@ -435,7 +437,7 @@ call_user_func(callable $callback [, $parameter [, ... ]]);
 
 <?php
 // Le PHP se trouvant dans un fichier inclus doit
-// également commencer par un tag PHP.
+// également commencer par une balise PHP.
 
 include 'my-file.php';
 // Le code se trouvant dans my-file.php est maintenant disponible dans
@@ -552,6 +554,7 @@ $my_other_class = new MyOtherClass('Instance prop');
 $my_other_class->printProtectedProperty(); // => Retourne "protected"
 $my_other_class->myMethod();               // Retourne "MyClass > MyOtherClass"
 
+// On peut empêcher qu'une classe soit héritée
 final class YouCannotExtendMe
 {
 }
@@ -678,13 +681,13 @@ $cls = new SomeOtherNamespace\MyClass();
 
 ## Pour plus d'informations
 
-Visitez la [documentation officielle](http://www.php.net/manual/fr)..
+Visitez la [documentation officielle](http://www.php.net/manual/fr).
 
-Si vous êtes intéressé aux bonnes pratiques, visitez
+Si vous êtes intéressé par les bonnes pratiques, visitez
 [PHP The Right Way](http://www.phptherightway.com/) (anglais seulement).
 
-Si vous êtes habitué d'utiliser de bons gestionaires de dépendances, regardez
+Si vous êtes habitué à utiliser de bons gestionaires de dépendances, regardez
 [Composer](http://getcomposer.org/).
 
-Pour les standards, visitez "the PHP Framework Interoperability Group's"
+Pour consulter les standards, visitez "the PHP Framework Interoperability Groups"
 [PSR standards](https://github.com/php-fig/fig-standards).
-- 
cgit v1.2.3


From d6f45adb94a3e7a16896c5301199baf8a96f6754 Mon Sep 17 00:00:00 2001
From: ven <vendethiel@hotmail.fr>
Date: Wed, 7 Oct 2015 08:35:54 +0200
Subject: fix contributors, #13699

---
 fr-fr/php.html.markdown | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'fr-fr')

diff --git a/fr-fr/php.html.markdown b/fr-fr/php.html.markdown
index 1c8db89a..f4eaf396 100644
--- a/fr-fr/php.html.markdown
+++ b/fr-fr/php.html.markdown
@@ -1,5 +1,8 @@
 ---
 language: PHP
+contributors:
+    - ["Malcolm Fell", "http://emarref.net/"]
+    - ["Trismegiste", "https://github.com/Trismegiste"]
 translators:
     - ["Pascal Boutin", "http://pboutin.net/"]
 lang: fr-fr
-- 
cgit v1.2.3


From ab8267f4273d6fa2c3027775e353d95e7d5f1493 Mon Sep 17 00:00:00 2001
From: payet-s <payet_s@epitech.eu>
Date: Thu, 8 Oct 2015 16:48:50 +0200
Subject: [yaml/fr] Fix typos

---
 fr-fr/yaml-fr.html.markdown | 92 +++++++++++++++++++++++----------------------
 1 file changed, 48 insertions(+), 44 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/yaml-fr.html.markdown b/fr-fr/yaml-fr.html.markdown
index 43b1df54..1e8296d3 100644
--- a/fr-fr/yaml-fr.html.markdown
+++ b/fr-fr/yaml-fr.html.markdown
@@ -8,113 +8,117 @@ lang: fr-fr
 
 Proposé à l'origine par Clark Evans en Mai 2001, YAML est un un format de 
 représentation de données par sérialisation, conçu pour être aisément 
-éditable et lisible par nous même, les humains.
+modifiable et lisible par nous-mêmes, les humains.
 
-YAML est plus concis que le XML auquel il est parfois comparé par ceux qui le découvre, plus lisible et clair que le CSV, et emprunte beaucoup au JSON dont il est un parent naturel. Toutefois, YAML emprunte également des idées et concepts de chez Python, et s'intègre bien avec bon nombre de langages.
+YAML est plus concis que le XML auquel il est parfois comparé par ceux qui le
+découvre, plus lisible et clair que le CSV, et emprunte beaucoup au JSON dont
+il est un parent naturel. Toutefois, YAML emprunte également des idées et
+concepts de Python, et s'intègre bien avec bon nombre de langages.
+Contrairement à ce dernier, YAML interdit l'utilisation des tabulations.
 
 
 ```yaml
-# les Commentaires sont précédés d'un signe "#", comme cette ligne.
+# Les commentaires sont précédés d'un signe "#", comme cette ligne.
 
 #############
 # SCALAIRES #
 #############
 
-# Les scalaires sont l'ensemble des types YAML qui ne sont pas des collections 
-# ( listes ou tableaux associatifs ).
+# Les scalaires sont l'ensemble des types YAML qui ne sont pas des collections
+# (listes ou tableaux associatifs).
 
-# Notre objet root ( racine ), sera une map ( carte ) et englobera 
-# l'intégralité du document. Cette map est l'équivalent d'un dictionnaire, 
+# Notre objet root (racine), sera une map (carte) et englobera
+# l'intégralité du document. Cette map est l'équivalent d'un dictionnaire,
 # hash ou objet dans d'autres langages.
 clé: valeur
-aurtre_clé: une autre valeur
+autre_clé: une autre valeur
 valeur_numérique: 100
 notation_scientifique: 1e+12
-boolean: true
+booléen: true
 valeur_null: null
 clé avec espaces: valeur
-# Bien qu'il ne soit pas nécessaire d'enfermer les chaînes de caractères 
+# Bien qu'il ne soit pas nécessaire de mettre les chaînes de caractères
 # entre guillemets, cela reste possible, et parfois utile.
 toutefois: "Une chaîne, peut être contenue entre guillemets."
-"Une clé entre guillemets.": "Utile si on veut utiliser ':' dans la clé."
+"Une clé entre guillemets.": "Utile si l'on veut utiliser ':' dans la clé."
 
-# Les chaînes couvrant plusieurs lignes, peuvent être écrites au choix, 
-# comme un 'bloc littéral' ( avec | ) ou bien 'bloc replié' avec ( > ).
+# Les chaînes couvrant plusieurs lignes, peuvent être écrites au choix,
+# comme un "bloc littéral" (avec '|') ou bien un "bloc replié" (avec '>').
 bloc_littéral: |
-    Tout ce bloc de texte sera la valeur de la clé 'bloc_littéral', 
-    avec préservation des retours à la ligne. ( chaque ligne vide à 
-    l'intérieur du même bloc, sera remplacée par "\n\n" )
+    Tout ce bloc de texte sera la valeur de la clé "bloc_littéral", 
+    avec préservation des retours à la ligne.
 
     Le littéral continue jusqu'à ce que l'indentation soit annulée.
 
-        Toutes lignes qui serait "d'avantage indentées" conservent leur 
+        Toutes lignes qui seraient "davantage indentées" conservent leur
         indentation, constituée de 4 espaces.
 bloc_replié: >
-    Tout ce bloc de texte sera la valeur de la clé 'bloc_replié', mais 
-    cette fois ci, toutes les nouvelles lignes deviendront un simple espace.
+    Tout ce bloc de texte sera la valeur de la clé "bloc_replié", mais 
+    cette fois-ci, toutes les nouvelles lignes deviendront un simple espace.
 
-    Les lignes vides, comme ci-dessus, seront converties en caractère "\n".
+    Les lignes vides, comme ci-dessus, seront converties en caractère de
+    nouvelle ligne.
 
-        Les lignes 'plus-indentées' gardent leurs retours à la ligne - 
+        Les lignes "plus-indentées" gardent leurs retours à la ligne -
         ce texte apparaîtra sur deux lignes.
 
 ###############
 # COLLECTIONS #
 ###############
 
-# l'Imbrication est créée par indentation.
+# L'imbrication est créée par indentation.
 une_map_imbriquée:
     clé: valeur
     autre_clé: autre valeur
     autre_map_imbriquée:
         bonjour: bonjour
 
-# les Clés des Maps ne sont pas nécessairement des chaînes de caractères.
-0.25: une clé de type float
+# Les clés des maps ne sont pas nécessairement des chaînes de caractères.
+0.25: une clé de type flottant
 
-# les Clés peuvent également être des objets s'étendant sur plusieurs lignes, 
+# Les clés peuvent également être des objets s'étendant sur plusieurs lignes,
 # en utilisant le signe "?" pour indiquer le début de la clé.
 ? |
-    ceci est une Clé
+    ceci est une clé
     sur de multiples lignes
-: et ceci est sa Valeur
+: et ceci est sa valeur
 
 # YAML autorise aussi l'usage des collections à l'intérieur des clés,
 # mais certains langages de programmation ne le tolère pas si bien.
 
-# les Séquences (équivalent des listes ou tableaux) ressemblent à cela:
+# Les séquences (équivalent des listes ou tableaux) ressemblent à cela :
 une_séquence:
-    - Item 1
-    - Item 2
+    - Objet 1
+    - Objet 2
     - 0.5 # les séquences peuvent contenir des types variés.
-    - Item 4
+    - Objet 4
     - clé: valeur
       autre_clé: autre_valeur
     -
         - Ceci est une séquence
         - dans une autre séquence
 
-# YAML étant un proche parent de JSON, vous pouvez écrire directement 
+# YAML étant un proche parent de JSON, vous pouvez écrire directement
 # des maps et séquences façon JSON
 json_map: {"clé": "valeur"}
 json_seq: [1, 2, 3, "soleil"]
 
-#################################
+################################
 # AUTRES FONCTIONNALITÉES YAML #
-#################################
+################################
 
-# YAML possède une fonctionnalité fort utile nommée 'ancres'. Celle-ci 
+# YAML possède une fonctionnalité fort utile nommée "ancres". Celle-ci
 # vous permet de dupliquer aisément du contenu au sein de votre document.
 
-# Les deux clés suivantes auront la même valeur:
+# Les deux clés suivantes auront la même valeur :
 contenu_ancré: &nom_ancre Cette chaîne sera la valeur des deux clés.
 autre_ancre: *nom_ancre
 
-# Avec les Tags YAML, vous pouvez explicitement déclarer des types de données.
+# Avec les tags YAML, vous pouvez explicitement déclarer des types de données.
 chaine_explicite: !!str 0.5
 
-# Certains parsers implémentent des tags spécifiques à d'autres langages, 
-# comme par exemple le "complex number" de Python.
+# Certains analyseurs syntaxiques (parsers) implémentent des tags spécifiques à
+# d'autres langages, comme par exemple celui des nombres complexes de Python.
 python_complex_number: !!python/complex 1+2j
 
 #####################
@@ -122,7 +126,7 @@ python_complex_number: !!python/complex 1+2j
 #####################
 
 # YAML interprète également les données formatées ISO de type date et datetime,
-# pas seulement les chaînes et nombres. 
+# pas seulement les chaînes et nombres.
 datetime: 2001-12-15T02:59:43.1Z
 datetime_avec_espaces: 2001-12-14 21:59:43.10 -5
 date: 2002-12-14
@@ -135,14 +139,14 @@ fichier_gif: !!binary |
     +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
     AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
 
-# YAML a de même un type "set", qui ressemble à cela:
+# YAML a de même un type "set", semblable à ceci :
 set:
     ? item1
     ? item2
     ? item3
 
 # Comme dans Python, les sets ne sont que des maps contenant des valeurs null ;
-# le set précédent est l'équivalent du suivant:
+# le set précédent est l'équivalent du suivant :
 set2:
     item1: null
     item2: null
@@ -152,6 +156,6 @@ set2:
 
 Quelques références et outils :
 
-- Doc officielle [YAML 1.2](http://www.yaml.org/spec/1.2/spec.html) *anglais*,
+- Documentation officielle [YAML 1.2](http://www.yaml.org/spec/1.2/spec.html) *anglais*,
 - Une [Introduction à YAML](http://sweetohm.net/html/introduction-yaml.html) très bien construite et claire,
-- Un outil pour tester [live](http://yaml-online-parser.appspot.com/) la syntaxe YAML, avec des exemples.
+- Un outil pour tester [en ligne](http://yaml-online-parser.appspot.com/) la syntaxe YAML, avec des exemples.
-- 
cgit v1.2.3


From 1e90e7da1d042dfc46a5be11117a4e45e460bcf8 Mon Sep 17 00:00:00 2001
From: Andy B <andyjtbrown@gmail.com>
Date: Fri, 9 Oct 2015 15:32:05 +0100
Subject: [objective-c/en-fr-ru-tr-vn] Enable syntax highlighting

---
 fr-fr/objective-c-fr.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'fr-fr')

diff --git a/fr-fr/objective-c-fr.html.markdown b/fr-fr/objective-c-fr.html.markdown
index 69f4d8f9..4e31c4bf 100644
--- a/fr-fr/objective-c-fr.html.markdown
+++ b/fr-fr/objective-c-fr.html.markdown
@@ -14,7 +14,7 @@ lang: fr-fr
 
 L'Objective-C est un langage de programmation orienté objet réflexif principalement utilisé par Apple pour les systèmes d'exploitations Mac OS X et iOS et leurs frameworks respectifs, Cocoa et Cocoa Touch.
 
-```objective_c
+```objective-c
 // Les commentaires sur une seule ligne commencent par //
 
 /*
-- 
cgit v1.2.3


From 7c2c4480600b6c817418d5ba04315bca3c5a400d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Joa=CC=83o=20Costa?= <joao.costa@shiftforward.eu>
Date: Sat, 10 Oct 2015 16:49:53 +0100
Subject: Fix compile errors of the English and French Scala tutorials

---
 fr-fr/scala.html.markdown | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/scala.html.markdown b/fr-fr/scala.html.markdown
index a43edf16..c6d06361 100644
--- a/fr-fr/scala.html.markdown
+++ b/fr-fr/scala.html.markdown
@@ -208,6 +208,7 @@ sSquared.reduce (_+_)
 // La fonction filter prend un prédicat (une fonction de type A -> Booléen) et
 // sélectionne tous les éléments qui satisfont ce prédicat
 List(1, 2, 3) filter (_ > 2) // List(3)
+case class Person(name: String, age: Int)
 List(
   Person(name = "Dom", age = 23),
   Person(name = "Bob", age = 30)
@@ -217,6 +218,7 @@ List(
 
 // Scala a une méthode foreach définie pour certaines collections
 // qui prend en argument une fonction renvoyant Unit (une méthode void)
+val aListOfNumbers = List(1, 2, 3, 4, 10, 20, 100)
 aListOfNumbers foreach (x => println(x))
 aListOfNumbers foreach println
 
@@ -271,11 +273,12 @@ i    // Montre la valeur de i. Notez que while est une boucle au sens classique.
      // mais utiliser des combinateurs et des compréhensions comme ci-dessus est plus
      // facile pour comprendre et pour faire la parallélisation
 
+i = 0
 // La boucle do while
 do {
   println("x is still less then 10");
-  x += 1
-} while (x < 10)
+  i += 1
+} while (i < 10)
 
 
 // La récursivité est un moyen idiomatique de faire une chose répétitive en Scala.
@@ -370,7 +373,7 @@ val email(user, domain) = "henry@zkpr.com"
 
 "Les chaînes de caractères Scala sont entourées de doubles guillements"
 'a' // Un caractère de Scala
-'Les simples guillemets n'existent pas en Scala // Erreur
+// 'Les simples guillemets n'existent pas en Scala' // Erreur
 "Les chaînes de caractères possèdent les méthodes usuelles de Java".length
 "Il y a aussi quelques méthodes extra de Scala.".reverse
 
-- 
cgit v1.2.3


From 7281681a3e45e8103b771933b40920a292fc2818 Mon Sep 17 00:00:00 2001
From: Thibault iTech <tallancon@gmail.com>
Date: Sat, 10 Oct 2015 18:58:25 +0200
Subject: Added translation in french for the HAML article

---
 fr-fr/haml-fr.html.markdown | 156 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 156 insertions(+)
 create mode 100644 fr-fr/haml-fr.html.markdown

(limited to 'fr-fr')

diff --git a/fr-fr/haml-fr.html.markdown b/fr-fr/haml-fr.html.markdown
new file mode 100644
index 00000000..0267a380
--- /dev/null
+++ b/fr-fr/haml-fr.html.markdown
@@ -0,0 +1,156 @@
+---
+language: haml
+filename: learnhaml.haml
+contributors:
+  - ["Simon Neveu", "https://github.com/sneveu"]
+  - ["Thibault", "https://github.com/iTech-"]
+---
+
+Haml est un langage de balisage utilisé majoritairement avec Ruby, qui décrit de manière simple et propre le HTML de n'importe quelle page web sans l'utilisation des traditionnelles lignes de code. Le langage est une alternative très populaire au langage de templates Rails (.erb) et permet d'intégrer du code en Ruby dans votre balisage.
+
+Son but est de réduire le nombre de répétitions dans le balisage en fermant des balises pour vous en se basant sur l'indentation de votre code. Finalement, le balisage est bien structuré, ne contient pas de répétition, est logique et facile à lire.
+
+Vous pouvez aussi utiliser Haml sur un projet indépendant de Ruby, en installant les gems de Haml et en le convertissant en html grâce aux commandes.
+
+$ haml fichier_entree.haml fichier_sortie.html
+
+
+```haml
+/ -------------------------------------------
+/ Indentation 
+/ -------------------------------------------
+
+/
+  A cause de l'importance de l'indentation sur la manière dont votre code sera
+  converti, l'indentation doit être constante à travers votre document. Un 
+  simple changement d'indentation entrainera une erreur. En général, on utilise
+  deux espaces, mais ce genre de décision sur l'indentation vous appartient, du
+  moment que vous vous y tenez.
+
+/ -------------------------------------------
+/ Commentaires
+/ -------------------------------------------
+
+/ Ceci est un commentaire en Haml.
+
+/
+  Pour écrire un commentaire sur plusieurs lignes, indentez votre code
+  commenté en le commençant par un slash
+
+-# Ceci est un commentaire silencieux, qui n'apparaîtra pas dans le fichier
+
+
+/ -------------------------------------------
+/ Eléments HTML
+/ -------------------------------------------
+
+/ Pour écrire vos balises, utilisez un pourcentage suivi du nom de votre balise
+%body
+  %header
+    %nav
+
+/ Remarquez qu'il n'y a aucunes balises fermées. Le code produira alors ceci
+  <body>
+    <header>
+      <nav></nav>
+    </header>
+  </body>
+
+/ La balise div est l'élément par défaut, vous pouvez donc l'écrire comme ceci
+.balise
+
+/ Pour ajouter du contenu à votre balise, ajoutez le texte après sa déclaration
+%h1 Titre contenu
+
+/ Pour écrire du contenu sur plusieurs lignes, imbriquez le
+%p
+  Ce paragraphe contient beaucoup de contenu qui pourrait
+  probablement tenir sur deux lignes séparées.
+
+/
+  Vous pouvez utiliser des caractères html spéciaux en utilisant &=. Cela va
+  convertir les caractères comme &, /, : en leur équivalent HTML. Par exemple
+
+%p
+  &= "Oui & oui"
+
+/ Produira 'Oui &amp; oui'
+
+/ Vous pouvez écrire du contenu html sans qu'il soit converti en utilisant !=
+%p
+  != "Voici comment écrire une balise de paragraphe <p></p>"
+
+/ Cela produira 'Voici comment écrire une balise de paragraphe <p></p>'
+
+/ Une classe CSS peut être ajouté à votre balise en chainant le nom de la classe
+%div.truc.machin
+
+/ ou en utilisant un hash de Ruby
+%div{:class => 'truc machin'}
+
+/ Des attributs pour n'importe quelles balises peuvent être ajoutés au hash
+%a{:href => '#', :class => 'machin', :title => 'Titre machin'}
+
+/ Pour affecter une valeur à un booléen, utilisez 'true' 
+%input{:selected => true}
+
+/ Pour écrire des data-attributes, utilisez le :data avec la valeur d'un hash
+%div{:data => {:attribute => 'machin'}}
+
+
+/ -------------------------------------------
+/ Insérer du Ruby
+/ -------------------------------------------
+
+/
+  Pour transférer une valeur de Ruby comme contenu d'une balise, utilisez le
+  signe égal suivi du code Ruby
+
+%h1= livre.titre
+
+%p
+  = livre.auteur
+  = livre.editeur
+
+
+/ Pour lancer du code Ruby sans le convertir en HTML, utilisez un trait d'union
+- livres = ['livre 1', 'livre 2', 'livre 3']
+
+/ Ceci vous permet de faire des choses géniales comme des blocs Ruby
+- livre.shuffle.each_with_index do |livre, index|
+  %h1= livre 
+
+  if livre do
+    %p Ceci est un livre
+
+/
+  Encore une fois il n'est pas nécessaire d'ajouter une balise fermante, même
+  pour Ruby.
+  L'indentation le fera pour vous.
+
+
+/ -------------------------------------------
+/ Ruby en-ligne / Interpolation en Ruby
+/ -------------------------------------------
+
+/ Inclure une variable Ruby dans une ligne en utilisant #{}
+%p Votre meilleur score est #{record}
+
+
+/ -------------------------------------------
+/ Filtres
+/ -------------------------------------------
+
+/
+  Utilisez les deux points pour définir un filtre Haml, vous pouvez par exemple
+  utiliser un filtre :javascript pour écrire du contenu en-ligne js
+
+:javascript
+  console.log('Ceci est la balise en-ligne <script>');
+
+```
+
+## Lectures complémentaires
+
+- [Qu'est-ce que HAML ?](http://haml.info/) - Une bonne introduction qui explique très bien les avantages d'utiliser HAML.
+- [Documentation officielle](http://haml.info/docs/yardoc/file.REFERENCE.html) - Si vous souhaitez en apprendre plus et aller plus loin.
-- 
cgit v1.2.3


From e13909c73719203deb83881c7d70ed7b1ef5a64f Mon Sep 17 00:00:00 2001
From: Gnomino <gnomino@gnomino.eu>
Date: Sat, 10 Oct 2015 19:51:04 +0200
Subject: Added french translation for Python3

---
 fr-fr/python3-fr.html.markdown | 724 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 724 insertions(+)
 create mode 100644 fr-fr/python3-fr.html.markdown

(limited to 'fr-fr')

diff --git a/fr-fr/python3-fr.html.markdown b/fr-fr/python3-fr.html.markdown
new file mode 100644
index 00000000..2963a03f
--- /dev/null
+++ b/fr-fr/python3-fr.html.markdown
@@ -0,0 +1,724 @@
+---
+language: python3
+contributors:
+    - ["Louie Dinh", "http://pythonpracticeprojects.com"]
+    - ["Steven Basart", "http://github.com/xksteven"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
+    - ["Zachary Ferguson", "http://github.com/zfergus2"]
+filename: learnpython3-fr.py
+lang: fr-fr
+---
+
+Python was created by Guido Van Rossum in the early 90s. It is now one of the most popular
+languages in existence. I fell in love with Python for its syntactic clarity. It's basically
+executable pseudocode.
+Python a été créé par Guido Van Rossum au début des années 90. C'est maintenant un des 
+langages les populaires.Je suis tombé amoureux de Python pour la clarté de sa syntaxe.
+C'est tout simplement du pseudo-code éxécutable.
+
+L'auteur original apprécierait les retours ( en anglais ): vous pouvez le contacter sur Twitter à [@louiedinh](http://twitter.com/louiedinh) ou par mail à l'adresse louiedinh [at] [google's email service]
+
+Note : Cet article s'applique spécifiquement à Python 3. Jettez un coup d'oeil [ici](http://learnxinyminutes.com/docs/fr-fr/python-fr/) pour apprendre le vieux Python 2.7
+
+```python
+
+# Un commentaire d'une ligne commence par un dièse
+
+""" Les chaînes de caractère peuvent être écrites
+    avec 3 guillemets doubles ("), et sont souvent
+    utilisées comme des commentaires.
+"""
+
+####################################################
+## 1. Types de données primaires et opérateurs
+####################################################
+
+# On a des nombres
+3  # => 3
+
+# Les calculs sont ce à quoi on s'attend
+1 + 1  # => 2
+8 - 1  # => 7
+10 * 2  # => 20
+
+# Sauf pour la division qui retourne un float ( nombre à virgule flottante )
+35 / 5  # => 7.0
+
+# Résultats de divisions entières tronqués pour les nombres positifs et négatifs
+5 // 3     # => 1
+5.0 // 3.0 # => 1.0 # works on floats too
+-5 // 3  # => -2
+-5.0 // 3.0 # => -2.0
+
+# Quand on utilise un float, le résultat est un float
+3 * 2.0 # => 6.0
+
+# Modulo ( reste de la division )
+7 % 3 # => 1
+
+# Exponentiation (x**y, x élevé à la puissance y)
+2**4 # => 16
+
+# Forcer la priorité de calcul avec des parenthèses
+(1 + 3) * 2  # => 8
+
+# Les valeurs booléennes sont primitives
+True
+False
+
+# Négation avec not
+not True  # => False
+not False  # => True
+
+# Opérateurs booléens
+# On note que "and" et "or" sont sensibles à la casse
+True and False #=> False
+False or True #=> True
+
+# Utilisation des opérations booléennes avec des entiers :
+0 and 2 #=> 0
+-5 or 0 #=> -5
+0 == False #=> True
+2 == True #=> False
+1 == True #=> True
+
+# On vérifie une égalité avec ==
+1 == 1  # => True
+2 == 1  # => False
+
+# On vérifie une inégalité avec !=
+1 != 1  # => False
+2 != 1  # => True
+
+# Autres opérateurs de comparaison
+1 < 10  # => True
+1 > 10  # => False
+2 <= 2  # => True
+2 >= 2  # => True
+
+# On peut enchaîner les comparaisons
+1 < 2 < 3  # => True
+2 < 3 < 2  # => False
+
+# (is vs. ==) is vérifie si deux variables pointent sur le même objet, mais == vérifie
+# si les objets ont la même valeur.
+a = [1, 2, 3, 4] # a pointe sur une nouvelle liste, [1, 2, 3, 4]
+b = a # b pointe sur a
+b is a # => True, a et b pointent sur le même objet
+b == a # => True, les objets a et b sont égaux
+b = [1, 2, 3, 4] # b pointe sur une nouvelle liste, [1, 2, 3, 4]
+b is a # => False, a et b ne pointent pas sur le même objet
+b == a # => True, les objets a et b ne pointent pas sur le même objet
+
+# Les chaînes ( ou string ) sont créées avec " ou '
+"Ceci est une chaine"
+'Ceci est une chaine aussi.'
+
+# On peut additionner des chaînes aussi ! Mais essayez d'éviter de le faire.
+"Hello " + "world!"  # => "Hello world!"
+# On peut aussi le faire sans utiliser '+'
+"Hello " "world!"  # => "Hello world!"
+
+# On peut traîter une chaîne comme une liste de caractères
+"This is a string"[0]  # => 'T'
+
+# .format peut être utilisé pour formatter des chaînes, comme ceci:
+"{} peuvent etre {}".format("Les chaînes", "interpolées")
+
+# On peut aussi réutiliser le même argument pour gagner du temps.
+"{0} be nimble, {0} be quick, {0} jump over the {1}".format("Jack", "candle stick")
+#=> "Jack be nimble, Jack be quick, Jack jump over the candle stick"
+
+# On peut aussi utiliser des mots clés pour éviter de devoir compter.
+"{name} wants to eat {food}".format(name="Bob", food="lasagna") #=> "Bob wants to eat lasagna"
+
+# Si votre code doit aussi être compatible avec Python 2.5 et moins,
+# vous pouvez encore utiliser l'ancienne syntaxe :
+"Les %s peuvent être %s avec la %s méthode" % ("chaînes", "interpolées", "vieille")
+
+
+# None est un objet
+None  # => None
+
+# N'utilisez pas "==" pour comparer des objets à None
+# Utilisez plutôt "is". Cela permet de vérifier l'égalité de l'identité des objets.
+"etc" is None  # => False
+None is None  # => True
+
+# None, 0, and les strings/lists/dicts ( chaînes/listes/dictionnaires ) valent False lorsqu'ils sont convertis en booléens.
+# Toutes les autres valeurs valent True
+bool(0)  # => False
+bool("")  # => False
+bool([]) #=> False
+bool({}) #=> False
+
+
+####################################################
+## 2. Variables et Collections
+####################################################
+
+# Python a une fonction print pour afficher du texte
+print("I'm Python. Nice to meet you!")
+
+# Par défaut, la fonction print affiche aussi une nouvelle ligne à la fin.
+# Utilisez l'argument optionnel end pour changer ce caractère de fin.
+print("Hello, World", end="!") # => Hello, World!
+
+# Pas besoin de déclarer des variables avant de les définir.
+# La convention est de nommer ses variables avec des minuscules_et_underscores
+some_var = 5
+some_var  # => 5
+
+# Tenter d'accéder à une variable non définie lève une exception.
+# Voir Structures de contrôle pour en apprendre plus sur le traitement des exceptions.
+une_variable_inconnue  # Lève une NameError
+
+# Les listes permettent de stocker des séquences
+li = []
+# On peut initialiser une liste pré-remplie
+other_li = [4, 5, 6]
+
+# On ajoute des objets à la fin d'une liste avec .append
+li.append(1)    # li vaut maintenant [1]
+li.append(2)    # li vaut maintenant [1, 2]
+li.append(4)    # li vaut maintenant [1, 2, 4]
+li.append(3)    # li vaut maintenant [1, 2, 4, 3]
+# On enlève le dernier élément avec .pop
+li.pop()        # => 3 et li vaut maintenant [1, 2, 4]
+# Et on le remet
+li.append(3)    # li vaut de nouveau [1, 2, 4, 3]
+
+# Accès à un élément d'une liste :
+li[0]  # => 1
+# Accès au dernier élément :
+li[-1]  # => 3
+
+# Accéder à un élément en dehors des limites lève une IndexError
+li[4]  # Lève une IndexError
+
+# On peut accéder à une intervalle avec la syntaxe "slice"
+# (Pour les matheux, c'est un rang du type "fermé/ouvert")
+li[1:3]  # => [2, 4]
+# Omettre les deux premiers éléments
+li[2:]  # => [4, 3]
+# Prendre les trois premiers
+li[:3]  # => [1, 2, 4]
+# Sélectionner un élément sur deux
+li[::2]   # =>[1, 4]
+# Avoir une copie de la liste à l'envers
+li[::-1]   # => [3, 4, 2, 1]
+# Pour des "slices" plus élaborées :
+# li[debut:fin:pas]
+
+# Faire une copie d'une profondeur de un avec les "slices"
+li2 = li[:] # => li2 = [1, 2, 4, 3] mais (li2 is li) vaut False.
+
+# Enlever des éléments arbitrairement d'une liste
+del li[2]   # li is now [1, 2, 3]
+
+# On peut additionner des listes
+# Note: les valeurs de li et other_li ne sont pas modifiées.
+li + other_li   # => [1, 2, 3, 4, 5, 6]
+
+# Concaténer des listes avec "extend()"
+li.extend(other_li)   # Now li is [1, 2, 3, 4, 5, 6]
+
+# Vérifier la présence d'un objet dans une liste avec "in"
+1 in li   # => True
+
+# Examiner la longueur avec "len()"
+len(li)   # => 6
+
+
+# Les tuples sont comme des listes mais sont immuables.
+tup = (1, 2, 3)
+tup[0]   # => 1
+tup[0] = 3  # Lève une TypeError
+
+# Note : un tuple de taille un doit avoir une virgule après le dernier élément,
+# mais ce n'est pas le cas des tuples d'autres tailles, même zéro.
+type((1))  # => <class 'int'>
+type((1,)) # => <class 'tuple'>
+type(())   # => <class 'tuple'>
+
+# On peut utiliser la plupart des opérations des listes sur des tuples.
+len(tup)   # => 3
+tup + (4, 5, 6)   # => (1, 2, 3, 4, 5, 6)
+tup[:2]   # => (1, 2)
+2 in tup   # => True
+
+# Vous pouvez "dé-packager" des tuples (ou des listes) dans des variables
+a, b, c = (1, 2, 3)     # a vaut 1, b vaut 2 et c vaut 3
+# Les tuples sont créés par défaut sans parenthèses
+d, e, f = 4, 5, 6
+# Voyez comme il est facile d'intervertir deux valeurs :
+e, d = d, e     # d vaut maintenant 5 et e vaut maintenant 4
+
+
+# Créer un dictionnaire :
+empty_dict = {}
+# Un dictionnaire pré-rempli :
+filled_dict = {"one": 1, "two": 2, "three": 3}
+
+# Note : les clés des dictionnaires doivent être de types immuables.
+# Elles doivent être convertibles en une valeur constante pour une recherche rapide.
+# Les types immuables incluent les ints, floats, strings et tuples.
+invalid_dict = {[1,2,3]: "123"} # => Lève une TypeError: unhashable type: 'list'
+valid_dict = {(1,2,3):[1,2,3]}  # Par contre, les valeurs peuvent être de tout type.
+
+# On trouve une valeur avec []
+filled_dict["one"]   # => 1
+
+# On obtient toutes les clés sous forme d'un itérable avec "keys()" Il faut l'entourer
+# de list() pour avoir une liste Note: l'ordre n'est pas garanti.
+list(filled_dict.keys())   # => ["three", "two", "one"]
+
+
+# On obtient toutes les valeurs sous forme d'un itérable avec "values()". 
+# Là aussi, il faut utiliser list() pour avoir une liste.
+# Note : l'ordre n'est toujours pas garanti.
+list(filled_dict.values())   # => [3, 2, 1]
+
+
+# On vérifie la présence d'une clé dans un dictionnaire avec "in"
+"one" in filled_dict   # => True
+1 in filled_dict   # => False
+
+# L'accès à une clé non-existente lève une KeyError
+filled_dict["four"]   # KeyError
+
+# On utilise "get()" pour éviter la KeyError
+filled_dict.get("one")   # => 1
+filled_dict.get("four")   # => None
+# La méthode get accepte une valeur de retour par défaut en cas de valeur non-existante.
+filled_dict.get("one", 4)   # => 1
+filled_dict.get("four", 4)   # => 4
+
+# "setdefault()" insère une valeur dans un dictionnaire si la clé n'est pas présente.
+filled_dict.setdefault("five", 5)  # filled_dict["five"] devient 5
+filled_dict.setdefault("five", 6)  # filled_dict["five"] est toujours 5
+
+# Ajouter à un dictionnaire
+filled_dict.update({"four":4}) #=> {"one": 1, "two": 2, "three": 3, "four": 4}
+#filled_dict["four"] = 4  # une autre méthode
+
+# Enlever des clés d'un dictionnaire avec del
+del filled_dict["one"]  # Enlever la clé "one" de filled_dict.
+
+
+# Les sets stockent ... des sets
+empty_set = set()
+# Initialiser un set avec des valeurs. Oui, ça ressemble aux dictionnaires, désolé.
+some_set = {1, 1, 2, 2, 3, 4}   # some_set est maintenant {1, 2, 3, 4}
+
+# Comme les clés d'un dictionnaire, les éléments d'un set doivent être immuables.
+invalid_set = {[1], 1} # => Lève une TypeError: unhashable type: 'list'
+valid_set = {(1,), 1}
+
+# On peut changer un set :
+filled_set = some_set
+
+# Ajouter un objet au set :
+filled_set.add(5)   # filled_set vaut maintenant {1, 2, 3, 4, 5}
+
+# Chercher les intersections de deux sets avec &
+other_set = {3, 4, 5, 6}
+filled_set & other_set   # => {3, 4, 5}
+
+# On fait l'union de sets avec |
+filled_set | other_set   # => {1, 2, 3, 4, 5, 6}
+
+# On fait la différence de deux sets avec -
+{1, 2, 3, 4} - {2, 3, 5}   # => {1, 4}
+
+# On vérifie la présence d'un objet dans un set avec in
+2 in filled_set   # => True
+10 in filled_set   # => False
+
+
+
+####################################################
+## 3. Structures de contrôle et Itérables
+####################################################
+
+# On créée juste une variable
+some_var = 5
+
+# Voici une condition "si". L'indentation est significative en Python!
+# Affiche: "some_var is smaller than 10"
+if some_var > 10:
+    print("some_var is totally bigger than 10.")
+elif some_var < 10:    # La clause elif ("sinon si") est optionelle
+    print("some_var is smaller than 10.")
+else:                  # La clause else ("sinon") l'est aussi.
+    print("some_var is indeed 10.")
+
+
+"""
+Les boucles "for" itèrent sur une liste
+Affiche:
+    chien est un mammifère
+    chat est un mammifère
+    souris est un mammifère
+"""
+for animal in ["chien", "chat", "souris"]:
+    # On peut utiliser format() pour interpoler des chaînes formattées
+    print("{} est un mammifère".format(animal))
+
+"""
+"range(nombre)" retourne un itérable de nombres
+de zéro au nombre donné
+Affiche:
+    0
+    1
+    2
+    3
+"""
+for i in range(4):
+    print(i)
+
+"""
+"range(debut, fin)" retourne un itérable de nombre
+de debut à fin.
+Affiche:
+    4
+    5
+    6
+    7
+"""
+for i in range(4, 8):
+    print(i)
+
+"""
+"range(debut, fin, pas)" retourne un itérable de nombres
+de début à fin en incrémentant de pas.
+Si le pas n'est pas indiqué, la valeur par défaut est 1.
+Affiche:
+    4
+    6
+    8
+"""
+for i in range(4, 8, 2):
+    print(i)
+"""
+
+Les boucles "while" bouclent jusqu'à ce que la condition devienne fausse.
+Affiche:
+    0
+    1
+    2
+    3
+"""
+x = 0
+while x < 4:
+    print(x)
+    x += 1  # Raccourci pour x = x + 1
+
+# On gère les exceptions avec un bloc try/except
+try:
+    # On utilise "raise" pour lever une erreur
+    raise IndexError("Ceci est une erreur d'index")
+except IndexError as e:
+    pass    # Pass signifie simplement "ne rien faire". Généralement, on gère l'erreur ici.
+except (TypeError, NameError):
+    pass    # Si besoin, on peut aussi gérer plusieurs erreurs en même temps.
+else:   # Clause optionelle des blocs try/except. Doit être après tous les except.
+    print("Tout va bien!")   # Uniquement si aucune exception n'est levée.
+finally: #  Éxécuté dans toutes les circonstances.
+    print("On nettoie les ressources ici")
+
+# Au lieu de try/finally pour nettoyer les ressources, on peut utiliser with
+with open("myfile.txt") as f:
+    for line in f:
+        print(line)
+
+# Python offre une abstraction fondamentale : l'Iterable.
+# Un itérable est un objet pouvant être traîté comme une séquence.
+# L'objet retourné par la fonction range() est un itérable.
+
+filled_dict = {"one": 1, "two": 2, "three": 3}
+our_iterable = filled_dict.keys()
+print(our_iterable) #=> range(1,10). C'est un objet qui implémente l'interface Iterable
+
+# On peut boucler dessus
+for i in our_iterable:
+    print(i)    # Affiche one, two, three
+
+# Cependant, on ne peut pas accéder aux éléments par leur adresse.
+our_iterable[1]  # Lève une TypeError
+
+# Un itérable est un objet qui sait créer un itérateur.
+our_iterator = iter(our_iterable)
+
+# Notre itérateur est un objet qui se rappelle de notre position quand on le traverse.
+# On passe à l'élément suivant avec "next()".
+next(our_iterator)  #=> "one"
+
+# Il garde son état quand on itère.
+next(our_iterator)  #=> "two"
+next(our_iterator)  #=> "three"
+
+# Après que l'itérateur a retourné toutes ses données, il lève une exception StopIterator
+next(our_iterator) # Lève une StopIteration
+
+# On peut mettre tous les éléments d'un itérateur dans une liste avec list()
+list(filled_dict.keys())  #=> Returns ["one", "two", "three"]
+
+
+####################################################
+## 4. Fonctions
+####################################################
+
+# On utilise "def" pour créer des fonctions
+def add(x, y):
+    print("x est {} et y est {}".format(x, y))
+    return x + y    # On retourne une valeur avec return
+
+# Appel d'une fonction avec des paramètres :
+add(5, 6)   # => affiche "x est 5 et y est 6" et retourne 11
+
+# Une autre manière d'appeller une fonction : avec des arguments
+add(y=6, x=5)   # Les arguments peuvent être dans n'importe quel ordre.
+
+# Définir une fonction qui prend un nombre variable d'arguments
+def varargs(*args):
+    return args
+
+varargs(1, 2, 3)   # => (1, 2, 3)
+
+# On peut aussi définir une fonction qui prend un nombre variable de paramètres.
+def keyword_args(**kwargs):
+    return kwargs
+
+# Appelons la pour voir ce qu'il se passe :
+keyword_args(big="foot", loch="ness")   # => {"big": "foot", "loch": "ness"}
+
+
+# On peut aussi faire les deux à la fois :
+def all_the_args(*args, **kwargs):
+    print(args)
+    print(kwargs)
+"""
+all_the_args(1, 2, a=3, b=4) affiche:
+    (1, 2)
+    {"a": 3, "b": 4}
+"""
+
+# En appelant des fonctions, on peut aussi faire l'inverse :
+# utiliser * pour étendre un tuple de paramètres 
+# et ** pour étendre un dictionnaire d'arguments.
+args = (1, 2, 3, 4)
+kwargs = {"a": 3, "b": 4}
+all_the_args(*args)   # équivalent à foo(1, 2, 3, 4)
+all_the_args(**kwargs)   # équivalent à foo(a=3, b=4)
+all_the_args(*args, **kwargs)   # équivalent à foo(1, 2, 3, 4, a=3, b=4)
+
+# Retourne plusieurs valeurs ( avec un tuple )
+def swap(x, y):
+    return y, x # Retourne plusieurs valeurs avec un tuple sans parenthèses.
+                # (Note: on peut aussi utiliser des parenthèses)
+
+x = 1
+y = 2
+x, y = swap(x, y) # => x = 2, y = 1
+# (x, y) = swap(x,y) # Là aussi, rien ne nous empêche d'ajouter des parenthèses
+
+# Portée des fonctions :
+x = 5
+
+def setX(num):
+    # La variable locale x n'est pas la même que la variable globale x
+    x = num # => 43
+    print (x) # => 43
+
+def setGlobalX(num):
+    global x
+    print (x) # => 5
+    x = num # la variable globale x est maintenant 6
+    print (x) # => 6
+
+setX(43)
+setGlobalX(6)
+
+
+# Python a des fonctions de première classe
+def create_adder(x):
+    def adder(y):
+        return x + y
+    return adder
+
+add_10 = create_adder(10)
+add_10(3)   # => 13
+
+# Mais aussi des fonctions anonymes
+(lambda x: x > 2)(3)   # => True
+(lambda x, y: x ** 2 + y ** 2)(2, 1) # => 5
+
+# TODO - Fix for iterables
+# Il y a aussi des fonctions de base
+map(add_10, [1, 2, 3])   # => [11, 12, 13]
+map(max, [1, 2, 3], [4, 2, 1])   # => [4, 2, 3]
+
+filter(lambda x: x > 5, [3, 4, 5, 6, 7])   # => [6, 7]
+
+# On peut utiliser les compréhensions de listes pour de jolies maps et filtres.
+# Une compréhension de liste stocke la sortie comme une liste qui peut elle même être une liste imbriquée.
+[add_10(i) for i in [1, 2, 3]]  # => [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5]   # => [6, 7]
+
+####################################################
+## 5. Classes
+####################################################
+
+
+# On hérite de object pour créer une classe
+class Human(object):
+
+    # Un attribut de la classe. Il est partagé par toutes les instances de la classe.
+    species = "H. sapiens"
+
+    # L'initialiseur de base. Il est appelé quand la classe est instanciée.
+    # Note : les doubles underscores au début et à la fin sont utilisés pour
+    # les fonctions et attributs utilisés par Python mais contrôlés par l'utilisateur.
+    # Les méthodes (ou objets ou attributs) comme: __init__, __str__,
+    # __repr__ etc. sont appelés méthodes magiques.
+    # Vous ne devriez pas inventer de noms de ce style.
+    def __init__(self, name):
+        # Assigner l'argument à l'attribut de l'instance
+        self.name = name
+
+    # Une méthode de l'instance. Toutes prennent "self" comme premier argument.
+    def say(self, msg):
+        return "{name}: {message}".format(name=self.name, message=msg)
+
+    # Une méthode de classe est partagée avec entre les instances
+    # Ils sont appelés avec la classe comme premier argument
+    @classmethod
+    def get_species(cls):
+        return cls.species
+
+    # Une méthode statique est appelée sans référence à une instance ni à une classe.
+    @staticmethod
+    def grunt():
+        return "*grunt*"
+
+
+# Instantier une classe
+i = Human(name="Ian")
+print(i.say("hi"))     # affiche "Ian: hi"
+
+j = Human("Joel")
+print(j.say("hello"))  # affiche "Joel: hello"
+
+# Appeller notre méthode de classe
+i.get_species()   # => "H. sapiens"
+
+# Changer les attributs partagés
+Human.species = "H. neanderthalensis"
+i.get_species()   # => "H. neanderthalensis"
+j.get_species()   # => "H. neanderthalensis"
+
+# Appeller la méthode statique
+Human.grunt()   # => "*grunt*"
+
+
+####################################################
+## 6. Modules
+####################################################
+
+# On peut importer des modules
+import math
+print(math.sqrt(16))  # => 4
+
+# On peut importer des fonctions spécifiques d'un module
+from math import ceil, floor
+print(ceil(3.7))  # => 4.0
+print(floor(3.7))   # => 3.0
+
+# On peut importer toutes les fonctions d'un module
+# Attention: ce n'est pas recommandé.
+from math import *
+
+# On peut raccourcir un nom de module
+import math as m
+math.sqrt(16) == m.sqrt(16)   # => True
+
+# Les modules Python sont juste des fichiers Python.
+# Vous pouvez écrire les vôtres et les importer. Le nom du module
+# est le nom du fichier.
+
+# On peut voir quels fonctions et objets un module définit
+import math
+dir(math)
+
+
+####################################################
+## 7. Avancé
+####################################################
+
+# Les générateurs aident à faire du code paresseux (lazy)
+def double_numbers(iterable):
+    for i in iterable:
+        yield i + i
+
+# Un générateur créé des valeurs à la volée.
+# Au lieu de générer et retourner toutes les valeurs en une fois, il en crée une à chaque
+# itération.  Cela signifie que les valeurs supérieures à 15 ne seront pas traîtées par
+# double_numbers.
+# Note : range est un générateur aussi. 
+# Créer une liste 1-900000000 prendrait beaucoup de temps
+# On met un underscore à la fin d'un nom de variable normalement réservé par Python.
+range_ = range(1, 900000000)
+# Double tous les nombres jusqu'à ce qu'un nombre >=30 soit trouvé
+for i in double_numbers(range_):
+    print(i)
+    if i >= 30:
+        break
+
+
+# Decorateurs
+# Dans cet exemple, beg enveloppe say
+# Beg appellera say. Si say_please vaut True le message retourné sera changé
+from functools import wraps
+
+
+def beg(target_function):
+    @wraps(target_function)
+    def wrapper(*args, **kwargs):
+        msg, say_please = target_function(*args, **kwargs)
+        if say_please:
+            return "{} {}".format(msg, "Please! I am poor :(")
+        return msg
+
+    return wrapper
+
+
+@beg
+def say(say_please=False):
+    msg = "Can you buy me a beer?"
+    return msg, say_please
+
+
+print(say())  # affiche Can you buy me a beer?
+print(say(say_please=True))  # affiche Can you buy me a beer? Please! I am poor :(
+```
+
+## Prêt pour encore plus ?
+
+### En ligne et gratuit ( en anglais )
+
+* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
+* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+* [Dive Into Python](http://www.diveintopython.net/)
+* [Ideas for Python Projects](http://pythonpracticeprojects.com)
+* [The Official Docs](http://docs.python.org/3/)
+* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
+* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
+* [Python Course](http://www.python-course.eu/index.php)
+* [First Steps With Python](https://realpython.com/learn/python-first-steps/)
+
+### Livres ( en anglais )
+
+* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
+* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
+* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
-- 
cgit v1.2.3


From 7f07379cfb8aeeffae49b857dda272d646ae5e48 Mon Sep 17 00:00:00 2001
From: Gnomino <gnomino@gnomino.eu>
Date: Sat, 10 Oct 2015 19:58:16 +0200
Subject: Removed leftovers, added Gnomino to the translators of Python3-FR

---
 fr-fr/python3-fr.html.markdown | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/python3-fr.html.markdown b/fr-fr/python3-fr.html.markdown
index 2963a03f..21aa5be5 100644
--- a/fr-fr/python3-fr.html.markdown
+++ b/fr-fr/python3-fr.html.markdown
@@ -5,13 +5,12 @@ contributors:
     - ["Steven Basart", "http://github.com/xksteven"]
     - ["Andre Polykanine", "https://github.com/Oire"]
     - ["Zachary Ferguson", "http://github.com/zfergus2"]
+translators:
+    - ["Gnomino", "https://github.com/Gnomino"]
 filename: learnpython3-fr.py
 lang: fr-fr
 ---
 
-Python was created by Guido Van Rossum in the early 90s. It is now one of the most popular
-languages in existence. I fell in love with Python for its syntactic clarity. It's basically
-executable pseudocode.
 Python a été créé par Guido Van Rossum au début des années 90. C'est maintenant un des 
 langages les populaires.Je suis tombé amoureux de Python pour la clarté de sa syntaxe.
 C'est tout simplement du pseudo-code éxécutable.
-- 
cgit v1.2.3


From 7a3babacd7f52dd82f9b443bc6e371fbc96e4835 Mon Sep 17 00:00:00 2001
From: Gnomino <gnomino@gnomino.eu>
Date: Sat, 10 Oct 2015 20:05:33 +0200
Subject: Removed spaces in parenthesis

---
 fr-fr/python3-fr.html.markdown | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/python3-fr.html.markdown b/fr-fr/python3-fr.html.markdown
index 21aa5be5..f826c4f6 100644
--- a/fr-fr/python3-fr.html.markdown
+++ b/fr-fr/python3-fr.html.markdown
@@ -15,7 +15,7 @@ Python a été créé par Guido Van Rossum au début des années 90. C'est maint
 langages les populaires.Je suis tombé amoureux de Python pour la clarté de sa syntaxe.
 C'est tout simplement du pseudo-code éxécutable.
 
-L'auteur original apprécierait les retours ( en anglais ): vous pouvez le contacter sur Twitter à [@louiedinh](http://twitter.com/louiedinh) ou par mail à l'adresse louiedinh [at] [google's email service]
+L'auteur original apprécierait les retours (en anglais): vous pouvez le contacter sur Twitter à [@louiedinh](http://twitter.com/louiedinh) ou par mail à l'adresse louiedinh [at] [google's email service]
 
 Note : Cet article s'applique spécifiquement à Python 3. Jettez un coup d'oeil [ici](http://learnxinyminutes.com/docs/fr-fr/python-fr/) pour apprendre le vieux Python 2.7
 
@@ -40,7 +40,7 @@ Note : Cet article s'applique spécifiquement à Python 3. Jettez un coup d'oeil
 8 - 1  # => 7
 10 * 2  # => 20
 
-# Sauf pour la division qui retourne un float ( nombre à virgule flottante )
+# Sauf pour la division qui retourne un float (nombre à virgule flottante)
 35 / 5  # => 7.0
 
 # Résultats de divisions entières tronqués pour les nombres positifs et négatifs
@@ -52,7 +52,7 @@ Note : Cet article s'applique spécifiquement à Python 3. Jettez un coup d'oeil
 # Quand on utilise un float, le résultat est un float
 3 * 2.0 # => 6.0
 
-# Modulo ( reste de la division )
+# Modulo (reste de la division)
 7 % 3 # => 1
 
 # Exponentiation (x**y, x élevé à la puissance y)
@@ -109,7 +109,7 @@ b = [1, 2, 3, 4] # b pointe sur une nouvelle liste, [1, 2, 3, 4]
 b is a # => False, a et b ne pointent pas sur le même objet
 b == a # => True, les objets a et b ne pointent pas sur le même objet
 
-# Les chaînes ( ou string ) sont créées avec " ou '
+# Les chaînes (ou strings) sont créées avec " ou '
 "Ceci est une chaine"
 'Ceci est une chaine aussi.'
 
@@ -144,7 +144,7 @@ None  # => None
 "etc" is None  # => False
 None is None  # => True
 
-# None, 0, and les strings/lists/dicts ( chaînes/listes/dictionnaires ) valent False lorsqu'ils sont convertis en booléens.
+# None, 0, and les strings/lists/dicts (chaînes/listes/dictionnaires) valent False lorsqu'ils sont convertis en booléens.
 # Toutes les autres valeurs valent True
 bool(0)  # => False
 bool("")  # => False
@@ -512,7 +512,7 @@ all_the_args(*args)   # équivalent à foo(1, 2, 3, 4)
 all_the_args(**kwargs)   # équivalent à foo(a=3, b=4)
 all_the_args(*args, **kwargs)   # équivalent à foo(1, 2, 3, 4, a=3, b=4)
 
-# Retourne plusieurs valeurs ( avec un tuple )
+# Retourne plusieurs valeurs (avec un tuple)
 def swap(x, y):
     return y, x # Retourne plusieurs valeurs avec un tuple sans parenthèses.
                 # (Note: on peut aussi utiliser des parenthèses)
@@ -704,7 +704,7 @@ print(say(say_please=True))  # affiche Can you buy me a beer? Please! I am poor
 
 ## Prêt pour encore plus ?
 
-### En ligne et gratuit ( en anglais )
+### En ligne et gratuit (en anglais)
 
 * [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
 * [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
@@ -716,7 +716,7 @@ print(say(say_please=True))  # affiche Can you buy me a beer? Please! I am poor
 * [Python Course](http://www.python-course.eu/index.php)
 * [First Steps With Python](https://realpython.com/learn/python-first-steps/)
 
-### Livres ( en anglais )
+### Livres (en anglais)
 
 * [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
 * [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
-- 
cgit v1.2.3


From 0a599281c3f35e8987e488f6ace6aab789617aa7 Mon Sep 17 00:00:00 2001
From: Gnomino <gnomino@gnomino.eu>
Date: Sat, 10 Oct 2015 20:11:50 +0200
Subject: Corrected spelling mistakes

---
 fr-fr/python3-fr.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/python3-fr.html.markdown b/fr-fr/python3-fr.html.markdown
index f826c4f6..13e453f4 100644
--- a/fr-fr/python3-fr.html.markdown
+++ b/fr-fr/python3-fr.html.markdown
@@ -340,7 +340,7 @@ filled_set | other_set   # => {1, 2, 3, 4, 5, 6}
 ## 3. Structures de contrôle et Itérables
 ####################################################
 
-# On créée juste une variable
+# On crée juste une variable
 some_var = 5
 
 # Voici une condition "si". L'indentation est significative en Python!
@@ -660,7 +660,7 @@ def double_numbers(iterable):
     for i in iterable:
         yield i + i
 
-# Un générateur créé des valeurs à la volée.
+# Un générateur crée des valeurs à la volée.
 # Au lieu de générer et retourner toutes les valeurs en une fois, il en crée une à chaque
 # itération.  Cela signifie que les valeurs supérieures à 15 ne seront pas traîtées par
 # double_numbers.
-- 
cgit v1.2.3


From aad7eb82dd34c53dcdf15a8ea34dbee0df066bcc Mon Sep 17 00:00:00 2001
From: Gnomino <gnomino@gnomino.eu>
Date: Sun, 11 Oct 2015 10:34:18 +0200
Subject: Corrected french mistakes

---
 fr-fr/python3-fr.html.markdown | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/python3-fr.html.markdown b/fr-fr/python3-fr.html.markdown
index 13e453f4..b687143c 100644
--- a/fr-fr/python3-fr.html.markdown
+++ b/fr-fr/python3-fr.html.markdown
@@ -12,7 +12,7 @@ lang: fr-fr
 ---
 
 Python a été créé par Guido Van Rossum au début des années 90. C'est maintenant un des 
-langages les populaires.Je suis tombé amoureux de Python pour la clarté de sa syntaxe.
+langages les populaires. Je suis tombé amoureux de Python pour la clarté de sa syntaxe.
 C'est tout simplement du pseudo-code éxécutable.
 
 L'auteur original apprécierait les retours (en anglais): vous pouvez le contacter sur Twitter à [@louiedinh](http://twitter.com/louiedinh) ou par mail à l'adresse louiedinh [at] [google's email service]
@@ -23,7 +23,7 @@ Note : Cet article s'applique spécifiquement à Python 3. Jettez un coup d'oeil
 
 # Un commentaire d'une ligne commence par un dièse
 
-""" Les chaînes de caractère peuvent être écrites
+""" Les chaînes de caractères peuvent être écrites
     avec 3 guillemets doubles ("), et sont souvent
     utilisées comme des commentaires.
 """
@@ -196,7 +196,7 @@ li[-1]  # => 3
 li[4]  # Lève une IndexError
 
 # On peut accéder à une intervalle avec la syntaxe "slice"
-# (Pour les matheux, c'est un rang du type "fermé/ouvert")
+# (c'est un rang du type "fermé/ouvert")
 li[1:3]  # => [2, 4]
 # Omettre les deux premiers éléments
 li[2:]  # => [4, 3]
@@ -246,7 +246,7 @@ tup + (4, 5, 6)   # => (1, 2, 3, 4, 5, 6)
 tup[:2]   # => (1, 2)
 2 in tup   # => True
 
-# Vous pouvez "dé-packager" des tuples (ou des listes) dans des variables
+# Vous pouvez décomposer des tuples (ou des listes) dans des variables
 a, b, c = (1, 2, 3)     # a vaut 1, b vaut 2 et c vaut 3
 # Les tuples sont créés par défaut sans parenthèses
 d, e, f = 4, 5, 6
@@ -305,7 +305,7 @@ filled_dict.update({"four":4}) #=> {"one": 1, "two": 2, "three": 3, "four": 4}
 del filled_dict["one"]  # Enlever la clé "one" de filled_dict.
 
 
-# Les sets stockent ... des sets
+# Les sets stockent des ensembles
 empty_set = set()
 # Initialiser un set avec des valeurs. Oui, ça ressemble aux dictionnaires, désolé.
 some_set = {1, 1, 2, 2, 3, 4}   # some_set est maintenant {1, 2, 3, 4}
-- 
cgit v1.2.3


From 097c839b7bbf03dd2ee50c9ccabde147e6bf285e Mon Sep 17 00:00:00 2001
From: Gnomino <gnomino@gnomino.eu>
Date: Sun, 11 Oct 2015 13:47:44 +0200
Subject: Changed way of creating classes

---
 fr-fr/python3-fr.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/python3-fr.html.markdown b/fr-fr/python3-fr.html.markdown
index b687143c..22256efc 100644
--- a/fr-fr/python3-fr.html.markdown
+++ b/fr-fr/python3-fr.html.markdown
@@ -570,8 +570,8 @@ filter(lambda x: x > 5, [3, 4, 5, 6, 7])   # => [6, 7]
 ####################################################
 
 
-# On hérite de object pour créer une classe
-class Human(object):
+# On utilise l'opérateur "classe" pour définir une classe
+class Human:
 
     # Un attribut de la classe. Il est partagé par toutes les instances de la classe.
     species = "H. sapiens"
-- 
cgit v1.2.3


From e6aa293c3afca8ff429a9f676d0807829e88106c Mon Sep 17 00:00:00 2001
From: Gnomino <gnomino@gnomino.eu>
Date: Sun, 11 Oct 2015 19:10:40 +0200
Subject: Corrected a spelling mistake

---
 fr-fr/python3-fr.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'fr-fr')

diff --git a/fr-fr/python3-fr.html.markdown b/fr-fr/python3-fr.html.markdown
index 22256efc..04d0a55d 100644
--- a/fr-fr/python3-fr.html.markdown
+++ b/fr-fr/python3-fr.html.markdown
@@ -13,7 +13,7 @@ lang: fr-fr
 
 Python a été créé par Guido Van Rossum au début des années 90. C'est maintenant un des 
 langages les populaires. Je suis tombé amoureux de Python pour la clarté de sa syntaxe.
-C'est tout simplement du pseudo-code éxécutable.
+C'est tout simplement du pseudo-code exécutable.
 
 L'auteur original apprécierait les retours (en anglais): vous pouvez le contacter sur Twitter à [@louiedinh](http://twitter.com/louiedinh) ou par mail à l'adresse louiedinh [at] [google's email service]
 
-- 
cgit v1.2.3


From dff456bb6de20f6b0ab5d9c1d9abfe43449e2606 Mon Sep 17 00:00:00 2001
From: evuez <helloevuez@gmail.com>
Date: Tue, 13 Oct 2015 13:42:29 +0200
Subject: Add lang to header

Header configuration was missing `lang` field.
---
 fr-fr/haml-fr.html.markdown | 1 +
 1 file changed, 1 insertion(+)

(limited to 'fr-fr')

diff --git a/fr-fr/haml-fr.html.markdown b/fr-fr/haml-fr.html.markdown
index 0267a380..24be8bf9 100644
--- a/fr-fr/haml-fr.html.markdown
+++ b/fr-fr/haml-fr.html.markdown
@@ -4,6 +4,7 @@ filename: learnhaml.haml
 contributors:
   - ["Simon Neveu", "https://github.com/sneveu"]
   - ["Thibault", "https://github.com/iTech-"]
+lang: fr-fr
 ---
 
 Haml est un langage de balisage utilisé majoritairement avec Ruby, qui décrit de manière simple et propre le HTML de n'importe quelle page web sans l'utilisation des traditionnelles lignes de code. Le langage est une alternative très populaire au langage de templates Rails (.erb) et permet d'intégrer du code en Ruby dans votre balisage.
-- 
cgit v1.2.3


From 9a966716423ecb85f410980b39504a0ca4a45715 Mon Sep 17 00:00:00 2001
From: Rafik NACCACHE <rafik@tnteam.rocks>
Date: Fri, 16 Oct 2015 15:44:30 +0100
Subject: Add documentation about Threading Macros

---
 fr-fr/clojure-fr.html.markdown | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

(limited to 'fr-fr')

diff --git a/fr-fr/clojure-fr.html.markdown b/fr-fr/clojure-fr.html.markdown
index d3c5a67b..25911ea8 100644
--- a/fr-fr/clojure-fr.html.markdown
+++ b/fr-fr/clojure-fr.html.markdown
@@ -248,7 +248,7 @@ keymap ; => {:a 1, :b 2, :c 3}
 
 ; Il y a encore d'autres fonctions dans l'espace de nom clojure.sets.
 
-; Formes utiles
+; Formes et macros utiles
 ;;;;;;;;;;;;;;;
 
 ; Les constructions logiques en Clojure sont juste des macros, et
@@ -275,6 +275,22 @@ ressemblent à toutes les autres formes:
 (let [name "Urkel"]
   (print "Saying hello to " name)
   (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel")
+  
+; Utilisez les Threading Macros (-> et ->>) pour exprimer plus clairement vos transformations, en y pensant de manière multi-niveaux:
+; La "flèche simple" ou "Thread-first", insère, à chaque niveau de la transformation, la forme courante en la seconde position de la forme suivante, constituant à chaque fois un nouvel étage de transformation.Par exemple:
+(->  
+   {:a 1 :b 2} 
+   (assoc :c 3) ;=> Génère ici (assoc {:a 1 :b 2} :c 3)
+   (dissoc :b)) ;=> Génère ici (dissoc (assoc {:a 1 :b 2} :c 3) :b)
+; Cette expression est ré-écrite en: (dissoc (assoc {:a 1 :b 2} :c 3) :b) et est évaluée en : {:a 1 :c 3}
+; La "flèche double" ou "Thread-last" procède de la même manière que "->", mais insère le résultat de la réécriture de chaque étage en dernière position. Par exemple:
+(->>
+   (range 10)
+   (map inc)     ;=> Génère ici (map inc (range 10)
+   (filter odd?) ;=> Génère ici (filter odd? (map inc (range 10))
+   (into []))    ;=> Génère ici (into [] (filter odd? (map inc (range 10))), ce qui est évalué au final à;
+                 ; [1 3 5 7 9]
+
 
 ; Modules
 ;;;;;;;;;;;;;;;
-- 
cgit v1.2.3


From 85fa357b8a3e441e5c160f18ca6d19cdea7d0160 Mon Sep 17 00:00:00 2001
From: Adam Bard <github@adambard.com>
Date: Sun, 18 Oct 2015 00:26:19 +0800
Subject: Update clojure-fr.html.markdown

---
 fr-fr/clojure-fr.html.markdown | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/clojure-fr.html.markdown b/fr-fr/clojure-fr.html.markdown
index 25911ea8..1cedda1d 100644
--- a/fr-fr/clojure-fr.html.markdown
+++ b/fr-fr/clojure-fr.html.markdown
@@ -276,12 +276,14 @@ ressemblent à toutes les autres formes:
   (print "Saying hello to " name)
   (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel")
   
-; Utilisez les Threading Macros (-> et ->>) pour exprimer plus clairement vos transformations, en y pensant de manière multi-niveaux:
-; La "flèche simple" ou "Thread-first", insère, à chaque niveau de la transformation, la forme courante en la seconde position de la forme suivante, constituant à chaque fois un nouvel étage de transformation.Par exemple:
+; Utilisez les Threading Macros (-> et ->>) pour exprimer plus clairement vos transformations, en y pensant de manière multi-niveaux.
+
+; La "flèche simple" ou "Thread-first", insère, à chaque niveau de la transformation, la forme courante en la seconde position de la forme suivante, constituant à chaque fois un nouvel étage de transformation. Par exemple:
 (->  
    {:a 1 :b 2} 
    (assoc :c 3) ;=> Génère ici (assoc {:a 1 :b 2} :c 3)
    (dissoc :b)) ;=> Génère ici (dissoc (assoc {:a 1 :b 2} :c 3) :b)
+   
 ; Cette expression est ré-écrite en: (dissoc (assoc {:a 1 :b 2} :c 3) :b) et est évaluée en : {:a 1 :c 3}
 ; La "flèche double" ou "Thread-last" procède de la même manière que "->", mais insère le résultat de la réécriture de chaque étage en dernière position. Par exemple:
 (->>
-- 
cgit v1.2.3


From 085bc20c1afc7bb45aae9d269c12df06ba804a1e Mon Sep 17 00:00:00 2001
From: Adam Bard <github@adambard.com>
Date: Sun, 18 Oct 2015 00:27:50 +0800
Subject: Fix spacing.

---
 fr-fr/clojure-fr.html.markdown | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/clojure-fr.html.markdown b/fr-fr/clojure-fr.html.markdown
index 1cedda1d..63bc25b5 100644
--- a/fr-fr/clojure-fr.html.markdown
+++ b/fr-fr/clojure-fr.html.markdown
@@ -276,16 +276,25 @@ ressemblent à toutes les autres formes:
   (print "Saying hello to " name)
   (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel")
   
-; Utilisez les Threading Macros (-> et ->>) pour exprimer plus clairement vos transformations, en y pensant de manière multi-niveaux.
+; Utilisez les Threading Macros (-> et ->>) pour exprimer plus
+; clairement vos transformations, en y pensant de manière multi-niveaux.
 
-; La "flèche simple" ou "Thread-first", insère, à chaque niveau de la transformation, la forme courante en la seconde position de la forme suivante, constituant à chaque fois un nouvel étage de transformation. Par exemple:
+; La "flèche simple" ou "Thread-first", insère, à chaque niveau
+; de la transformation, la forme courante en la seconde position
+; de la forme suivante, constituant à chaque fois un nouvel étage
+; de transformation. Par exemple:
 (->  
    {:a 1 :b 2} 
    (assoc :c 3) ;=> Génère ici (assoc {:a 1 :b 2} :c 3)
    (dissoc :b)) ;=> Génère ici (dissoc (assoc {:a 1 :b 2} :c 3) :b)
    
-; Cette expression est ré-écrite en: (dissoc (assoc {:a 1 :b 2} :c 3) :b) et est évaluée en : {:a 1 :c 3}
-; La "flèche double" ou "Thread-last" procède de la même manière que "->", mais insère le résultat de la réécriture de chaque étage en dernière position. Par exemple:
+; Cette expression est ré-écrite en:
+; (dissoc (assoc {:a 1 :b 2} :c 3) :b)
+; et est évaluée en : {:a 1 :c 3}
+
+; La "flèche double" ou "Thread-last" procède de la même manière
+; que "->", mais insère le résultat de la réécriture de chaque
+; étage en dernière position. Par exemple:
 (->>
    (range 10)
    (map inc)     ;=> Génère ici (map inc (range 10)
-- 
cgit v1.2.3