From 5a9f042ea544776b9d1b94bdb02326006c199b72 Mon Sep 17 00:00:00 2001
From: Julien M'Poy <julien.mpoy@gmail.com>
Date: Fri, 27 Oct 2017 09:51:28 +0200
Subject: Corrected french mistakes

---
 fr-fr/php.html.markdown | 84 +++++++++++++++++++++++++++++++++++++------------
 1 file changed, 64 insertions(+), 20 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/php.html.markdown b/fr-fr/php.html.markdown
index 823630bd..d001f1d4 100644
--- a/fr-fr/php.html.markdown
+++ b/fr-fr/php.html.markdown
@@ -6,11 +6,14 @@ contributors:
     - ["Trismegiste", "https://github.com/Trismegiste"]
 translators:
     - ["Pascal Boutin", "http://pboutin.net/"]
+    - ["Julien M'Poy", "https://github.com/groovytron"]
 lang: fr-fr
 ---
 
 This document describes PHP 5+.
 
+Ce document décrit PHP 5+.
+
 ```php
  // Le code PHP doit être placé à l'intérieur de balises '<?php'
 
@@ -48,7 +51,7 @@ Hello World Again!
 // Un nom de variable valide commence par une lettre ou un souligné,
 // suivi de n'importe quelle lettre, nombre ou de soulignés.
 
-// Les valeurs booléenes ne sont pas sensibles à la casse
+// Les valeurs booléennes ne sont pas sensibles à la casse
 $boolean = true;  // ou TRUE ou True
 $boolean = false; // ou FALSE ou False
 
@@ -84,30 +87,30 @@ $number /= $float; // Divise et assigne le quotient à $number
 $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.'
+$dbl_quotes = "Ceci est une $sgl_quotes."; // => 'Ceci est une $String.'
 
 // 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';
+$escaped   = "Ceci contient \t une tabulation.";
+$unescaped = 'Ceci contient juste un slash et un t: \t';
 
 // En cas de besoin, placez la variable dans des accolades
-$money = "I have $${number} in the bank.";
+$money = "J'ai $${number} sur mon compte en banque.";
 
 // Depuis PHP 5.3, Nowdoc peut être utilisé pour faire des chaînes
 // multi-lignes non-interprétées
 $nowdoc = <<<'END'
-Multi line
-string
+String
+mutli-lignes
 END;
 
 // Heredoc peut être utilisé pour faire des chaînes multi-lignes interprétées
 $heredoc = <<<END
-Multi line
 $sgl_quotes
+multi-lignes
 END;
 
 // La concaténation de chaînes se fait avec un .
-echo 'This string ' . 'is concatenated';
+echo 'Cette string ' . 'est concatenée'; // => 'Cette string est concaténée'
 
 
 /********************************
@@ -122,7 +125,7 @@ echo 'This string ' . 'is concatenated';
 define("FOO",     "something");
 
 // on peut accéder à une constante en utilisant directement son nom
-echo 'This outputs '.FOO;
+echo 'Ceci affiche ' . FOO;
 
 
 /********************************
@@ -149,6 +152,14 @@ $array[] = 'Four';
 // Retrait d'un élément du tableau
 unset($array[3]);
 
+// Depuis PHP 7, il est possible de déclarer des tableaux constants en
+// utilisant 'define'.
+define('ANIMAUX', [
+    'chien',
+    'chat',
+    'oiseau',
+]);
+
 /********************************
  * Affichage
  */
@@ -159,11 +170,13 @@ echo('Hello World!');
 
 print('Hello World!'); // Pareil à "écho"
 
-// Pour écho, vous n'avez pas besoin des parenthèses
+// 'echo' et 'print' sont des language constructs.
+// Il n'ont pas besoin de parenthèses car ils sont traités comme
+// des opérateurs unaires.
 echo 'Hello World!';
-print 'Hello World!'; // Pour print non plus
+print 'Hello World!'; 
 
-$paragraph = 'paragraph';
+$paragraph = 'paragraphe';
 
 echo 100;        // Affichez un scalaire directement
 echo $paragraph; // ou des variables
@@ -202,7 +215,8 @@ $b = '0';
 $c = '1';
 $d = '1';
 
-// assert affiche un avertissement dans son argument n'est pas vrai
+// assert affiche un avertissement quand l'expression booléenne passée
+// en argument n'est pas vraie.
 
 // Ces comparaisons vont toujours être vraies, même si leurs
 // types ne sont pas les mêmes.
@@ -315,7 +329,7 @@ if ($x === '0') {
 switch ($x) {
     case '0':
         print 'Les switch font du transtypage implicite';
-        break; // Il est important de déclaré un 'break', sinon les cas
+        break; // Il est important de déclarer un 'break', sinon les cas
                // 'two' et 'three' seront évalués
     case 'two':
     case 'three':
@@ -390,9 +404,10 @@ function my_function () {
 echo my_function(); // => "Hello"
 
 
-// Les noms de fonction débutent par le symbole $
-// Un nom de variable valide commence par une lettre ou un souligné,
+// Un nom de fonction valide commence par une lettre ou un souligné,
 // suivi de n'importe quelle lettre, nombre ou de soulignés.
+// Les noms des arguments d'une fonction doivent respecter le même format que
+// celui des variables.
 
 function add ($x, $y = 1) { // $y est facultatif et sa valeur par défaut est 1
   $result = $x + $y;
@@ -519,7 +534,7 @@ class MyClass
 
     public static function myStaticMethod()
     {
-        print 'I am static';
+        print 'Je suis static';
     }
 }
 
@@ -527,7 +542,7 @@ class MyClass
 echo MyClass::MY_CONST;    // Outputs 'value';
 
 echo MyClass::$staticVar;  // Retourne 'static';
-MyClass::myStaticMethod(); // Retourne 'I am static';
+MyClass::myStaticMethod(); // Retourne 'Je suis static';
 
 // On peut instancier une classe en utilisant le mot clé 'new'
 $my_class = new MyClass('An instance property');
@@ -584,7 +599,7 @@ 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').
+// elle peuvent implémenter une interface (en utilisant le mot clé 'implements').
 
 // Une interface peut être déclarée avec le mot clé 'interface'
 
@@ -637,6 +652,35 @@ class SomeOtherClass implements InterfaceOne, InterfaceTwo
     }
 }
 
+// Il est possible de déclarer des classes internes anonymes depuis PHP 7
+
+interface Logger {
+    public function log(string $msg);
+}
+
+class Application {
+    private $logger;
+
+    public function getLogger(): Logger {
+         return $this->logger;
+    }
+
+    public function setLogger(Logger $logger) {
+         $this->logger = $logger;
+    }
+}
+
+$app = new Application;
+
+$app->setLogger(new class implements Logger {
+    public function log(string $msg) {
+        echo $msg;
+    }
+});
+
+var_dump($app->getLogger()); // => 'object(class@anonymous)#2 (0) {}'
+
+
 /********************************
  * Espaces de noms (namespaces)
  */
-- 
cgit v1.2.3


From 0aaae2653cc4edef745c7f0de2b5c038097337d2 Mon Sep 17 00:00:00 2001
From: LukaxFeh <32396925+LukaxFeh@users.noreply.github.com>
Date: Sun, 29 Oct 2017 13:09:01 -0200
Subject: Fix file names in french (#2984)

* fix file name

* fix file names

* fix file names

* fix file names

* fix file names

* fix file names
---
 fr-fr/d-fr.html.markdown        | 264 +++++++++++++++
 fr-fr/d.html.markdown           | 264 ---------------
 fr-fr/haskell-fr.html.markdown  | 431 +++++++++++++++++++++++++
 fr-fr/haskell.html.markdown     | 431 -------------------------
 fr-fr/markdown-fr.html.markdown | 289 +++++++++++++++++
 fr-fr/markdown.html.markdown    | 289 -----------------
 fr-fr/php-fr.html.markdown      | 697 ++++++++++++++++++++++++++++++++++++++++
 fr-fr/php.html.markdown         | 697 ----------------------------------------
 fr-fr/scala-fr.html.markdown    | 460 ++++++++++++++++++++++++++
 fr-fr/scala.html.markdown       | 460 --------------------------
 fr-fr/vim-fr.html.markdown      | 239 ++++++++++++++
 fr-fr/vim.html.markdown         | 239 --------------
 12 files changed, 2380 insertions(+), 2380 deletions(-)
 create mode 100644 fr-fr/d-fr.html.markdown
 delete mode 100644 fr-fr/d.html.markdown
 create mode 100644 fr-fr/haskell-fr.html.markdown
 delete mode 100644 fr-fr/haskell.html.markdown
 create mode 100644 fr-fr/markdown-fr.html.markdown
 delete mode 100644 fr-fr/markdown.html.markdown
 create mode 100644 fr-fr/php-fr.html.markdown
 delete mode 100644 fr-fr/php.html.markdown
 create mode 100644 fr-fr/scala-fr.html.markdown
 delete mode 100644 fr-fr/scala.html.markdown
 create mode 100644 fr-fr/vim-fr.html.markdown
 delete mode 100644 fr-fr/vim.html.markdown

(limited to 'fr-fr')

diff --git a/fr-fr/d-fr.html.markdown b/fr-fr/d-fr.html.markdown
new file mode 100644
index 00000000..8d98f9dc
--- /dev/null
+++ b/fr-fr/d-fr.html.markdown
@@ -0,0 +1,264 @@
+---
+language: D
+filename: learnd-fr.d
+contributors:
+    - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"]
+translators:
+    - ["Quentin Ladeveze", "aceawan.eu"]
+lang: fr-fr
+---
+
+```c
+// Commençons par un classique
+module hello;
+
+import std.stdio;
+
+// args n'est pas obligatoire
+void main(string[] args) {
+    writeln("Bonjour le monde !");
+}
+```
+
+Si vous êtes comme moi et que vous passez beaucoup trop de temps sur internet, il y a
+de grandes chances pour que vous ayez déjà entendu parler du [D](http://dlang.org/).
+D est un langage de programmation moderne, généraliste, multi-paradigmes qui contient
+des fonctionnalités aussi bien de bas niveau que de haut niveau.
+
+D est activement développé par de nombreuses personnes très intelligents, guidées par
+[Walter Bright](https://fr.wikipedia.org/wiki/Walter_Bright))) et
+[Andrei Alexandrescu](https://fr.wikipedia.org/wiki/Andrei_Alexandrescu).
+Après cette petite introduction, jetons un coup d'oeil à quelques exemples.
+
+```c
+import std.stdio;
+
+void main() {
+    //Les conditions et les boucles sont classiques.
+    for(int i = 0; i < 10000; i++) {
+        writeln(i);
+    }
+
+    // On peut utiliser auto pour inférer automatiquement le
+    // type d'une variable.
+    auto n = 1;
+
+    // On peut faciliter la lecture des valeurs numériques
+    // en y insérant des `_`.
+    while(n < 10_000) {
+        n += n;
+    }
+
+    do {
+        n -= (n / 2);
+    } while(n > 0);
+
+    // For et while sont très utiles, mais en D, on préfère foreach.
+    // Les deux points : '..', créent un intervalle continu de valeurs
+    // incluant la première mais excluant la dernière.
+    foreach(i; 1..1_000_000) {
+        if(n % 2 == 0)
+            writeln(i);
+    }
+
+    // On peut également utiliser foreach_reverse pour itérer à l'envers.
+    foreach_reverse(i; 1..int.max) {
+        if(n % 2 == 1) {
+            writeln(i);
+        } else {
+            writeln("Non !");
+        }
+    }
+}
+```
+On peut définir de nouveaux types avec les mots-clés `struct`, `class`,
+`union` et `enum`. Ces types sont passés à la fonction par valeur (ils sont copiés)
+De plus, on peut utiliser les templates pour rendre toutes ces abstractions génériques.
+
+```c
+// Ici, 'T' est un paramètre de type. Il est similaire au <T> de C++/C#/Java.
+struct LinkedList(T) {
+    T data = null;
+
+	// Utilisez '!' pour instancier un type paramétré.
+	// Encore une fois semblable à '<T>'
+    LinkedList!(T)* next;
+}
+
+class BinTree(T) {
+    T data = null;
+
+    // S'il n'y a qu'un seul paramètre de template,
+    // on peut s'abstenir de mettre des parenthèses.
+    BinTree!T left;
+    BinTree!T right;
+}
+
+enum Day {
+    Sunday,
+    Monday,
+    Tuesday,
+    Wednesday,
+    Thursday,
+    Friday,
+    Saturday,
+}
+
+// Utilisez alias pour créer des abreviations pour les types.
+alias IntList = LinkedList!int;
+alias NumTree = BinTree!double;
+
+// On peut tout aussi bien créer des templates de function !
+T max(T)(T a, T b) {
+    if(a < b)
+        return b;
+
+    return a;
+}
+
+// On peut utiliser le mot-clé ref pour s'assurer que quelque chose est passé
+// par référence, et ceci, même si a et b sont d'ordinaire passés par valeur.
+// Ici ils seront toujours passés par référence à 'swap()'.
+void swap(T)(ref T a, ref T b) {
+    auto temp = a;
+
+    a = b;
+    b = temp;
+}
+
+// Avec les templates, on peut également passer des valeurs en paramètres.
+class Matrix(uint m, uint n, T = int) {
+    T[m] rows;
+    T[n] columns;
+}
+
+auto mat = new Matrix!(3, 3); // T est 'int' par défaut
+
+```
+À propos de classes, parlons des propriétés. Une propriété est, en gros,
+une méthode qui peut se comporter comme une lvalue. On peut donc utiliser
+la syntaxe des structures classiques (`struct.x = 7`) comme si il
+s'agissait de méthodes getter ou setter.
+
+```c
+// Considérons une classe paramétrée avec les types 'T' et 'U'
+class MyClass(T, U) {
+    T _data;
+    U _other;
+}
+
+// Et des méthodes "getter" et "setter" comme suit:
+class MyClass(T, U) {
+    T _data;
+    U _other;
+
+	// Les constructeurs s'appellent toujours 'this'.
+    this(T t, U u) {
+		// Ceci va appeller les setters ci-dessous.
+        data = t;
+        other = u;
+    }
+
+    // getters
+    @property T data() {
+        return _data;
+    }
+
+    @property U other() {
+        return _other;
+    }
+
+    // setters
+    @property void data(T t) {
+        _data = t;
+    }
+
+    @property void other(U u) {
+        _other = u;
+    }
+}
+
+// Et on l'utilise de cette façon:
+void main() {
+    auto mc = new MyClass!(int, string)(7, "seven");
+
+	// Importer le module 'stdio' de la bibliothèque standard permet
+	// d'écrire dans la console (les imports peuvent être locaux à une portée)
+    import std.stdio;
+
+	// On appelle les getters pour obtenir les valeurs.
+    writefln("Earlier: data = %d, str = %s", mc.data, mc.other);
+
+	// On appelle les setter pour assigner de nouvelles valeurs.
+    mc.data = 8;
+    mc.other = "eight";
+
+	// On appelle les setter pour obtenir les nouvelles valeurs.
+    writefln("Later: data = %d, str = %s", mc.data, mc.other);
+}
+```
+Avec les propriétés, on peut construire nos setters et nos getters
+comme on le souhaite, tout en gardant une syntaxe très propre,
+comme si on accédait directement à des membres de la classe.
+
+Les autres fonctionnalités orientées objets à notre disposition
+incluent les interfaces, les classes abstraites, et la surcharge
+de méthodes. D gère l'héritage comme Java: On ne peut hériter que
+d'une seule classe et implémenter autant d'interface que voulu.
+
+Nous venons d'explorer les fonctionnalités objet du D, mais changeons
+un peu de domaine. D permet la programmation fonctionelle, avec les fonctions
+de premier ordre, les fonctions `pures` et les données immuables.
+De plus, tout vos algorithmes fonctionels favoris (map, reduce, filter)
+sont disponibles dans le module `std.algorithm`.
+
+```c
+import std.algorithm : map, filter, reduce;
+import std.range : iota; // construit un intervalle excluant la dernière valeur.
+
+void main() {
+	// On veut un algorithme qui affiche la somme de la liste des carrés
+	// des entiers paires de 1 à 100. Un jeu d'enfant !
+
+	// On se contente de passer des expressions lambda en paramètre à des templates.
+	// On peut fournir au template n'importe quelle fonction, mais dans notre
+	// cas, les lambdas sont pratiques.
+    auto num = iota(1, 101).filter!(x => x % 2 == 0)
+                           .map!(y => y ^^ 2)
+                           .reduce!((a, b) => a + b);
+
+    writeln(num);
+}
+```
+
+Vous voyez qu'on a calculé `num` comme on le ferait en haskell par exemple ?
+C'est grâce à une innovation de D qu'on appelle "Uniform Function Call Syntax".
+Avec l'UFCS, on peut choisir d'écrire un appel à une fonction de manière
+classique, ou comme un appel à une méthode. Walter Brighter a écrit un
+article en anglais sur l'UFCS [ici.](http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394)
+Pour faire court, on peut appeller une fonction dont le premier paramètre
+est de type A, comme si c'était une méthode de A.
+
+J'aime le parallélisme. Vous aimez le parallélisme ? Bien sûr que vous aimez ça.
+Voyons comment on le fait en D !
+
+```c
+import std.stdio;
+import std.parallelism : parallel;
+import std.math : sqrt;
+
+void main() {
+    // On veut calculer la racine carrée de tous les nombres
+    // dans notre tableau, et profiter de tous les coeurs
+    // à notre disposition.
+    auto arr = new double[1_000_000];
+
+    // On utilise un index et une référence à chaque élément du tableau.
+    // On appelle juste la fonction parallel sur notre tableau !
+    foreach(i, ref elem; parallel(arr)) {
+        ref = sqrt(i + 1.0);
+    }
+}
+
+
+```
diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown
deleted file mode 100644
index 8d98f9dc..00000000
--- a/fr-fr/d.html.markdown
+++ /dev/null
@@ -1,264 +0,0 @@
----
-language: D
-filename: learnd-fr.d
-contributors:
-    - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"]
-translators:
-    - ["Quentin Ladeveze", "aceawan.eu"]
-lang: fr-fr
----
-
-```c
-// Commençons par un classique
-module hello;
-
-import std.stdio;
-
-// args n'est pas obligatoire
-void main(string[] args) {
-    writeln("Bonjour le monde !");
-}
-```
-
-Si vous êtes comme moi et que vous passez beaucoup trop de temps sur internet, il y a
-de grandes chances pour que vous ayez déjà entendu parler du [D](http://dlang.org/).
-D est un langage de programmation moderne, généraliste, multi-paradigmes qui contient
-des fonctionnalités aussi bien de bas niveau que de haut niveau.
-
-D est activement développé par de nombreuses personnes très intelligents, guidées par
-[Walter Bright](https://fr.wikipedia.org/wiki/Walter_Bright))) et
-[Andrei Alexandrescu](https://fr.wikipedia.org/wiki/Andrei_Alexandrescu).
-Après cette petite introduction, jetons un coup d'oeil à quelques exemples.
-
-```c
-import std.stdio;
-
-void main() {
-    //Les conditions et les boucles sont classiques.
-    for(int i = 0; i < 10000; i++) {
-        writeln(i);
-    }
-
-    // On peut utiliser auto pour inférer automatiquement le
-    // type d'une variable.
-    auto n = 1;
-
-    // On peut faciliter la lecture des valeurs numériques
-    // en y insérant des `_`.
-    while(n < 10_000) {
-        n += n;
-    }
-
-    do {
-        n -= (n / 2);
-    } while(n > 0);
-
-    // For et while sont très utiles, mais en D, on préfère foreach.
-    // Les deux points : '..', créent un intervalle continu de valeurs
-    // incluant la première mais excluant la dernière.
-    foreach(i; 1..1_000_000) {
-        if(n % 2 == 0)
-            writeln(i);
-    }
-
-    // On peut également utiliser foreach_reverse pour itérer à l'envers.
-    foreach_reverse(i; 1..int.max) {
-        if(n % 2 == 1) {
-            writeln(i);
-        } else {
-            writeln("Non !");
-        }
-    }
-}
-```
-On peut définir de nouveaux types avec les mots-clés `struct`, `class`,
-`union` et `enum`. Ces types sont passés à la fonction par valeur (ils sont copiés)
-De plus, on peut utiliser les templates pour rendre toutes ces abstractions génériques.
-
-```c
-// Ici, 'T' est un paramètre de type. Il est similaire au <T> de C++/C#/Java.
-struct LinkedList(T) {
-    T data = null;
-
-	// Utilisez '!' pour instancier un type paramétré.
-	// Encore une fois semblable à '<T>'
-    LinkedList!(T)* next;
-}
-
-class BinTree(T) {
-    T data = null;
-
-    // S'il n'y a qu'un seul paramètre de template,
-    // on peut s'abstenir de mettre des parenthèses.
-    BinTree!T left;
-    BinTree!T right;
-}
-
-enum Day {
-    Sunday,
-    Monday,
-    Tuesday,
-    Wednesday,
-    Thursday,
-    Friday,
-    Saturday,
-}
-
-// Utilisez alias pour créer des abreviations pour les types.
-alias IntList = LinkedList!int;
-alias NumTree = BinTree!double;
-
-// On peut tout aussi bien créer des templates de function !
-T max(T)(T a, T b) {
-    if(a < b)
-        return b;
-
-    return a;
-}
-
-// On peut utiliser le mot-clé ref pour s'assurer que quelque chose est passé
-// par référence, et ceci, même si a et b sont d'ordinaire passés par valeur.
-// Ici ils seront toujours passés par référence à 'swap()'.
-void swap(T)(ref T a, ref T b) {
-    auto temp = a;
-
-    a = b;
-    b = temp;
-}
-
-// Avec les templates, on peut également passer des valeurs en paramètres.
-class Matrix(uint m, uint n, T = int) {
-    T[m] rows;
-    T[n] columns;
-}
-
-auto mat = new Matrix!(3, 3); // T est 'int' par défaut
-
-```
-À propos de classes, parlons des propriétés. Une propriété est, en gros,
-une méthode qui peut se comporter comme une lvalue. On peut donc utiliser
-la syntaxe des structures classiques (`struct.x = 7`) comme si il
-s'agissait de méthodes getter ou setter.
-
-```c
-// Considérons une classe paramétrée avec les types 'T' et 'U'
-class MyClass(T, U) {
-    T _data;
-    U _other;
-}
-
-// Et des méthodes "getter" et "setter" comme suit:
-class MyClass(T, U) {
-    T _data;
-    U _other;
-
-	// Les constructeurs s'appellent toujours 'this'.
-    this(T t, U u) {
-		// Ceci va appeller les setters ci-dessous.
-        data = t;
-        other = u;
-    }
-
-    // getters
-    @property T data() {
-        return _data;
-    }
-
-    @property U other() {
-        return _other;
-    }
-
-    // setters
-    @property void data(T t) {
-        _data = t;
-    }
-
-    @property void other(U u) {
-        _other = u;
-    }
-}
-
-// Et on l'utilise de cette façon:
-void main() {
-    auto mc = new MyClass!(int, string)(7, "seven");
-
-	// Importer le module 'stdio' de la bibliothèque standard permet
-	// d'écrire dans la console (les imports peuvent être locaux à une portée)
-    import std.stdio;
-
-	// On appelle les getters pour obtenir les valeurs.
-    writefln("Earlier: data = %d, str = %s", mc.data, mc.other);
-
-	// On appelle les setter pour assigner de nouvelles valeurs.
-    mc.data = 8;
-    mc.other = "eight";
-
-	// On appelle les setter pour obtenir les nouvelles valeurs.
-    writefln("Later: data = %d, str = %s", mc.data, mc.other);
-}
-```
-Avec les propriétés, on peut construire nos setters et nos getters
-comme on le souhaite, tout en gardant une syntaxe très propre,
-comme si on accédait directement à des membres de la classe.
-
-Les autres fonctionnalités orientées objets à notre disposition
-incluent les interfaces, les classes abstraites, et la surcharge
-de méthodes. D gère l'héritage comme Java: On ne peut hériter que
-d'une seule classe et implémenter autant d'interface que voulu.
-
-Nous venons d'explorer les fonctionnalités objet du D, mais changeons
-un peu de domaine. D permet la programmation fonctionelle, avec les fonctions
-de premier ordre, les fonctions `pures` et les données immuables.
-De plus, tout vos algorithmes fonctionels favoris (map, reduce, filter)
-sont disponibles dans le module `std.algorithm`.
-
-```c
-import std.algorithm : map, filter, reduce;
-import std.range : iota; // construit un intervalle excluant la dernière valeur.
-
-void main() {
-	// On veut un algorithme qui affiche la somme de la liste des carrés
-	// des entiers paires de 1 à 100. Un jeu d'enfant !
-
-	// On se contente de passer des expressions lambda en paramètre à des templates.
-	// On peut fournir au template n'importe quelle fonction, mais dans notre
-	// cas, les lambdas sont pratiques.
-    auto num = iota(1, 101).filter!(x => x % 2 == 0)
-                           .map!(y => y ^^ 2)
-                           .reduce!((a, b) => a + b);
-
-    writeln(num);
-}
-```
-
-Vous voyez qu'on a calculé `num` comme on le ferait en haskell par exemple ?
-C'est grâce à une innovation de D qu'on appelle "Uniform Function Call Syntax".
-Avec l'UFCS, on peut choisir d'écrire un appel à une fonction de manière
-classique, ou comme un appel à une méthode. Walter Brighter a écrit un
-article en anglais sur l'UFCS [ici.](http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394)
-Pour faire court, on peut appeller une fonction dont le premier paramètre
-est de type A, comme si c'était une méthode de A.
-
-J'aime le parallélisme. Vous aimez le parallélisme ? Bien sûr que vous aimez ça.
-Voyons comment on le fait en D !
-
-```c
-import std.stdio;
-import std.parallelism : parallel;
-import std.math : sqrt;
-
-void main() {
-    // On veut calculer la racine carrée de tous les nombres
-    // dans notre tableau, et profiter de tous les coeurs
-    // à notre disposition.
-    auto arr = new double[1_000_000];
-
-    // On utilise un index et une référence à chaque élément du tableau.
-    // On appelle juste la fonction parallel sur notre tableau !
-    foreach(i, ref elem; parallel(arr)) {
-        ref = sqrt(i + 1.0);
-    }
-}
-
-
-```
diff --git a/fr-fr/haskell-fr.html.markdown b/fr-fr/haskell-fr.html.markdown
new file mode 100644
index 00000000..a34dc098
--- /dev/null
+++ b/fr-fr/haskell-fr.html.markdown
@@ -0,0 +1,431 @@
+---
+language: Haskell
+contributors:
+    - ["Adit Bhargava", "http://adit.io"]
+translators:
+    - ["David Baumgartner", "http://davidbaumgartner.ch"]    
+lang: fr-fr
+filename: learnhaskell-fr.hs
+---
+
+Haskell a été conçu pour être un langage fonctionnel pur et maniable. Il est connu pour ses monades et son système de types, mais je n'ai cesse d'y revenir pour son élégance. Pour moi, Haskell fait de la programmation une joie.
+
+```haskell
+-- Un commentaire en une ligne commence avec deux tirets.
+{- Un commentaire sur plusieurs lignes peut être contenu dans
+un bloc de cette façon.
+-}
+
+----------------------------------------------------
+-- 1. Types de données primitifs et opérateurs
+----------------------------------------------------
+
+-- Vous avez les nombres
+3 -- 3
+
+-- Les maths sont comme vous vous y attendez
+1 + 1 -- 2
+8 - 1 -- 7
+10 * 2 -- 20
+35 / 5 -- 7.0
+
+-- La division n'est pas entière par défaut
+35 / 4 -- 8.75
+
+-- division entière
+35 `div` 4 -- 8
+
+-- Les booléens sont primitifs
+True
+False
+
+-- Opérations avec les booléens
+not True -- False
+not False -- True
+1 == 1 -- True
+1 /= 1 -- False
+1 < 10 -- True
+
+-- Dans les exemples plus hauts, `not` est une fonction qui prend une valeur.
+-- Haskell n'a pas besoin de parenthèses pour appeler une fonction... tous
+-- les arguments sont juste listés après la fonction. Le schéma général est
+-- donc :
+-- func arg1 arg2 arg3...
+-- Voyez la section sur les fonctions pour savoir comment écrire les vôtres.
+
+-- Caractères et chaînes de caractère
+"Ceci est une chaîne de caractère."
+'a' -- caractère
+'Vous ne pouvez pas utiliser des apostrophes pour les chaînes de caractère.' -- erreur !
+
+-- Les chaînes peuvent être concaténées
+"Hello " ++ "world!" -- "Hello world!"
+
+-- Une chaîne de caractère est *réellement* une liste
+"Ceci est une chaîne." !! 0 -- 'C'
+
+
+----------------------------------------------------
+-- 2. Listes et tuples
+----------------------------------------------------
+
+-- Tous les éléments d'une liste doit avoir le même type.
+-- les deux lignes suivantes sont semblables
+[1, 2, 3, 4, 5]
+[1..5]
+
+-- Il y a aussi des listes infinies en Haskell !
+[1..] -- une liste de tous les nombres naturels
+
+-- Les listes infinies fonctionnent parce que Haskell est « paresseux »:
+-- ça veut dire qu'il n'évalue que ce qui a besoin de l'être. Vous pouvez
+-- donc vous demander le 1000e élément de votre liste et il vous le donnera :
+
+[1..] !! 999 -- 1000
+
+-- Et là, Haskell a évalué les éléments 1 à 1000 de la liste... mais le reste
+-- de cette liste « infinie » n'existe pas encore ! En fait, Haskell ne va jamais 
+-- le faire à moins qu'il ne le doive.
+
+-- Adjoindre deux listes 
+[1..5] ++ [6..10]
+
+-- ajouter au début de la liste
+0:[1..5] -- [0, 1, 2, 3, 4, 5]
+
+-- l'indice d'une liste
+[0..] !! 5 -- 5
+
+-- d'autres opérations sur les listes
+head [1..5] -- 1
+tail [1..5] -- [2, 3, 4, 5]
+init [1..5] -- [1, 2, 3, 4]
+last [1..5] -- 5
+
+--liste en compréhension
+[x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10]
+
+--avec un conditionnel
+[x*2 | x <- [1..5], x*2 > 4] -- [6, 8, 10]
+
+-- Chaque élément d'un tuple peut être d'un type différent, mais un
+-- tuple a une longueur fixée.
+-- Un tuple :
+("haskell", 1)
+
+-- accéder aux éléments d'un tuple
+fst ("haskell", 1) -- "haskell"
+snd ("haskell", 1) -- 1
+
+----------------------------------------------------
+-- 3. Functions
+----------------------------------------------------
+-- Une simple fonction qui prend deux paramètres
+add a b = a + b
+
+-- Notez que si vous utilisez ghci (l'interpréteur Haskell)
+-- vous devrez utiliser `let`. Par exemple :
+-- let add a b = a + b
+
+-- Utiliser une fonction
+add 1 2 -- 3
+
+-- Vous pouvez également mettre le nom de la fonction entre les
+-- deux arguments avec des accents graves :
+1 `add` 2 -- 3
+
+-- Vous pouvez également définir des fonctions qui n'ont pas de
+-- lettres ! Ça vous laisse créer vos propres opérateurs ! Voilà 
+-- un opérateur qui fait une division entière :
+(//) a b = a `div` b
+35 // 4 -- 8
+
+-- Gardes : Une façon de gérer la valeur de vos arguments en amont
+fib x
+  | x < 2 = x
+  | otherwise = fib (x - 1) + fib (x - 2)
+
+-- Le filtrage par motif est similaire. Là, on a donné trois 
+-- définitions différentes de `fib`. Haskell appellera automatiquement
+-- la première fonction qui correspond au motif de la valeur.
+fib 1 = 1
+fib 2 = 2
+fib x = fib (x - 1) + fib (x - 2)
+
+-- Filtrage par motif sur un tuple.
+foo (x, y) = (x + 1, y + 2)
+
+-- Filtrage par motif sur des listes. Ici, `x` est le premier
+-- élément de la liste, et `xs` le reste. On peut écrire notre
+-- propre fonction `map` :
+myMap func [] = []
+myMap func (x:xs) = func x:(myMap func xs)
+
+-- Les fonctions anonymes sont créées avec des barres obliques 
+-- inverses, suivies de tous les arguments.
+myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7]
+
+-- Une utilisation de fold (appelée `inject` dans quelques autres
+-- langages) avec comme paramètre une fonction anonyme.
+-- `foldl1` veut dire fold left -- soit littéralement pli gauche --
+-- et utilise la première valeur de la liste comme accumulateur.
+foldl1 (\acc x -> acc + x) [1..5] -- 15
+
+----------------------------------------------------
+-- 4. Plus de fonctions
+----------------------------------------------------
+
+-- curryfication : si vous n'appliquez pas tous les arguments à une
+-- fonction, elle devient « curryfiée ». Ça veut dire qu'elle retourne
+-- une fonction qui prend le reste des arguments.
+
+add a b = a + b
+foo = add 10 -- foo est une fonction qui prend un nombre et y ajoute 10
+foo 5 -- 15
+
+-- Une autre façon de l'écrire
+foo = (+10)
+foo 5 -- 15
+
+-- Composition de fonctions
+-- la fonction (.) enchaîne deux fonctions.
+-- Par exemple, on a foo qui est une fonction qui prend une valeur, y ajoute
+-- 10 et multiplie ce résultat par 5, et ensuite retourne la valeur finale.
+foo = (*5) . (+10)
+
+-- (5 + 10) * 5 = 75
+foo 5 -- 75
+
+-- fixation de priorité
+-- Haskell a une autre fonction appelée `$`. Elle peut changer la priorité
+-- de sorte que tout ce qu'il y a à sa gauche est calculé d'abord et ensuite 
+-- appliqué à tout ce qu'il y a à droite. Vous pouvez utiliser `.` et `$` 
+-- pour vous débarrasser de beaucoup de parenthèses :
+
+-- avant
+(even (fib 7)) -- False
+
+-- ensuite
+even . fib $ 7 -- False
+
+----------------------------------------------------
+-- 5. Signature de type
+----------------------------------------------------
+
+-- Haskell a un système de types très strict : par exemple, tout a un type.
+
+-- Quelques types simples :
+5 :: Integer
+"hello" :: String
+True :: Bool
+
+-- Les fonctions ont également des types.
+-- `not` prend un booléen et retourne un booléen.
+-- not :: Bool -> Bool
+
+-- Voilà une fonction qui prend deux paramètres.
+-- add :: Integer -> Integer -> Integer
+
+-- Quand vous définissez une valeur (souvenez-vous, tout est valeur en
+-- Haskell), une bonne pratique est d'écrire son type explicitement
+double :: Integer -> Integer
+double x = x * 2
+
+----------------------------------------------------
+-- 6. Flux de contrôle et structures conditionnelles
+----------------------------------------------------
+
+-- structure conditionnelle if
+haskell = if 1 == 1 then "awesome" else "awful" -- haskell = "awesome"
+
+-- les structures if peuvent être écrites sur plusieurs lignes
+haskell = if 1 == 1
+            then "awesome"
+            else "awful"
+
+-- les structures case : voilà comment vous pourriez analyser les arguments de 
+-- ligne de commande
+case args of
+  "help" -> printHelp
+  "start" -> startProgram
+  _ -> putStrLn "bad args"
+
+
+-- Haskell n'a pas de boucles parce qu'il utilise la récursion.
+-- `map` applique une fonction sur chaque élément d'une liste
+
+map (*2) [1..5] -- [2, 4, 6, 8, 10]
+
+-- vous pouvez créer une fonction `for` en utilisant `map`
+for array func = map func array
+
+-- et l'utiliser
+for [0..5] $ \i -> show i
+
+-- nous aurions pu l'écrire également ainsi
+for [0..5] show
+
+-- vous pouvez utiliser foldl et foldr pour 
+-- réduire une liste
+-- foldl <fonction> <valeur initiale> <liste>
+foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43
+
+-- C'est donc la même chose que 
+(2 * (2 * (2 * 4 + 1) + 2) + 3)
+
+-- foldl évalue de gauche à droite, foldr
+-- de droite à gauche
+foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16
+
+-- Et c'est équivalent à
+(2 * 3 + (2 * 2 + (2 * 1 + 4)))
+
+----------------------------------------------------
+-- 7. Types de données
+----------------------------------------------------
+
+-- Vous pouvez écrire vos propres types de données en Haskell
+
+data Couleur = Rouge | Bleu | Vert
+
+-- Et maintenant l'utiliser dans une fonction
+
+
+say :: Couleur -> String
+say Rouge = "Vous êtes Rouge !"
+say Bleu = "Vous êtes Bleu !"
+say Vert =  "Vous êtes Vert !"
+
+-- Vos types peuvent également avoir des paramètres
+
+data Maybe a = Nothing | Just a
+
+-- Tous les exemples ci-dessous sont issus du type Maybe
+Just "hello"    -- of type `Maybe String`
+Just 1          -- of type `Maybe Int`
+Nothing         -- of type `Maybe a` for any `a`
+
+----------------------------------------------------
+-- 8. Haskell IO
+----------------------------------------------------
+
+-- Tandis que l'IO ne peut pas être totalement expliqué pleinement
+-- sans que les monades ne le soient, il n'est pas difficile
+-- d'expliquer suffisamment pour commencer.
+
+-- Quand un programme en Haskell est exécuté, la fonction `main`
+-- est appelée. Il doit retourner une valeur de type `IO ()`.
+-- Par exemple :
+
+main :: IO ()
+main = putStrLn $ "Bonjour, le ciel ! " ++ (say Blue) 
+-- putStrLn a comme type String -> IO ()
+
+-- La façon la plus simple pour faire de l'IO est de faire un programme 
+-- fonction de String vers String. La fonction
+--    interact :: (String -> String) -> IO ()
+-- prend un texte, applique une fonction et affiche le résultat.
+
+countLines :: String -> String
+countLines = show . length . lines
+
+main' = interact countLines
+
+-- Vous pouvez considérer qu'une valeur de type `IO ()` représente
+-- une séquence d'actions que l'ordinateur exécute, un peu comme 
+-- dans un langage impératif. On peut utiliser la structure `do` 
+-- pour enchaîner des actions. Par exemple :
+
+sayHello :: IO ()
+sayHello = do 
+   putStrLn "Quel est ton nom ?"
+   name <- getLine -- prend une ligne et assigne sa valeur à `name`
+   putStrLn $ "Salut, " ++ name
+   
+-- Exercice : écrire votre propre version d'`interact` qui ne fait 
+--           que de lire une ligne d'entrée.
+   
+-- Le code de `sayHello` ne sera jamais exécuté, cependant. La seule
+-- action qui sera exécutée est la valeur de `main`.
+-- Pour lancer `sayHello`, commentez l'ancienne définition de `main`
+-- et remplacez-le par :
+--   main = sayHello
+
+-- Essaions de mieux comprendre comment la fonction `getLine` que 
+-- nous venons d'utiliser. Son type est :
+--    getLine :: IO String
+-- vous pouvez considérer le type `IO a` comme un programme que
+-- le programme va générer comme une valeur de type `a` quand
+-- il sera exécuté. On peut l'enregistrer et la réutiliser en
+-- utilisant `<-`. On peut aussi faire nos propres actions
+-- de type `IO String` :
+
+action :: IO String
+action = do
+   putStrLn "C'est une ligne. Heu"
+   input1 <- getLine 
+   input2 <- getLine
+   -- Le type de la structure `do` est celui de sa dernière ligne.
+   -- `return` n'est pas un mot clef, mais simplement une fonction.
+   return (input1 ++ "\n" ++ input2) -- return :: String -> IO String
+
+-- On peut maintenant l'utiliser comme on a utilisé `getLine`
+-- tout à l'heure
+
+main'' = do
+    putStrLn "Je vais afficher deux lignes !"
+    result <- action 
+    putStrLn result
+    putStrLn "C'était tout !"
+
+-- Le type `IO` est un exemple de « monade ». La façon dont Haskell utilise
+-- une monade pour faire de l'IO lui permet d'être purement fonctionnel. N'importe
+-- quelle fonction qui interagit avec le « monde extérieur » (c'est à dire fait de l'IO)
+-- devient marqué comme `IO` dans la signature de son type. Ça nous montre
+-- quelles fonctions sont « pures » (n'interagissent pas avec le monde extérieur
+-- ou ne changent pas d'état) et quelles fonctions ne le sont pas.
+
+-- C'est une fonctionnalité très puissante, car il est facile d'exécuter 
+-- des fonctions pures simultanément, et donc la concurrence en Haskell
+-- est très facile.
+
+
+----------------------------------------------------
+-- 9. Le REPL de Haskell
+----------------------------------------------------
+
+-- Lancer le REPL en tapant `ghci`.
+-- Vous pouvez maintenant taper du code Haskell.
+-- Toutes les nouvelles valeurs peuvent être crées 
+-- avec `let` :
+
+let foo = 5
+
+-- Vous pouvez voir le type de n'importe quelle valeur avec `:t` :
+
+>:t foo
+foo :: Integer
+
+-- Vous pouvez également lancer des actions de type `IO ()`
+
+> sayHello
+Quel est ton nom ?
+Ami
+Salut, Ami !
+
+```
+
+Et Haskell ne se limite pas à ça, on trouve encore par exemple les classes de types et les monades. Il y a beaucoup de raisons qui font que coder en Haskell est si *fun*. Je vous laisse avec un dernier exemple : une implémentation de quicksort :
+
+```haskell
+qsort [] = []
+qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater
+    where lesser  = filter (< p) xs
+          greater = filter (>= p) xs
+```
+
+Haskell facile à installer. Téléchargez-le [ici](http://www.haskell.org/platform/).
+
+Vous pouvez trouver une approche beaucoup plus douce avec les excellents
+[Learn you a Haskell](http://lyah.haskell.fr/) ou
+[Real World Haskell (en)](http://book.realworldhaskell.org/).
diff --git a/fr-fr/haskell.html.markdown b/fr-fr/haskell.html.markdown
deleted file mode 100644
index a34dc098..00000000
--- a/fr-fr/haskell.html.markdown
+++ /dev/null
@@ -1,431 +0,0 @@
----
-language: Haskell
-contributors:
-    - ["Adit Bhargava", "http://adit.io"]
-translators:
-    - ["David Baumgartner", "http://davidbaumgartner.ch"]    
-lang: fr-fr
-filename: learnhaskell-fr.hs
----
-
-Haskell a été conçu pour être un langage fonctionnel pur et maniable. Il est connu pour ses monades et son système de types, mais je n'ai cesse d'y revenir pour son élégance. Pour moi, Haskell fait de la programmation une joie.
-
-```haskell
--- Un commentaire en une ligne commence avec deux tirets.
-{- Un commentaire sur plusieurs lignes peut être contenu dans
-un bloc de cette façon.
--}
-
-----------------------------------------------------
--- 1. Types de données primitifs et opérateurs
-----------------------------------------------------
-
--- Vous avez les nombres
-3 -- 3
-
--- Les maths sont comme vous vous y attendez
-1 + 1 -- 2
-8 - 1 -- 7
-10 * 2 -- 20
-35 / 5 -- 7.0
-
--- La division n'est pas entière par défaut
-35 / 4 -- 8.75
-
--- division entière
-35 `div` 4 -- 8
-
--- Les booléens sont primitifs
-True
-False
-
--- Opérations avec les booléens
-not True -- False
-not False -- True
-1 == 1 -- True
-1 /= 1 -- False
-1 < 10 -- True
-
--- Dans les exemples plus hauts, `not` est une fonction qui prend une valeur.
--- Haskell n'a pas besoin de parenthèses pour appeler une fonction... tous
--- les arguments sont juste listés après la fonction. Le schéma général est
--- donc :
--- func arg1 arg2 arg3...
--- Voyez la section sur les fonctions pour savoir comment écrire les vôtres.
-
--- Caractères et chaînes de caractère
-"Ceci est une chaîne de caractère."
-'a' -- caractère
-'Vous ne pouvez pas utiliser des apostrophes pour les chaînes de caractère.' -- erreur !
-
--- Les chaînes peuvent être concaténées
-"Hello " ++ "world!" -- "Hello world!"
-
--- Une chaîne de caractère est *réellement* une liste
-"Ceci est une chaîne." !! 0 -- 'C'
-
-
-----------------------------------------------------
--- 2. Listes et tuples
-----------------------------------------------------
-
--- Tous les éléments d'une liste doit avoir le même type.
--- les deux lignes suivantes sont semblables
-[1, 2, 3, 4, 5]
-[1..5]
-
--- Il y a aussi des listes infinies en Haskell !
-[1..] -- une liste de tous les nombres naturels
-
--- Les listes infinies fonctionnent parce que Haskell est « paresseux »:
--- ça veut dire qu'il n'évalue que ce qui a besoin de l'être. Vous pouvez
--- donc vous demander le 1000e élément de votre liste et il vous le donnera :
-
-[1..] !! 999 -- 1000
-
--- Et là, Haskell a évalué les éléments 1 à 1000 de la liste... mais le reste
--- de cette liste « infinie » n'existe pas encore ! En fait, Haskell ne va jamais 
--- le faire à moins qu'il ne le doive.
-
--- Adjoindre deux listes 
-[1..5] ++ [6..10]
-
--- ajouter au début de la liste
-0:[1..5] -- [0, 1, 2, 3, 4, 5]
-
--- l'indice d'une liste
-[0..] !! 5 -- 5
-
--- d'autres opérations sur les listes
-head [1..5] -- 1
-tail [1..5] -- [2, 3, 4, 5]
-init [1..5] -- [1, 2, 3, 4]
-last [1..5] -- 5
-
---liste en compréhension
-[x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10]
-
---avec un conditionnel
-[x*2 | x <- [1..5], x*2 > 4] -- [6, 8, 10]
-
--- Chaque élément d'un tuple peut être d'un type différent, mais un
--- tuple a une longueur fixée.
--- Un tuple :
-("haskell", 1)
-
--- accéder aux éléments d'un tuple
-fst ("haskell", 1) -- "haskell"
-snd ("haskell", 1) -- 1
-
-----------------------------------------------------
--- 3. Functions
-----------------------------------------------------
--- Une simple fonction qui prend deux paramètres
-add a b = a + b
-
--- Notez que si vous utilisez ghci (l'interpréteur Haskell)
--- vous devrez utiliser `let`. Par exemple :
--- let add a b = a + b
-
--- Utiliser une fonction
-add 1 2 -- 3
-
--- Vous pouvez également mettre le nom de la fonction entre les
--- deux arguments avec des accents graves :
-1 `add` 2 -- 3
-
--- Vous pouvez également définir des fonctions qui n'ont pas de
--- lettres ! Ça vous laisse créer vos propres opérateurs ! Voilà 
--- un opérateur qui fait une division entière :
-(//) a b = a `div` b
-35 // 4 -- 8
-
--- Gardes : Une façon de gérer la valeur de vos arguments en amont
-fib x
-  | x < 2 = x
-  | otherwise = fib (x - 1) + fib (x - 2)
-
--- Le filtrage par motif est similaire. Là, on a donné trois 
--- définitions différentes de `fib`. Haskell appellera automatiquement
--- la première fonction qui correspond au motif de la valeur.
-fib 1 = 1
-fib 2 = 2
-fib x = fib (x - 1) + fib (x - 2)
-
--- Filtrage par motif sur un tuple.
-foo (x, y) = (x + 1, y + 2)
-
--- Filtrage par motif sur des listes. Ici, `x` est le premier
--- élément de la liste, et `xs` le reste. On peut écrire notre
--- propre fonction `map` :
-myMap func [] = []
-myMap func (x:xs) = func x:(myMap func xs)
-
--- Les fonctions anonymes sont créées avec des barres obliques 
--- inverses, suivies de tous les arguments.
-myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7]
-
--- Une utilisation de fold (appelée `inject` dans quelques autres
--- langages) avec comme paramètre une fonction anonyme.
--- `foldl1` veut dire fold left -- soit littéralement pli gauche --
--- et utilise la première valeur de la liste comme accumulateur.
-foldl1 (\acc x -> acc + x) [1..5] -- 15
-
-----------------------------------------------------
--- 4. Plus de fonctions
-----------------------------------------------------
-
--- curryfication : si vous n'appliquez pas tous les arguments à une
--- fonction, elle devient « curryfiée ». Ça veut dire qu'elle retourne
--- une fonction qui prend le reste des arguments.
-
-add a b = a + b
-foo = add 10 -- foo est une fonction qui prend un nombre et y ajoute 10
-foo 5 -- 15
-
--- Une autre façon de l'écrire
-foo = (+10)
-foo 5 -- 15
-
--- Composition de fonctions
--- la fonction (.) enchaîne deux fonctions.
--- Par exemple, on a foo qui est une fonction qui prend une valeur, y ajoute
--- 10 et multiplie ce résultat par 5, et ensuite retourne la valeur finale.
-foo = (*5) . (+10)
-
--- (5 + 10) * 5 = 75
-foo 5 -- 75
-
--- fixation de priorité
--- Haskell a une autre fonction appelée `$`. Elle peut changer la priorité
--- de sorte que tout ce qu'il y a à sa gauche est calculé d'abord et ensuite 
--- appliqué à tout ce qu'il y a à droite. Vous pouvez utiliser `.` et `$` 
--- pour vous débarrasser de beaucoup de parenthèses :
-
--- avant
-(even (fib 7)) -- False
-
--- ensuite
-even . fib $ 7 -- False
-
-----------------------------------------------------
--- 5. Signature de type
-----------------------------------------------------
-
--- Haskell a un système de types très strict : par exemple, tout a un type.
-
--- Quelques types simples :
-5 :: Integer
-"hello" :: String
-True :: Bool
-
--- Les fonctions ont également des types.
--- `not` prend un booléen et retourne un booléen.
--- not :: Bool -> Bool
-
--- Voilà une fonction qui prend deux paramètres.
--- add :: Integer -> Integer -> Integer
-
--- Quand vous définissez une valeur (souvenez-vous, tout est valeur en
--- Haskell), une bonne pratique est d'écrire son type explicitement
-double :: Integer -> Integer
-double x = x * 2
-
-----------------------------------------------------
--- 6. Flux de contrôle et structures conditionnelles
-----------------------------------------------------
-
--- structure conditionnelle if
-haskell = if 1 == 1 then "awesome" else "awful" -- haskell = "awesome"
-
--- les structures if peuvent être écrites sur plusieurs lignes
-haskell = if 1 == 1
-            then "awesome"
-            else "awful"
-
--- les structures case : voilà comment vous pourriez analyser les arguments de 
--- ligne de commande
-case args of
-  "help" -> printHelp
-  "start" -> startProgram
-  _ -> putStrLn "bad args"
-
-
--- Haskell n'a pas de boucles parce qu'il utilise la récursion.
--- `map` applique une fonction sur chaque élément d'une liste
-
-map (*2) [1..5] -- [2, 4, 6, 8, 10]
-
--- vous pouvez créer une fonction `for` en utilisant `map`
-for array func = map func array
-
--- et l'utiliser
-for [0..5] $ \i -> show i
-
--- nous aurions pu l'écrire également ainsi
-for [0..5] show
-
--- vous pouvez utiliser foldl et foldr pour 
--- réduire une liste
--- foldl <fonction> <valeur initiale> <liste>
-foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43
-
--- C'est donc la même chose que 
-(2 * (2 * (2 * 4 + 1) + 2) + 3)
-
--- foldl évalue de gauche à droite, foldr
--- de droite à gauche
-foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16
-
--- Et c'est équivalent à
-(2 * 3 + (2 * 2 + (2 * 1 + 4)))
-
-----------------------------------------------------
--- 7. Types de données
-----------------------------------------------------
-
--- Vous pouvez écrire vos propres types de données en Haskell
-
-data Couleur = Rouge | Bleu | Vert
-
--- Et maintenant l'utiliser dans une fonction
-
-
-say :: Couleur -> String
-say Rouge = "Vous êtes Rouge !"
-say Bleu = "Vous êtes Bleu !"
-say Vert =  "Vous êtes Vert !"
-
--- Vos types peuvent également avoir des paramètres
-
-data Maybe a = Nothing | Just a
-
--- Tous les exemples ci-dessous sont issus du type Maybe
-Just "hello"    -- of type `Maybe String`
-Just 1          -- of type `Maybe Int`
-Nothing         -- of type `Maybe a` for any `a`
-
-----------------------------------------------------
--- 8. Haskell IO
-----------------------------------------------------
-
--- Tandis que l'IO ne peut pas être totalement expliqué pleinement
--- sans que les monades ne le soient, il n'est pas difficile
--- d'expliquer suffisamment pour commencer.
-
--- Quand un programme en Haskell est exécuté, la fonction `main`
--- est appelée. Il doit retourner une valeur de type `IO ()`.
--- Par exemple :
-
-main :: IO ()
-main = putStrLn $ "Bonjour, le ciel ! " ++ (say Blue) 
--- putStrLn a comme type String -> IO ()
-
--- La façon la plus simple pour faire de l'IO est de faire un programme 
--- fonction de String vers String. La fonction
---    interact :: (String -> String) -> IO ()
--- prend un texte, applique une fonction et affiche le résultat.
-
-countLines :: String -> String
-countLines = show . length . lines
-
-main' = interact countLines
-
--- Vous pouvez considérer qu'une valeur de type `IO ()` représente
--- une séquence d'actions que l'ordinateur exécute, un peu comme 
--- dans un langage impératif. On peut utiliser la structure `do` 
--- pour enchaîner des actions. Par exemple :
-
-sayHello :: IO ()
-sayHello = do 
-   putStrLn "Quel est ton nom ?"
-   name <- getLine -- prend une ligne et assigne sa valeur à `name`
-   putStrLn $ "Salut, " ++ name
-   
--- Exercice : écrire votre propre version d'`interact` qui ne fait 
---           que de lire une ligne d'entrée.
-   
--- Le code de `sayHello` ne sera jamais exécuté, cependant. La seule
--- action qui sera exécutée est la valeur de `main`.
--- Pour lancer `sayHello`, commentez l'ancienne définition de `main`
--- et remplacez-le par :
---   main = sayHello
-
--- Essaions de mieux comprendre comment la fonction `getLine` que 
--- nous venons d'utiliser. Son type est :
---    getLine :: IO String
--- vous pouvez considérer le type `IO a` comme un programme que
--- le programme va générer comme une valeur de type `a` quand
--- il sera exécuté. On peut l'enregistrer et la réutiliser en
--- utilisant `<-`. On peut aussi faire nos propres actions
--- de type `IO String` :
-
-action :: IO String
-action = do
-   putStrLn "C'est une ligne. Heu"
-   input1 <- getLine 
-   input2 <- getLine
-   -- Le type de la structure `do` est celui de sa dernière ligne.
-   -- `return` n'est pas un mot clef, mais simplement une fonction.
-   return (input1 ++ "\n" ++ input2) -- return :: String -> IO String
-
--- On peut maintenant l'utiliser comme on a utilisé `getLine`
--- tout à l'heure
-
-main'' = do
-    putStrLn "Je vais afficher deux lignes !"
-    result <- action 
-    putStrLn result
-    putStrLn "C'était tout !"
-
--- Le type `IO` est un exemple de « monade ». La façon dont Haskell utilise
--- une monade pour faire de l'IO lui permet d'être purement fonctionnel. N'importe
--- quelle fonction qui interagit avec le « monde extérieur » (c'est à dire fait de l'IO)
--- devient marqué comme `IO` dans la signature de son type. Ça nous montre
--- quelles fonctions sont « pures » (n'interagissent pas avec le monde extérieur
--- ou ne changent pas d'état) et quelles fonctions ne le sont pas.
-
--- C'est une fonctionnalité très puissante, car il est facile d'exécuter 
--- des fonctions pures simultanément, et donc la concurrence en Haskell
--- est très facile.
-
-
-----------------------------------------------------
--- 9. Le REPL de Haskell
-----------------------------------------------------
-
--- Lancer le REPL en tapant `ghci`.
--- Vous pouvez maintenant taper du code Haskell.
--- Toutes les nouvelles valeurs peuvent être crées 
--- avec `let` :
-
-let foo = 5
-
--- Vous pouvez voir le type de n'importe quelle valeur avec `:t` :
-
->:t foo
-foo :: Integer
-
--- Vous pouvez également lancer des actions de type `IO ()`
-
-> sayHello
-Quel est ton nom ?
-Ami
-Salut, Ami !
-
-```
-
-Et Haskell ne se limite pas à ça, on trouve encore par exemple les classes de types et les monades. Il y a beaucoup de raisons qui font que coder en Haskell est si *fun*. Je vous laisse avec un dernier exemple : une implémentation de quicksort :
-
-```haskell
-qsort [] = []
-qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater
-    where lesser  = filter (< p) xs
-          greater = filter (>= p) xs
-```
-
-Haskell facile à installer. Téléchargez-le [ici](http://www.haskell.org/platform/).
-
-Vous pouvez trouver une approche beaucoup plus douce avec les excellents
-[Learn you a Haskell](http://lyah.haskell.fr/) ou
-[Real World Haskell (en)](http://book.realworldhaskell.org/).
diff --git a/fr-fr/markdown-fr.html.markdown b/fr-fr/markdown-fr.html.markdown
new file mode 100644
index 00000000..2e4e8461
--- /dev/null
+++ b/fr-fr/markdown-fr.html.markdown
@@ -0,0 +1,289 @@
+---
+language: markdown
+contributors:
+- ["Andrei Curelaru", "http://www.infinidad.fr"]
+filename: markdown-fr.md
+lang: fr-fr
+---
+
+Markdown a été créé par John Gruber en 2004. Il se veut être d'une syntaxe
+facile à lire et à écrire, aisément convertible en HTML
+ (et beaucoup d'autres formats aussi à présent).
+
+Faites moi autant de retours que vous voulez! Sentez vous libre de "forker" 
+et envoyer des pull request!
+
+
+```markdown
+<!-- Markdown est une sorte de cousin du HTML, si bien que tout document HTML 
+est un document Markdown valide. Autrement dit, vous pouvez utiliser des 
+balises HTML dans un fichier Markdown, comme la balise commentaire dans 
+laquelle nous sommes à présent, car celle-ci ne sera pas affectée par 
+le parser( analyseur syntaxique ) Markdown. -->
+
+<!-- Toutefois, si vous voulez créer un élément HTML dans un fichier Markdown,
+ vous ne pourrez pas utiliser du Markdown à l'intérieur de ce dernier. -->
+
+<!--  Le Markdown est implémenté de différentes manières, selon le parser. 
+Ce guide va alors tenter de trier les fonctionnalités universelles de celles
+spécifiques à un parser.  -->
+
+<!-- Headers ( En-têtes ) -->
+<!-- Vous pouvez facilement créer des éléments HTML <h1> à <h6> en précédant
+ le texte de votre futur titre par un ou plusieurs dièses ( # ), de un à six,
+  selon le niveau de titre souhaité. -->
+# Ceci est un <h1>
+## Ceci est un <h2>
+### Ceci est un <h3>
+#### Ceci est un <h4>
+##### Ceci est un <h5>
+###### Ceci est un <h6>
+
+<!-- 
+Markdown fournit également une façon alternative de marquer les h1 et h2 
+-->
+
+Ceci est un h1
+=============
+
+Ceci est un h2
+-------------
+
+<!-- Styles basiques pour du texte -->
+<!-- On peut facilement rendre un texte "gras" ou "italique" en Markdown -->
+
+*Ce texte est en italique.*
+_Celui-ci aussi._
+
+**Ce texte est en gras.**
+__Celui-là aussi.__
+
+***Ce texte a les deux styles.***
+**_Pareil ici_**
+*__Et là!__*
+
+<!-- Dans le "GitHub Flavored Markdown", utilisé pour interpréter le Markdown 
+sur GitHub, on a également le strikethrough ( texte barré ) : -->
+
+~~Ce texte est barré avec strikethrough.~~
+
+<!--  Les Paragraphes sont représentés par une ou plusieurs lignes de texte 
+séparées par une ou plusieurs lignes vides. -->
+
+Ceci est un paragraphe. Là, je suis dans un paragraphe, facile non?
+
+Maintenant je suis dans le paragraphe 2.
+Je suis toujours dans le paragraphe 2!
+
+
+Puis là, eh oui, le paragraphe 3!
+
+<!--  
+Si jamais vous souhaitez insérer une balise HTML <br />, vous pouvez ajouter 
+un ou plusieurs espaces à la fin de votre paragraphe, et en commencer 
+un nouveau.
+-->
+
+J'ai deux espaces vides à la fin (sélectionnez moi pour les voir). 
+
+Bigre, il y a un <br /> au dessus de moi!
+
+<!-- Les 'Blocs de Citations' sont générés aisément, grâce au caractère > -->
+
+> Ceci est une superbe citation. Vous pouvez même
+> revenir à la ligne quand ça vous chante, et placer un `>` 
+> devant chaque bout de ligne faisant partie
+> de la citation.
+> La taille ne compte pas^^ tant que chaque ligne commence par un `>`.
+
+> Vous pouvez aussi utiliser plus d'un niveau
+>> d'imbrication!
+> Classe et facile, pas vrai?
+
+<!-- les Listes -->
+<!-- les Listes non ordonnées sont marquées par des asterisques, 
+signes plus ou signes moins. -->
+
+* Item
+* Item
+* Un autre item
+
+ou
+
++ Item
++ Item
++ Encore un item
+
+ou
+
+- Item
+- Item
+- Un dernier item
+
+<!-- les Listes Ordonnées sont générées via un nombre suivi d'un point -->
+
+1. Item un
+2. Item deux
+3. Item trois
+
+<!-- Vous pouvez même vous passer de tout numéroter, et Markdown générera 
+les bons chiffres. Ceci dit, cette variante perd en clarté.-->
+
+1. Item un
+1. Item deux
+1. Item trois
+<!-- ( cette liste sera interprétée de la même façon que celle au dessus ) -->
+
+<!-- Vous pouvez également utiliser des sous-listes -->
+
+1. Item un
+2. Item deux
+3. Item trois
+* Sub-item
+* Sub-item
+4. Item quatre
+
+<!-- Il y a même des "listes de Taches". Elles génèrent des champs HTML 
+de type checkbox. -->
+
+Les [ ] ci dessous, n'ayant pas de [ x ], 
+deviendront des cases à cocher HTML non-cochées.
+
+- [ ] Première tache à réaliser.
+- [ ] Une autre chose à faire.
+La case suivante sera une case à cocher HTML cochée.
+- [x] Ça ... c'est fait!
+
+<!-- les Blocs de Code -->
+<!-- Pour marquer du texte comme étant du code, il suffit de commencer 
+chaque ligne en tapant 4 espaces (ou un Tab) -->
+
+    echo "Ça, c'est du Code!";
+    var Ça = "aussi !";
+
+<!-- L'indentation par tab ou série de quatre espaces 
+fonctionne aussi à l'intérieur du bloc de code -->
+
+    my_array.each do |item|
+       puts item
+    end
+
+<!-- Des bouts de code en mode 'inline' s'ajoutent en les entourant de ` -->
+
+La fonction `run()` ne vous oblige pas à aller courir!
+
+<!-- Via GitHub Flavored Markdown, vous pouvez utiliser 
+des syntaxes spécifiques -->
+
+\`\`\`ruby 
+<!-- mais enlevez les backslashes quand vous faites ça, 
+gardez juste ```ruby ( ou nom de la syntaxe correspondant à votre code )-->
+def foobar
+puts "Hello world!"
+end
+\`\`\` <!-- pareil, pas de backslashes, juste ``` en guise de fin -->
+
+<-- Pas besoin d'indentation pour le code juste au dessus, de plus, GitHub 
+va utiliser une coloration syntaxique pour le langage indiqué après les ``` -->
+
+<!-- Ligne Horizontale (<hr />) -->
+<!-- Pour en insérer une, utilisez trois ou plusieurs astérisques ou tirets, 
+avec ou sans espaces entre chaque un. -->
+
+***
+---
+- - -
+****************
+
+<!-- Liens -->
+<!-- Une des fonctionnalités sympathiques du Markdown est la facilité 
+d'ajouter des liens. Le texte du lien entre [ ], l'url entre ( ), 
+et voilà l'travail.
+-->
+
+[Clic moi!](http://test.com/)
+
+<!-- 
+Pour ajouter un attribut Title, collez le entre guillemets, avec le lien. 
+-->
+
+[Clic moi!](http://test.com/ "Lien vers Test.com")
+
+<!-- les Liens Relatifs marchent aussi -->
+
+[En avant la musique](/music/).
+
+<!-- Les liens façon "références" sont eux aussi disponibles en Markdown -->
+
+[Cliquez ici][link1] pour plus d'information!
+[Regardez aussi par ici][foobar] si vous voulez.
+
+[link1]: http://test.com/ "Cool!"
+[foobar]: http://foobar.biz/ "Alright!"
+
+<!--  Le titre peut aussi être entouré de guillemets simples, 
+entre parenthèses ou absent. Les références peuvent être placées 
+un peu où vous voulez dans le document, et les identifiants 
+(link1, foobar, ...) quoi que ce soit tant qu'ils sont uniques -->
+
+<!-- Il y a également le "nommage implicite" qui transforme le texte du lien
+ en identifiant -->
+
+[Ceci][] est un lien.
+
+[ceci]: http://ceciestunlien.com/
+
+<!-- mais ce n'est pas beaucoup utilisé. -->
+
+<!-- Images -->
+<!-- Pour les images, la syntaxe est identique aux liens, sauf que précédée
+ d'un point d'exclamation! -->
+
+![Attribut ALT de l'image](http://imgur.com/monimage.jpg "Titre optionnel")
+
+<!-- Là aussi, on peut utiliser le mode "références" -->
+
+![Ceci est l'attribut ALT de l'image][monimage]
+
+[monimage]: relative/urls/cool/image.jpg "si vous voulez un titre, c'est ici."
+
+<!-- Divers -->
+<!-- Liens Automatiques -->
+
+<http://testwebsite.com/> est équivalent à :
+[http://testwebsite.com/](http://testwebsite.com/)
+
+<!-- Liens Automatiques pour emails -->
+
+<foo@bar.com>
+
+<!-- Escaping -->
+Il suffit de précéder les caractères spécifiques à ignorer par des backslash \
+
+Pour taper *ce texte* entouré d'astérisques mais pas en italique : 
+Tapez \*ce texte\*.
+
+<!-- Tableaux -->
+<!-- les Tableaux ne sont disponibles que dans le GitHub Flavored Markdown
+ et c'est ce n'est pas super agréable d'utilisation. 
+ Mais si vous en avez besoin :
+ -->
+
+| Col1 | Col2 | Col3 |
+| :----------- | :------: | ------------: |
+| Alignement Gauche | Centé | Alignement Droite |
+| bla | bla | bla |
+
+<!-- ou bien, pour un résultat équivalent : -->
+
+Col 1 | Col2 | Col3
+:-- | :-: | --:
+Ough que c'est moche | svp | arrêtez
+
+<!-- Fin! -->
+
+```
+
+Pour plus d'information :
+ consultez [ici](http://daringfireball.net/projects/markdown/syntax) le post officiel de Jhon Gruber à propos de la syntaxe, 
+ et [là](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) la superbe cheatsheet de Adam Pritchard.
diff --git a/fr-fr/markdown.html.markdown b/fr-fr/markdown.html.markdown
deleted file mode 100644
index 2e4e8461..00000000
--- a/fr-fr/markdown.html.markdown
+++ /dev/null
@@ -1,289 +0,0 @@
----
-language: markdown
-contributors:
-- ["Andrei Curelaru", "http://www.infinidad.fr"]
-filename: markdown-fr.md
-lang: fr-fr
----
-
-Markdown a été créé par John Gruber en 2004. Il se veut être d'une syntaxe
-facile à lire et à écrire, aisément convertible en HTML
- (et beaucoup d'autres formats aussi à présent).
-
-Faites moi autant de retours que vous voulez! Sentez vous libre de "forker" 
-et envoyer des pull request!
-
-
-```markdown
-<!-- Markdown est une sorte de cousin du HTML, si bien que tout document HTML 
-est un document Markdown valide. Autrement dit, vous pouvez utiliser des 
-balises HTML dans un fichier Markdown, comme la balise commentaire dans 
-laquelle nous sommes à présent, car celle-ci ne sera pas affectée par 
-le parser( analyseur syntaxique ) Markdown. -->
-
-<!-- Toutefois, si vous voulez créer un élément HTML dans un fichier Markdown,
- vous ne pourrez pas utiliser du Markdown à l'intérieur de ce dernier. -->
-
-<!--  Le Markdown est implémenté de différentes manières, selon le parser. 
-Ce guide va alors tenter de trier les fonctionnalités universelles de celles
-spécifiques à un parser.  -->
-
-<!-- Headers ( En-têtes ) -->
-<!-- Vous pouvez facilement créer des éléments HTML <h1> à <h6> en précédant
- le texte de votre futur titre par un ou plusieurs dièses ( # ), de un à six,
-  selon le niveau de titre souhaité. -->
-# Ceci est un <h1>
-## Ceci est un <h2>
-### Ceci est un <h3>
-#### Ceci est un <h4>
-##### Ceci est un <h5>
-###### Ceci est un <h6>
-
-<!-- 
-Markdown fournit également une façon alternative de marquer les h1 et h2 
--->
-
-Ceci est un h1
-=============
-
-Ceci est un h2
--------------
-
-<!-- Styles basiques pour du texte -->
-<!-- On peut facilement rendre un texte "gras" ou "italique" en Markdown -->
-
-*Ce texte est en italique.*
-_Celui-ci aussi._
-
-**Ce texte est en gras.**
-__Celui-là aussi.__
-
-***Ce texte a les deux styles.***
-**_Pareil ici_**
-*__Et là!__*
-
-<!-- Dans le "GitHub Flavored Markdown", utilisé pour interpréter le Markdown 
-sur GitHub, on a également le strikethrough ( texte barré ) : -->
-
-~~Ce texte est barré avec strikethrough.~~
-
-<!--  Les Paragraphes sont représentés par une ou plusieurs lignes de texte 
-séparées par une ou plusieurs lignes vides. -->
-
-Ceci est un paragraphe. Là, je suis dans un paragraphe, facile non?
-
-Maintenant je suis dans le paragraphe 2.
-Je suis toujours dans le paragraphe 2!
-
-
-Puis là, eh oui, le paragraphe 3!
-
-<!--  
-Si jamais vous souhaitez insérer une balise HTML <br />, vous pouvez ajouter 
-un ou plusieurs espaces à la fin de votre paragraphe, et en commencer 
-un nouveau.
--->
-
-J'ai deux espaces vides à la fin (sélectionnez moi pour les voir). 
-
-Bigre, il y a un <br /> au dessus de moi!
-
-<!-- Les 'Blocs de Citations' sont générés aisément, grâce au caractère > -->
-
-> Ceci est une superbe citation. Vous pouvez même
-> revenir à la ligne quand ça vous chante, et placer un `>` 
-> devant chaque bout de ligne faisant partie
-> de la citation.
-> La taille ne compte pas^^ tant que chaque ligne commence par un `>`.
-
-> Vous pouvez aussi utiliser plus d'un niveau
->> d'imbrication!
-> Classe et facile, pas vrai?
-
-<!-- les Listes -->
-<!-- les Listes non ordonnées sont marquées par des asterisques, 
-signes plus ou signes moins. -->
-
-* Item
-* Item
-* Un autre item
-
-ou
-
-+ Item
-+ Item
-+ Encore un item
-
-ou
-
-- Item
-- Item
-- Un dernier item
-
-<!-- les Listes Ordonnées sont générées via un nombre suivi d'un point -->
-
-1. Item un
-2. Item deux
-3. Item trois
-
-<!-- Vous pouvez même vous passer de tout numéroter, et Markdown générera 
-les bons chiffres. Ceci dit, cette variante perd en clarté.-->
-
-1. Item un
-1. Item deux
-1. Item trois
-<!-- ( cette liste sera interprétée de la même façon que celle au dessus ) -->
-
-<!-- Vous pouvez également utiliser des sous-listes -->
-
-1. Item un
-2. Item deux
-3. Item trois
-* Sub-item
-* Sub-item
-4. Item quatre
-
-<!-- Il y a même des "listes de Taches". Elles génèrent des champs HTML 
-de type checkbox. -->
-
-Les [ ] ci dessous, n'ayant pas de [ x ], 
-deviendront des cases à cocher HTML non-cochées.
-
-- [ ] Première tache à réaliser.
-- [ ] Une autre chose à faire.
-La case suivante sera une case à cocher HTML cochée.
-- [x] Ça ... c'est fait!
-
-<!-- les Blocs de Code -->
-<!-- Pour marquer du texte comme étant du code, il suffit de commencer 
-chaque ligne en tapant 4 espaces (ou un Tab) -->
-
-    echo "Ça, c'est du Code!";
-    var Ça = "aussi !";
-
-<!-- L'indentation par tab ou série de quatre espaces 
-fonctionne aussi à l'intérieur du bloc de code -->
-
-    my_array.each do |item|
-       puts item
-    end
-
-<!-- Des bouts de code en mode 'inline' s'ajoutent en les entourant de ` -->
-
-La fonction `run()` ne vous oblige pas à aller courir!
-
-<!-- Via GitHub Flavored Markdown, vous pouvez utiliser 
-des syntaxes spécifiques -->
-
-\`\`\`ruby 
-<!-- mais enlevez les backslashes quand vous faites ça, 
-gardez juste ```ruby ( ou nom de la syntaxe correspondant à votre code )-->
-def foobar
-puts "Hello world!"
-end
-\`\`\` <!-- pareil, pas de backslashes, juste ``` en guise de fin -->
-
-<-- Pas besoin d'indentation pour le code juste au dessus, de plus, GitHub 
-va utiliser une coloration syntaxique pour le langage indiqué après les ``` -->
-
-<!-- Ligne Horizontale (<hr />) -->
-<!-- Pour en insérer une, utilisez trois ou plusieurs astérisques ou tirets, 
-avec ou sans espaces entre chaque un. -->
-
-***
----
-- - -
-****************
-
-<!-- Liens -->
-<!-- Une des fonctionnalités sympathiques du Markdown est la facilité 
-d'ajouter des liens. Le texte du lien entre [ ], l'url entre ( ), 
-et voilà l'travail.
--->
-
-[Clic moi!](http://test.com/)
-
-<!-- 
-Pour ajouter un attribut Title, collez le entre guillemets, avec le lien. 
--->
-
-[Clic moi!](http://test.com/ "Lien vers Test.com")
-
-<!-- les Liens Relatifs marchent aussi -->
-
-[En avant la musique](/music/).
-
-<!-- Les liens façon "références" sont eux aussi disponibles en Markdown -->
-
-[Cliquez ici][link1] pour plus d'information!
-[Regardez aussi par ici][foobar] si vous voulez.
-
-[link1]: http://test.com/ "Cool!"
-[foobar]: http://foobar.biz/ "Alright!"
-
-<!--  Le titre peut aussi être entouré de guillemets simples, 
-entre parenthèses ou absent. Les références peuvent être placées 
-un peu où vous voulez dans le document, et les identifiants 
-(link1, foobar, ...) quoi que ce soit tant qu'ils sont uniques -->
-
-<!-- Il y a également le "nommage implicite" qui transforme le texte du lien
- en identifiant -->
-
-[Ceci][] est un lien.
-
-[ceci]: http://ceciestunlien.com/
-
-<!-- mais ce n'est pas beaucoup utilisé. -->
-
-<!-- Images -->
-<!-- Pour les images, la syntaxe est identique aux liens, sauf que précédée
- d'un point d'exclamation! -->
-
-![Attribut ALT de l'image](http://imgur.com/monimage.jpg "Titre optionnel")
-
-<!-- Là aussi, on peut utiliser le mode "références" -->
-
-![Ceci est l'attribut ALT de l'image][monimage]
-
-[monimage]: relative/urls/cool/image.jpg "si vous voulez un titre, c'est ici."
-
-<!-- Divers -->
-<!-- Liens Automatiques -->
-
-<http://testwebsite.com/> est équivalent à :
-[http://testwebsite.com/](http://testwebsite.com/)
-
-<!-- Liens Automatiques pour emails -->
-
-<foo@bar.com>
-
-<!-- Escaping -->
-Il suffit de précéder les caractères spécifiques à ignorer par des backslash \
-
-Pour taper *ce texte* entouré d'astérisques mais pas en italique : 
-Tapez \*ce texte\*.
-
-<!-- Tableaux -->
-<!-- les Tableaux ne sont disponibles que dans le GitHub Flavored Markdown
- et c'est ce n'est pas super agréable d'utilisation. 
- Mais si vous en avez besoin :
- -->
-
-| Col1 | Col2 | Col3 |
-| :----------- | :------: | ------------: |
-| Alignement Gauche | Centé | Alignement Droite |
-| bla | bla | bla |
-
-<!-- ou bien, pour un résultat équivalent : -->
-
-Col 1 | Col2 | Col3
-:-- | :-: | --:
-Ough que c'est moche | svp | arrêtez
-
-<!-- Fin! -->
-
-```
-
-Pour plus d'information :
- consultez [ici](http://daringfireball.net/projects/markdown/syntax) le post officiel de Jhon Gruber à propos de la syntaxe, 
- et [là](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) la superbe cheatsheet de Adam Pritchard.
diff --git a/fr-fr/php-fr.html.markdown b/fr-fr/php-fr.html.markdown
new file mode 100644
index 00000000..823630bd
--- /dev/null
+++ b/fr-fr/php-fr.html.markdown
@@ -0,0 +1,697 @@
+---
+language: PHP
+filename: php-fr.php
+contributors:
+    - ["Malcolm Fell", "http://emarref.net/"]
+    - ["Trismegiste", "https://github.com/Trismegiste"]
+translators:
+    - ["Pascal Boutin", "http://pboutin.net/"]
+lang: fr-fr
+---
+
+This document describes PHP 5+.
+
+```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 la balise '?>'
+
+// Deux barres obliques amorcent un commentaire simple.
+
+# 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-lignes.
+*/
+
+// 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
+
+// toutes 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 de 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 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 à
+// 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és avec des guillemets
+$escaped   = "This contains a \t tab character.";
+$unescaped = 'This just contains a slash and a t: \t';
+
+// En cas de besoin, placez la variable dans des accolades
+$money = "I have $${number} in the bank.";
+
+// 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;
+
+// Heredoc 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)
+ */
+
+// Tous les tableaux en PHP sont associatifs (hashmaps),
+
+// Fonctionne dans toutes 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 du 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 convivial
+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 vraies, 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 vraies 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épendamment 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 nulle
+
+
+/********************************
+ * 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>Ceci est affiché si $x est faux</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 "The $vehicle have $wheel_count wheels";
+}
+
+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 immé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"
+
+
+// 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;
+  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 une balise 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"
+
+// On peut empêcher qu'une classe soit héritée
+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é par les bonnes pratiques, visitez
+[PHP The Right Way](http://www.phptherightway.com/) (anglais seulement).
+
+Si vous êtes habitué à utiliser de bons gestionaires de dépendances, regardez
+[Composer](http://getcomposer.org/).
+
+Pour consulter les standards, visitez "the PHP Framework Interoperability Groups"
+[PSR standards](https://github.com/php-fig/fig-standards).
diff --git a/fr-fr/php.html.markdown b/fr-fr/php.html.markdown
deleted file mode 100644
index 823630bd..00000000
--- a/fr-fr/php.html.markdown
+++ /dev/null
@@ -1,697 +0,0 @@
----
-language: PHP
-filename: php-fr.php
-contributors:
-    - ["Malcolm Fell", "http://emarref.net/"]
-    - ["Trismegiste", "https://github.com/Trismegiste"]
-translators:
-    - ["Pascal Boutin", "http://pboutin.net/"]
-lang: fr-fr
----
-
-This document describes PHP 5+.
-
-```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 la balise '?>'
-
-// Deux barres obliques amorcent un commentaire simple.
-
-# 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-lignes.
-*/
-
-// 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
-
-// toutes 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 de 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 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 à
-// 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és avec des guillemets
-$escaped   = "This contains a \t tab character.";
-$unescaped = 'This just contains a slash and a t: \t';
-
-// En cas de besoin, placez la variable dans des accolades
-$money = "I have $${number} in the bank.";
-
-// 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;
-
-// Heredoc 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)
- */
-
-// Tous les tableaux en PHP sont associatifs (hashmaps),
-
-// Fonctionne dans toutes 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 du 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 convivial
-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 vraies, 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 vraies 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épendamment 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 nulle
-
-
-/********************************
- * 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>Ceci est affiché si $x est faux</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 "The $vehicle have $wheel_count wheels";
-}
-
-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 immé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"
-
-
-// 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;
-  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 une balise 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"
-
-// On peut empêcher qu'une classe soit héritée
-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é par les bonnes pratiques, visitez
-[PHP The Right Way](http://www.phptherightway.com/) (anglais seulement).
-
-Si vous êtes habitué à utiliser de bons gestionaires de dépendances, regardez
-[Composer](http://getcomposer.org/).
-
-Pour consulter les standards, visitez "the PHP Framework Interoperability Groups"
-[PSR standards](https://github.com/php-fig/fig-standards).
diff --git a/fr-fr/scala-fr.html.markdown b/fr-fr/scala-fr.html.markdown
new file mode 100644
index 00000000..c6a61745
--- /dev/null
+++ b/fr-fr/scala-fr.html.markdown
@@ -0,0 +1,460 @@
+---
+language: Scala
+contributors:
+    - ["George Petrov", "http://github.com/petrovg"]
+    - ["Dominic Bou-Samra", "http://dbousamra.github.com"]
+translators:
+    - ["Anne-Catherine Dehier", "https://github.com/spellart"]
+filename: learnscala-fr.scala
+lang: fr-fr
+---
+
+### Scala - le langage évolutif
+
+```scala
+
+/*
+  Pour vous préparer :
+
+  1) (Téléchargez Scala)[http://www.scala-lang.org/downloads]
+  2) Dézippez/décompressez dans votre endroit préféré
+  et ajoutez le chemin du sous-répertoire bin au chemin du système
+  3) Commencez un REPL de Scala en tapant juste scala. Vous devriez voir le prompteur :
+
+  scala>
+
+  C'est ce qu'on appelle un REPL (Read-Eval-Print-Loop), c'est une interface de programmation interactive.
+  Vous pouvez y exécuter des commandes.
+  Allons-y :
+*/
+
+println(10) // affiche l'integer 10
+
+println("Boo!") // affiche avec retour à la ligne la chaîne de caractère Boo!
+
+
+// Quelques basiques
+
+// Imprimer et forcer une nouvelle ligne à la prochaine impression
+println("Hello world!")
+// Imprimer sans forcer une nouvelle ligne à la prochaine impression
+print("Hello world")
+
+// Pour déclarer des valeurs on utilise var ou val
+// Les déclarations val sont immuables, tandis que les var sont muables.
+// L'immuabilité est une bonne chose.
+
+val x = 10 // x vaut maintenant 10
+x = 20 // erreur : réaffectation à val
+var x = 10
+x = 20 // x vaut maintenant 20
+
+// Les commentaires d'une ligne commencent par deux slashs
+
+/*
+Les commentaires multilignes ressemblent à ça.
+*/
+
+// les valeurs booléennes
+true
+false
+
+// Les opérateurs booléens
+!true // false
+!false // true
+true == false // false
+10 > 5 // true
+
+// Les opérateurs mathématiques sont habituels
+1 + 1 // 2
+2 - 1 // 1
+5 * 3 // 15
+6 / 2 // 3
+
+
+// Le REPL donne le type et la valeur du résultat quand vous évaluez une commande
+
+1 + 7
+
+/* Les lignes ci-dessous donnent les résultats :
+
+  scala> 1 + 7
+  res29: Int = 8
+
+  Ça signifie que le résultat de l'évaluation 1 + 7 est un objet de
+  type Int avec une valeur de 8
+
+  1+7 donnera le même résultat
+*/
+
+
+// Tout est un objet, même une fonction. Tapez ceci dans le REPL :
+
+7 // donne res30: Int = 7 (res30 est seulement un nom de variable généré pour le résultat)
+
+
+// La ligne suivante est une fonction qui prend un Int et retourne son carré
+(x:Int) => x * x
+
+
+// On peut assigner cette fonction à un identifieur comme ceci :
+val sq = (x:Int) => x * x
+
+/* La ligne suivante nous dit :
+
+   sq: Int => Int = <function1>
+
+   Ce qui signifie que cette fois-ci nous avons donné un nom explicite à la valeur.
+   sq est une fonction qui prend un Int et retourne un Int.
+
+
+   sq peut être exécutée comme ci-dessous :
+*/
+
+sq(10) // donne comme résultat : res33: Int = 100.
+
+
+// les deux-points définissent explicitement le type de la valeur,
+// dans ce cas une fonction qui prend un Int et retourne un Int.
+val add10: Int => Int = _ + 10
+
+// Scala autorise des méthodes et des fonctions à retourner
+// ou prendre comme paramètres des autres fonctions ou méthodes
+
+
+List(1, 2, 3) map add10 // List(11, 12, 13) - add10 est appliqué à chaque éléments
+
+
+// Les fonctions anonymes peuvent être utilisées à la place des fonctions nommées :
+List(1, 2, 3) map (x => x + 10)
+
+
+
+
+// Le tiret du bas peut être utilisé si la fonction anonyme ne prend qu'un paramètre.
+// Il se comporte comme une variable
+List(1, 2, 3) map (_ + 10)
+
+
+
+// Si le bloc et la fonction anonyme prennent tous les deux un seul argument,
+// vous pouvez omettre le tiret du bas
+List("Dom", "Bob", "Natalia") foreach println
+
+
+
+// Les structures de données
+
+val a = Array(1, 2, 3, 5, 8, 13)
+a(0)
+a(3)
+a(21)    // Lance une exception
+
+val m = Map("fork" -> "tenedor", "spoon" -> "cuchara", "knife" -> "cuchillo")
+m("fork")
+m("spoon")
+m("bottle")       // Lance une exception
+
+val safeM = m.withDefaultValue("no lo se")
+safeM("bottle")
+
+val s = Set(1, 3, 7)
+s(0)
+s(1)
+
+/* Jetez un oeil sur la documentation de map ici -
+ * http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.Map
+ */
+
+
+// Tuples
+
+(1, 2)
+
+(4, 3, 2)
+
+(1, 2, "three")
+
+(a, 2, "three")
+
+// Exemple d'utilisation
+val divideInts = (x:Int, y:Int) => (x / y, x % y)
+
+
+divideInts(10,3) // La fonction divideInts donne le résultat et le reste de la division
+
+// Pour accéder à un élément d'un tuple, utilisez _._n
+// où n est l'index de base 1 de l'élément
+val d = divideInts(10,3)
+
+d._1
+
+d._2
+
+
+
+// Des combinaisons
+
+s.map(sq)
+
+val sSquared = s. map(sq)
+
+sSquared.filter(_ < 10)
+
+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)
+).filter(_.age > 25) // List(Person("Bob", 30))
+
+
+
+// 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
+
+
+
+
+// Compréhensions de listes
+
+for { n <- s } yield sq(n)
+
+val nSquared2 = for { n <- s } yield sq(n)
+
+for { n <- nSquared2 if n < 10 } yield n
+
+for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared
+
+
+
+/* Les exemples précédents ne sont pas des boucles for. La sémantique des boucles for
+   est "répète", alors qu'une for-compréhension définit une relation
+   entre deux ensembles de données. */
+
+
+
+// Boucles et itération
+
+1 to 5
+val r = 1 to 5
+r.foreach( println )
+
+r foreach println
+// NB: Scala est vraiment tolérant par rapport aux points et aux parenthèses en étudiant les roles séparément.
+// Ça aide pour écrire des DSL ou des API qui se lisent comme en anglais.
+
+
+(5 to 1 by -1) foreach ( println )
+
+// Une boucle while
+var i = 0
+while (i < 10) {  println("i " + i); i+=1  }
+
+while (i < 10) {  println("i " + i); i+=1  }  // Oui, encore. Qu'est-ce qui s'est passé ? Pourquoi ?
+
+
+
+
+
+
+i    // Montre la valeur de i. Notez que while est une boucle au sens classique.
+     // Il exécute séquentiellement pendant que la variable de boucle change.
+     // While est très rapide,
+     // 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 than 10");
+  i += 1
+} while (i < 10)
+
+
+// La récursivité est un moyen idiomatique de faire une chose répétitive en Scala.
+// Les fonctions récursives ont besoin d'un type de retour explicite,
+// le compilateur ne peut pas le déduire.
+// Ici c'est Unit.
+def showNumbersInRange(a:Int, b:Int):Unit = {
+  print(a)
+  if (a < b)
+    showNumbersInRange(a + 1, b)
+}
+
+
+
+// Structures de contrôle
+
+val x = 10
+
+if (x == 1) println("yeah")
+if (x == 10) println("yeah")
+if (x == 11) println("yeah")
+if (x == 11) println ("yeah") else println("nay")
+
+println(if (x == 10) "yeah" else "nope")
+val text = if (x == 10) "yeah" else "nope"
+
+var i = 0
+while (i < 10) { println("i " + i); i+=1  }
+
+
+
+// Les caractéristiques "Orienté Objet"
+
+// Création d'une classe Dog
+class Dog {
+  // Une méthode appelée bark qui retourne une chaîne de caractère
+  def bark: String = {
+    // le corps de la méthode
+    "Woof, woof!"
+  }
+}
+
+
+// Les classes peuvent contenir presque n'importe quelle autre construction, incluant d'autres classes,
+// des fonctions, des méthodes, des objets, des classes case, des traits, etc ...
+
+
+
+// Les classes case
+
+case class Person(name:String, phoneNumber:String)
+
+Person("George", "1234") == Person("Kate", "1236")
+
+
+
+
+// Correspondances de motifs
+
+val me = Person("George", "1234")
+
+me match { case Person(name, number) => {
+            "We matched someone : " + name + ", phone : " + number }}
+
+me match { case Person(name, number) => "Match : " + name; case _ => "Hm..." }
+
+me match { case Person("George", number) => "Match"; case _ => "Hm..." }
+
+me match { case Person("Kate", number) => "Match"; case _ => "Hm..." }
+
+me match { case Person("Kate", _) => "Girl"; case Person("George", _) => "Boy" }
+
+val kate = Person("Kate", "1234")
+
+kate match { case Person("Kate", _) => "Girl"; case Person("George", _) => "Boy" }
+
+
+
+// Expressions régulières
+
+val email = "(.*)@(.*)".r  // On fait une Regex en invoquant r sur la chaîne de caractère
+
+val email(user, domain) = "henry@zkpr.com"
+
+"mrbean@pyahoo.com" match {
+  case email(name, domain) => "I know your name, " + name
+}
+
+
+
+// Les chaînes de caractères
+
+"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 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
+
+// Voir également : scala.collection.immutable.StringOps
+
+println("ABCDEF".length)
+println("ABCDEF".substring(2, 6))
+println("ABCDEF".replace("C", "3"))
+
+val n = 45
+println(s"We have $n apples")
+
+val a = Array(11, 9, 6)
+println(s"My second daughter is ${a(2-1)} years old")
+
+// Certains caractères ont besoin d'être "échappés",
+// ex un guillemet à l'intérieur d'une chaîne de caractères :
+val a = "They stood outside the \"Rose and Crown\""
+
+// Les triples guillemets permettent d'écrire des chaînes de caractères
+// sur plusieurs lignes et peuvent contenir des guillemets
+
+val html = """<form id="daform">
+                <p>Press belo', Joe</p>
+             |  <input type="submit">
+              </form>"""
+
+
+
+// Structure et organisation d'une application
+
+// Importer des chaînes de caratères
+import scala.collection.immutable.List
+
+// Importer tous les sous-paquets
+import scala.collection.immutable._
+
+// Importer plusieurs classes en une seule instruction
+import scala.collection.immutable.{List, Map}
+
+// Renommer un import en utilisant '=>'
+import scala.collection.immutable.{ List => ImmutableList }
+
+// Importer toutes les classes, à l'exception de certaines.
+// La ligne suivante exclut Map et Set :
+import scala.collection.immutable.{Map => _, Set => _, _}
+
+// Le point d'entrée du programme est défini dans un fichier scala
+// utilisant un objet, avec une simple méthode main :
+object Application {
+  def main(args: Array[String]): Unit = {
+    // Votre code ici.
+  }
+}
+
+// Les fichiers peuvent contenir plusieurs classes et plusieurs objets.
+// On les compile avec scalac
+
+
+
+
+// Entrée et Sortie
+
+// Pour lire un fichier ligne par ligne
+import scala.io.Source
+for(line <- Source.fromFile("myfile.txt").getLines())
+  println(line)
+
+// On utilise le PrintWriter de Java pour écrire un fichier
+
+
+```
+
+## Autres ressources
+
+[Scala for the impatient](http://horstmann.com/scala/)
+
+[Twitter Scala school](http://twitter.github.io/scala_school/)
+
+[The scala documentation](http://docs.scala-lang.org/)
+
+[Try Scala in your browser](http://scalatutorials.com/tour/)
+
+Rejoindre le [Scala user group](https://groups.google.com/forum/#!forum/scala-user)
diff --git a/fr-fr/scala.html.markdown b/fr-fr/scala.html.markdown
deleted file mode 100644
index c6a61745..00000000
--- a/fr-fr/scala.html.markdown
+++ /dev/null
@@ -1,460 +0,0 @@
----
-language: Scala
-contributors:
-    - ["George Petrov", "http://github.com/petrovg"]
-    - ["Dominic Bou-Samra", "http://dbousamra.github.com"]
-translators:
-    - ["Anne-Catherine Dehier", "https://github.com/spellart"]
-filename: learnscala-fr.scala
-lang: fr-fr
----
-
-### Scala - le langage évolutif
-
-```scala
-
-/*
-  Pour vous préparer :
-
-  1) (Téléchargez Scala)[http://www.scala-lang.org/downloads]
-  2) Dézippez/décompressez dans votre endroit préféré
-  et ajoutez le chemin du sous-répertoire bin au chemin du système
-  3) Commencez un REPL de Scala en tapant juste scala. Vous devriez voir le prompteur :
-
-  scala>
-
-  C'est ce qu'on appelle un REPL (Read-Eval-Print-Loop), c'est une interface de programmation interactive.
-  Vous pouvez y exécuter des commandes.
-  Allons-y :
-*/
-
-println(10) // affiche l'integer 10
-
-println("Boo!") // affiche avec retour à la ligne la chaîne de caractère Boo!
-
-
-// Quelques basiques
-
-// Imprimer et forcer une nouvelle ligne à la prochaine impression
-println("Hello world!")
-// Imprimer sans forcer une nouvelle ligne à la prochaine impression
-print("Hello world")
-
-// Pour déclarer des valeurs on utilise var ou val
-// Les déclarations val sont immuables, tandis que les var sont muables.
-// L'immuabilité est une bonne chose.
-
-val x = 10 // x vaut maintenant 10
-x = 20 // erreur : réaffectation à val
-var x = 10
-x = 20 // x vaut maintenant 20
-
-// Les commentaires d'une ligne commencent par deux slashs
-
-/*
-Les commentaires multilignes ressemblent à ça.
-*/
-
-// les valeurs booléennes
-true
-false
-
-// Les opérateurs booléens
-!true // false
-!false // true
-true == false // false
-10 > 5 // true
-
-// Les opérateurs mathématiques sont habituels
-1 + 1 // 2
-2 - 1 // 1
-5 * 3 // 15
-6 / 2 // 3
-
-
-// Le REPL donne le type et la valeur du résultat quand vous évaluez une commande
-
-1 + 7
-
-/* Les lignes ci-dessous donnent les résultats :
-
-  scala> 1 + 7
-  res29: Int = 8
-
-  Ça signifie que le résultat de l'évaluation 1 + 7 est un objet de
-  type Int avec une valeur de 8
-
-  1+7 donnera le même résultat
-*/
-
-
-// Tout est un objet, même une fonction. Tapez ceci dans le REPL :
-
-7 // donne res30: Int = 7 (res30 est seulement un nom de variable généré pour le résultat)
-
-
-// La ligne suivante est une fonction qui prend un Int et retourne son carré
-(x:Int) => x * x
-
-
-// On peut assigner cette fonction à un identifieur comme ceci :
-val sq = (x:Int) => x * x
-
-/* La ligne suivante nous dit :
-
-   sq: Int => Int = <function1>
-
-   Ce qui signifie que cette fois-ci nous avons donné un nom explicite à la valeur.
-   sq est une fonction qui prend un Int et retourne un Int.
-
-
-   sq peut être exécutée comme ci-dessous :
-*/
-
-sq(10) // donne comme résultat : res33: Int = 100.
-
-
-// les deux-points définissent explicitement le type de la valeur,
-// dans ce cas une fonction qui prend un Int et retourne un Int.
-val add10: Int => Int = _ + 10
-
-// Scala autorise des méthodes et des fonctions à retourner
-// ou prendre comme paramètres des autres fonctions ou méthodes
-
-
-List(1, 2, 3) map add10 // List(11, 12, 13) - add10 est appliqué à chaque éléments
-
-
-// Les fonctions anonymes peuvent être utilisées à la place des fonctions nommées :
-List(1, 2, 3) map (x => x + 10)
-
-
-
-
-// Le tiret du bas peut être utilisé si la fonction anonyme ne prend qu'un paramètre.
-// Il se comporte comme une variable
-List(1, 2, 3) map (_ + 10)
-
-
-
-// Si le bloc et la fonction anonyme prennent tous les deux un seul argument,
-// vous pouvez omettre le tiret du bas
-List("Dom", "Bob", "Natalia") foreach println
-
-
-
-// Les structures de données
-
-val a = Array(1, 2, 3, 5, 8, 13)
-a(0)
-a(3)
-a(21)    // Lance une exception
-
-val m = Map("fork" -> "tenedor", "spoon" -> "cuchara", "knife" -> "cuchillo")
-m("fork")
-m("spoon")
-m("bottle")       // Lance une exception
-
-val safeM = m.withDefaultValue("no lo se")
-safeM("bottle")
-
-val s = Set(1, 3, 7)
-s(0)
-s(1)
-
-/* Jetez un oeil sur la documentation de map ici -
- * http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.Map
- */
-
-
-// Tuples
-
-(1, 2)
-
-(4, 3, 2)
-
-(1, 2, "three")
-
-(a, 2, "three")
-
-// Exemple d'utilisation
-val divideInts = (x:Int, y:Int) => (x / y, x % y)
-
-
-divideInts(10,3) // La fonction divideInts donne le résultat et le reste de la division
-
-// Pour accéder à un élément d'un tuple, utilisez _._n
-// où n est l'index de base 1 de l'élément
-val d = divideInts(10,3)
-
-d._1
-
-d._2
-
-
-
-// Des combinaisons
-
-s.map(sq)
-
-val sSquared = s. map(sq)
-
-sSquared.filter(_ < 10)
-
-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)
-).filter(_.age > 25) // List(Person("Bob", 30))
-
-
-
-// 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
-
-
-
-
-// Compréhensions de listes
-
-for { n <- s } yield sq(n)
-
-val nSquared2 = for { n <- s } yield sq(n)
-
-for { n <- nSquared2 if n < 10 } yield n
-
-for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared
-
-
-
-/* Les exemples précédents ne sont pas des boucles for. La sémantique des boucles for
-   est "répète", alors qu'une for-compréhension définit une relation
-   entre deux ensembles de données. */
-
-
-
-// Boucles et itération
-
-1 to 5
-val r = 1 to 5
-r.foreach( println )
-
-r foreach println
-// NB: Scala est vraiment tolérant par rapport aux points et aux parenthèses en étudiant les roles séparément.
-// Ça aide pour écrire des DSL ou des API qui se lisent comme en anglais.
-
-
-(5 to 1 by -1) foreach ( println )
-
-// Une boucle while
-var i = 0
-while (i < 10) {  println("i " + i); i+=1  }
-
-while (i < 10) {  println("i " + i); i+=1  }  // Oui, encore. Qu'est-ce qui s'est passé ? Pourquoi ?
-
-
-
-
-
-
-i    // Montre la valeur de i. Notez que while est une boucle au sens classique.
-     // Il exécute séquentiellement pendant que la variable de boucle change.
-     // While est très rapide,
-     // 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 than 10");
-  i += 1
-} while (i < 10)
-
-
-// La récursivité est un moyen idiomatique de faire une chose répétitive en Scala.
-// Les fonctions récursives ont besoin d'un type de retour explicite,
-// le compilateur ne peut pas le déduire.
-// Ici c'est Unit.
-def showNumbersInRange(a:Int, b:Int):Unit = {
-  print(a)
-  if (a < b)
-    showNumbersInRange(a + 1, b)
-}
-
-
-
-// Structures de contrôle
-
-val x = 10
-
-if (x == 1) println("yeah")
-if (x == 10) println("yeah")
-if (x == 11) println("yeah")
-if (x == 11) println ("yeah") else println("nay")
-
-println(if (x == 10) "yeah" else "nope")
-val text = if (x == 10) "yeah" else "nope"
-
-var i = 0
-while (i < 10) { println("i " + i); i+=1  }
-
-
-
-// Les caractéristiques "Orienté Objet"
-
-// Création d'une classe Dog
-class Dog {
-  // Une méthode appelée bark qui retourne une chaîne de caractère
-  def bark: String = {
-    // le corps de la méthode
-    "Woof, woof!"
-  }
-}
-
-
-// Les classes peuvent contenir presque n'importe quelle autre construction, incluant d'autres classes,
-// des fonctions, des méthodes, des objets, des classes case, des traits, etc ...
-
-
-
-// Les classes case
-
-case class Person(name:String, phoneNumber:String)
-
-Person("George", "1234") == Person("Kate", "1236")
-
-
-
-
-// Correspondances de motifs
-
-val me = Person("George", "1234")
-
-me match { case Person(name, number) => {
-            "We matched someone : " + name + ", phone : " + number }}
-
-me match { case Person(name, number) => "Match : " + name; case _ => "Hm..." }
-
-me match { case Person("George", number) => "Match"; case _ => "Hm..." }
-
-me match { case Person("Kate", number) => "Match"; case _ => "Hm..." }
-
-me match { case Person("Kate", _) => "Girl"; case Person("George", _) => "Boy" }
-
-val kate = Person("Kate", "1234")
-
-kate match { case Person("Kate", _) => "Girl"; case Person("George", _) => "Boy" }
-
-
-
-// Expressions régulières
-
-val email = "(.*)@(.*)".r  // On fait une Regex en invoquant r sur la chaîne de caractère
-
-val email(user, domain) = "henry@zkpr.com"
-
-"mrbean@pyahoo.com" match {
-  case email(name, domain) => "I know your name, " + name
-}
-
-
-
-// Les chaînes de caractères
-
-"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 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
-
-// Voir également : scala.collection.immutable.StringOps
-
-println("ABCDEF".length)
-println("ABCDEF".substring(2, 6))
-println("ABCDEF".replace("C", "3"))
-
-val n = 45
-println(s"We have $n apples")
-
-val a = Array(11, 9, 6)
-println(s"My second daughter is ${a(2-1)} years old")
-
-// Certains caractères ont besoin d'être "échappés",
-// ex un guillemet à l'intérieur d'une chaîne de caractères :
-val a = "They stood outside the \"Rose and Crown\""
-
-// Les triples guillemets permettent d'écrire des chaînes de caractères
-// sur plusieurs lignes et peuvent contenir des guillemets
-
-val html = """<form id="daform">
-                <p>Press belo', Joe</p>
-             |  <input type="submit">
-              </form>"""
-
-
-
-// Structure et organisation d'une application
-
-// Importer des chaînes de caratères
-import scala.collection.immutable.List
-
-// Importer tous les sous-paquets
-import scala.collection.immutable._
-
-// Importer plusieurs classes en une seule instruction
-import scala.collection.immutable.{List, Map}
-
-// Renommer un import en utilisant '=>'
-import scala.collection.immutable.{ List => ImmutableList }
-
-// Importer toutes les classes, à l'exception de certaines.
-// La ligne suivante exclut Map et Set :
-import scala.collection.immutable.{Map => _, Set => _, _}
-
-// Le point d'entrée du programme est défini dans un fichier scala
-// utilisant un objet, avec une simple méthode main :
-object Application {
-  def main(args: Array[String]): Unit = {
-    // Votre code ici.
-  }
-}
-
-// Les fichiers peuvent contenir plusieurs classes et plusieurs objets.
-// On les compile avec scalac
-
-
-
-
-// Entrée et Sortie
-
-// Pour lire un fichier ligne par ligne
-import scala.io.Source
-for(line <- Source.fromFile("myfile.txt").getLines())
-  println(line)
-
-// On utilise le PrintWriter de Java pour écrire un fichier
-
-
-```
-
-## Autres ressources
-
-[Scala for the impatient](http://horstmann.com/scala/)
-
-[Twitter Scala school](http://twitter.github.io/scala_school/)
-
-[The scala documentation](http://docs.scala-lang.org/)
-
-[Try Scala in your browser](http://scalatutorials.com/tour/)
-
-Rejoindre le [Scala user group](https://groups.google.com/forum/#!forum/scala-user)
diff --git a/fr-fr/vim-fr.html.markdown b/fr-fr/vim-fr.html.markdown
new file mode 100644
index 00000000..b2f1d24d
--- /dev/null
+++ b/fr-fr/vim-fr.html.markdown
@@ -0,0 +1,239 @@
+---
+category: tool
+tool: vim
+filename: LearnVim-fr.txt
+contributors:
+    - ["RadhikaG", "https://github.com/RadhikaG"]
+translators:
+    - ["Thibault", "https://github.com/napnac"]
+lang: fr-fr
+---
+
+
+[Vim](http://www.vim.org)
+(Vi IMproved) est le clone le plus populaire de l'éditeur de texte vi sous Unix.
+Vim est un éditeur de texte omniprésent sur les systèmes de type Unix, et a pour
+objectif la rapidité ainsi que l'augmentation de la productivité. Il a de 
+nombreux raccourcis claviers pour une navigation et une édition plus rapide.
+
+## Navigation basique avec Vim
+
+```
+    vim <ficher>     # Ouvre <fichier> avec vim
+    :q               # Quitte vim
+    :w               # Sauvegarde le fichier actuel
+    :wq              # Sauvegarde le fichier actuel et quitte vim
+    :q!              # Quitte vim sans sauvegarder
+                     # ! *force* l'exécution de :q, ce qui par conséquent 
+                     # oblige vim à quitter sans sauvegarder
+    :x               # Sauvegarde le fichier et quitte vim (raccourcis de :wq)
+
+    u                # Annuler
+    CTRL+R           # Rétablir
+
+    h                # Déplace le curseur vers la gauche
+    j                # Déplace le curseur vers le bas
+    k                # Déplace le curseur vers le haut
+    l                # Déplace le curseur vers la droite
+
+    # Mouvements au sein d'une ligne
+
+    0                # Va au début de la ligne
+    $                # Va à la fin de la ligne
+    ^                # Va au premier caractère non blanc de la ligne
+
+    # Rechercher dans un texte
+
+    /mot             # Surligne toutes les occurrences du mot après le curseur
+    ?mot             # Surligne toutes les occurrences du mot avant le curseur
+    n                # Déplace le curseur sur la prochaine occurrence du mot recherché
+    N                # Déplace le curseur sur la précédente occurrence du mot recherché
+
+    :%s/abc/def/g    # Transforme les 'abc' en 'def' sur chaque ligne du texte
+    :s/abc/def/g     # Transforme les 'abc' en 'def' sur la ligne actuelle
+
+    # Se déplacer vers un caractère
+
+    f<caractère>     # Se déplace en avant jusqu'à <caractère>
+    t<caractère>     # Se déplace en avant juste avant <caractère>
+
+    # Par exemple
+    f<               # Se déplace en avant jusqu'à <
+    t<               # Se déplace en avant juste avant <
+    
+    # Se déplacer dans un mot
+
+    w                # Avance d'un mot
+    b                # Recule d'un mot
+    e                # Se déplace jusqu'à la fin du mot actuel
+
+    # D'autres raccourcis pour se déplacer
+
+    gg               # Va au début du fichier
+    G                # Va à la fin du fichier
+    :NB              # Va à la ligne numéro NB (où NB est un nombre)
+    H                # Se déplace jusqu'en haut de l'écran
+    M                # Se déplace jusqu'au milieu de l'écran
+    L                # Se déplace jusqu'en bas de l'écran
+```
+
+## Modes
+
+Vim est basé sur le concept de **modes**.
+
+Mode Commande  - pour se déplacer et exécuter des commandes (vim démarre dans ce mode)
+Mode Insertion - pour éditer le fichier
+Mode Visuel    - pour sélectionner du texte et réaliser des opérations dessus
+Mode Ex        - pour entrer des commandes avec ':'
+
+```
+    i                # Mode insertion, avant le curseur
+    a                # Mode insertion, après le curseur
+    v                # Mode visuel
+    :                # Mode ex
+    <esc>            # 'Echap' permet de revenir dans le mode commande
+
+    # Copier/Coller du texte
+
+    y                # Copie le texte sélectionné
+    yy               # Copie la ligne actuelle
+    d                # Supprime ce qui est sélectionné
+    dd               # Supprime la ligne actuelle
+    p                # Colle après le curseur
+    P                # Colle avant le curseur
+    x                # Supprime le caractère sous le curseur
+```
+
+## La "Grammaire" de Vim
+
+Vim peut être vu comme un ensemble de commande sous la forme
+'Verbe-Modificateur-Nom' :
+
+Verbe        - notre action
+Modificateur - la manière de faire l'action
+Nom          - l'objet désigné par l'action
+
+Quelques exemples importants de 'Verbes', 'Modificateurs', et de 'Noms' :
+
+```
+    # 'Verbes'
+ 
+    d                # Supprime
+    c                # Transforme
+    y                # Copie
+    v                # Sélectionne
+
+    # 'Modificateurs'
+
+    i                # A l'intérieur
+    a                # Autour
+    NB               # Nombre
+    f                # Cherche quelque chose et se déplace dessus
+    t                # Cherche quelque chose et se déplace juste avant
+    /                # Cherche une chaîne de caractères après le curseur
+    ?                # Cherche une chaîne de caractères avant le curseur
+
+    # 'Noms'
+
+    w                # Mot
+    s                # Phrase
+    p                # Paragraphe
+    b                # Bloc
+    
+    # Exemple de 'phrases' ou commandes
+
+    d2w              # Supprime 2 mots
+    cis              # Transforme l'intérieur de la phrase
+    yip              # Copie l'intérieur du paragraphe
+    ct<              # Transforme le texte du curseur jusqu'au caractère avant le <
+    d$               # Supprime jusqu'à la fin de la ligne
+```
+
+## Quelques raccourcis et astuces
+
+```
+    >                # Indente la sélection d'un bloc
+    <                # Dé-indente la sélection d'un bloc
+    :earlier 15m     # Retrouve le document comme il était il y a 15 minutes
+    :later 15m       # Inverse la commande précédente
+    ddp              # Echange la position de deux lignes consécutives (dd puis p)
+    .                # Répète la dernière action effectuée
+```
+
+## Macros
+
+Les macros sont des actions enregistrables.
+Quand on commence à enregistrer une macro, Vim enregistre **toutes** les actions
+et les commandes que vous utilisez, jusqu'à ce que vous arrêtiez d'enregistrer.
+Lorsque vous appelez une macro, elle applique exactement les mêmes actions et 
+commandes sur le texte sélectionné.
+
+```
+    qa               # Commence l'enregistrement de la macro 'a'
+    q                # Arrête l'enregistrement
+    @a               # Appelle la macro 'a'
+```
+
+### Configuration de ~/.vimrc
+
+Le fichier .vimrc est utilisé pour configurer Vim lors du démarrage.
+
+Voici un exemple de fichier ~/.vimrc :
+
+```
+" Exemple de ~/.vimrc
+" 2015.10 
+
+" Nécessaire à Vim pour être 'iMproved'
+set nocompatible
+
+" Détermine l'extension du fichier à partir du nom pour permettre une indentation
+" automatique intelligente, etc.
+filetype indent plugin on
+
+" Active la coloration syntaxique
+syntax on
+
+" Une meilleure complétion de la ligne de commande
+set wildmenu
+
+" Utilise une recherche insensible à la case sauf quand on utilise des majuscules
+set ignorecase
+set smartcase
+
+" Quand on commence une nouvelle ligne et qu'aucun type d'indentation n'est activé
+" on utilise la même indentation que sur la ligne précédente
+set autoindent
+
+" Affiche le numéro de la ligne sur la gauche de l'écran
+set number
+
+" Options d'indentation, à changer en fonction des préférences personnelles
+
+" Nombre d'espaces visuels par tabulation
+set tabstop=4
+
+" Nombre d'espaces par tabulation
+set softtabstop=4
+
+" Nombre d'espaces indentés avec les opérations d'indentations (>> et <<)
+set shiftwidth=4
+
+" Convertis les tabulations en espaces
+set expandtab
+
+" Active des tabulations et des espaces intelligents pour l'indentation et l'alignement
+set smarttab
+```
+
+### Références
+
+[Vim | Home](http://www.vim.org/index.php)
+
+`$ vimtutor`
+
+[A vim Tutorial and Primer](https://danielmiessler.com/study/vim/)
+
+[What are the dark corners of Vim your mom never told you about? (Stack Overflow thread)](http://stackoverflow.com/questions/726894/what-are-the-dark-corners-of-vim-your-mom-never-told-you-about)
+
+[Arch Linux Wiki](https://wiki.archlinux.org/index.php/Vim)
diff --git a/fr-fr/vim.html.markdown b/fr-fr/vim.html.markdown
deleted file mode 100644
index b2f1d24d..00000000
--- a/fr-fr/vim.html.markdown
+++ /dev/null
@@ -1,239 +0,0 @@
----
-category: tool
-tool: vim
-filename: LearnVim-fr.txt
-contributors:
-    - ["RadhikaG", "https://github.com/RadhikaG"]
-translators:
-    - ["Thibault", "https://github.com/napnac"]
-lang: fr-fr
----
-
-
-[Vim](http://www.vim.org)
-(Vi IMproved) est le clone le plus populaire de l'éditeur de texte vi sous Unix.
-Vim est un éditeur de texte omniprésent sur les systèmes de type Unix, et a pour
-objectif la rapidité ainsi que l'augmentation de la productivité. Il a de 
-nombreux raccourcis claviers pour une navigation et une édition plus rapide.
-
-## Navigation basique avec Vim
-
-```
-    vim <ficher>     # Ouvre <fichier> avec vim
-    :q               # Quitte vim
-    :w               # Sauvegarde le fichier actuel
-    :wq              # Sauvegarde le fichier actuel et quitte vim
-    :q!              # Quitte vim sans sauvegarder
-                     # ! *force* l'exécution de :q, ce qui par conséquent 
-                     # oblige vim à quitter sans sauvegarder
-    :x               # Sauvegarde le fichier et quitte vim (raccourcis de :wq)
-
-    u                # Annuler
-    CTRL+R           # Rétablir
-
-    h                # Déplace le curseur vers la gauche
-    j                # Déplace le curseur vers le bas
-    k                # Déplace le curseur vers le haut
-    l                # Déplace le curseur vers la droite
-
-    # Mouvements au sein d'une ligne
-
-    0                # Va au début de la ligne
-    $                # Va à la fin de la ligne
-    ^                # Va au premier caractère non blanc de la ligne
-
-    # Rechercher dans un texte
-
-    /mot             # Surligne toutes les occurrences du mot après le curseur
-    ?mot             # Surligne toutes les occurrences du mot avant le curseur
-    n                # Déplace le curseur sur la prochaine occurrence du mot recherché
-    N                # Déplace le curseur sur la précédente occurrence du mot recherché
-
-    :%s/abc/def/g    # Transforme les 'abc' en 'def' sur chaque ligne du texte
-    :s/abc/def/g     # Transforme les 'abc' en 'def' sur la ligne actuelle
-
-    # Se déplacer vers un caractère
-
-    f<caractère>     # Se déplace en avant jusqu'à <caractère>
-    t<caractère>     # Se déplace en avant juste avant <caractère>
-
-    # Par exemple
-    f<               # Se déplace en avant jusqu'à <
-    t<               # Se déplace en avant juste avant <
-    
-    # Se déplacer dans un mot
-
-    w                # Avance d'un mot
-    b                # Recule d'un mot
-    e                # Se déplace jusqu'à la fin du mot actuel
-
-    # D'autres raccourcis pour se déplacer
-
-    gg               # Va au début du fichier
-    G                # Va à la fin du fichier
-    :NB              # Va à la ligne numéro NB (où NB est un nombre)
-    H                # Se déplace jusqu'en haut de l'écran
-    M                # Se déplace jusqu'au milieu de l'écran
-    L                # Se déplace jusqu'en bas de l'écran
-```
-
-## Modes
-
-Vim est basé sur le concept de **modes**.
-
-Mode Commande  - pour se déplacer et exécuter des commandes (vim démarre dans ce mode)
-Mode Insertion - pour éditer le fichier
-Mode Visuel    - pour sélectionner du texte et réaliser des opérations dessus
-Mode Ex        - pour entrer des commandes avec ':'
-
-```
-    i                # Mode insertion, avant le curseur
-    a                # Mode insertion, après le curseur
-    v                # Mode visuel
-    :                # Mode ex
-    <esc>            # 'Echap' permet de revenir dans le mode commande
-
-    # Copier/Coller du texte
-
-    y                # Copie le texte sélectionné
-    yy               # Copie la ligne actuelle
-    d                # Supprime ce qui est sélectionné
-    dd               # Supprime la ligne actuelle
-    p                # Colle après le curseur
-    P                # Colle avant le curseur
-    x                # Supprime le caractère sous le curseur
-```
-
-## La "Grammaire" de Vim
-
-Vim peut être vu comme un ensemble de commande sous la forme
-'Verbe-Modificateur-Nom' :
-
-Verbe        - notre action
-Modificateur - la manière de faire l'action
-Nom          - l'objet désigné par l'action
-
-Quelques exemples importants de 'Verbes', 'Modificateurs', et de 'Noms' :
-
-```
-    # 'Verbes'
- 
-    d                # Supprime
-    c                # Transforme
-    y                # Copie
-    v                # Sélectionne
-
-    # 'Modificateurs'
-
-    i                # A l'intérieur
-    a                # Autour
-    NB               # Nombre
-    f                # Cherche quelque chose et se déplace dessus
-    t                # Cherche quelque chose et se déplace juste avant
-    /                # Cherche une chaîne de caractères après le curseur
-    ?                # Cherche une chaîne de caractères avant le curseur
-
-    # 'Noms'
-
-    w                # Mot
-    s                # Phrase
-    p                # Paragraphe
-    b                # Bloc
-    
-    # Exemple de 'phrases' ou commandes
-
-    d2w              # Supprime 2 mots
-    cis              # Transforme l'intérieur de la phrase
-    yip              # Copie l'intérieur du paragraphe
-    ct<              # Transforme le texte du curseur jusqu'au caractère avant le <
-    d$               # Supprime jusqu'à la fin de la ligne
-```
-
-## Quelques raccourcis et astuces
-
-```
-    >                # Indente la sélection d'un bloc
-    <                # Dé-indente la sélection d'un bloc
-    :earlier 15m     # Retrouve le document comme il était il y a 15 minutes
-    :later 15m       # Inverse la commande précédente
-    ddp              # Echange la position de deux lignes consécutives (dd puis p)
-    .                # Répète la dernière action effectuée
-```
-
-## Macros
-
-Les macros sont des actions enregistrables.
-Quand on commence à enregistrer une macro, Vim enregistre **toutes** les actions
-et les commandes que vous utilisez, jusqu'à ce que vous arrêtiez d'enregistrer.
-Lorsque vous appelez une macro, elle applique exactement les mêmes actions et 
-commandes sur le texte sélectionné.
-
-```
-    qa               # Commence l'enregistrement de la macro 'a'
-    q                # Arrête l'enregistrement
-    @a               # Appelle la macro 'a'
-```
-
-### Configuration de ~/.vimrc
-
-Le fichier .vimrc est utilisé pour configurer Vim lors du démarrage.
-
-Voici un exemple de fichier ~/.vimrc :
-
-```
-" Exemple de ~/.vimrc
-" 2015.10 
-
-" Nécessaire à Vim pour être 'iMproved'
-set nocompatible
-
-" Détermine l'extension du fichier à partir du nom pour permettre une indentation
-" automatique intelligente, etc.
-filetype indent plugin on
-
-" Active la coloration syntaxique
-syntax on
-
-" Une meilleure complétion de la ligne de commande
-set wildmenu
-
-" Utilise une recherche insensible à la case sauf quand on utilise des majuscules
-set ignorecase
-set smartcase
-
-" Quand on commence une nouvelle ligne et qu'aucun type d'indentation n'est activé
-" on utilise la même indentation que sur la ligne précédente
-set autoindent
-
-" Affiche le numéro de la ligne sur la gauche de l'écran
-set number
-
-" Options d'indentation, à changer en fonction des préférences personnelles
-
-" Nombre d'espaces visuels par tabulation
-set tabstop=4
-
-" Nombre d'espaces par tabulation
-set softtabstop=4
-
-" Nombre d'espaces indentés avec les opérations d'indentations (>> et <<)
-set shiftwidth=4
-
-" Convertis les tabulations en espaces
-set expandtab
-
-" Active des tabulations et des espaces intelligents pour l'indentation et l'alignement
-set smarttab
-```
-
-### Références
-
-[Vim | Home](http://www.vim.org/index.php)
-
-`$ vimtutor`
-
-[A vim Tutorial and Primer](https://danielmiessler.com/study/vim/)
-
-[What are the dark corners of Vim your mom never told you about? (Stack Overflow thread)](http://stackoverflow.com/questions/726894/what-are-the-dark-corners-of-vim-your-mom-never-told-you-about)
-
-[Arch Linux Wiki](https://wiki.archlinux.org/index.php/Vim)
-- 
cgit v1.2.3


From 20893f5d83b4f7a1585bac9e7656d6af46183262 Mon Sep 17 00:00:00 2001
From: Julien M'Poy <julien.mpoy@gmail.com>
Date: Wed, 8 Nov 2017 13:27:20 +0100
Subject: Change file name as requested by @prertik

---
 fr-fr/php-fr.html.markdown | 741 +++++++++++++++++++++++++++++++++++++++++++++
 fr-fr/php.html.markdown    | 741 ---------------------------------------------
 2 files changed, 741 insertions(+), 741 deletions(-)
 create mode 100644 fr-fr/php-fr.html.markdown
 delete mode 100644 fr-fr/php.html.markdown

(limited to 'fr-fr')

diff --git a/fr-fr/php-fr.html.markdown b/fr-fr/php-fr.html.markdown
new file mode 100644
index 00000000..d001f1d4
--- /dev/null
+++ b/fr-fr/php-fr.html.markdown
@@ -0,0 +1,741 @@
+---
+language: PHP
+filename: php-fr.php
+contributors:
+    - ["Malcolm Fell", "http://emarref.net/"]
+    - ["Trismegiste", "https://github.com/Trismegiste"]
+translators:
+    - ["Pascal Boutin", "http://pboutin.net/"]
+    - ["Julien M'Poy", "https://github.com/groovytron"]
+lang: fr-fr
+---
+
+This document describes PHP 5+.
+
+Ce document décrit PHP 5+.
+
+```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 la balise '?>'
+
+// Deux barres obliques amorcent un commentaire simple.
+
+# 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-lignes.
+*/
+
+// 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
+
+// toutes 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 de soulignés.
+
+// Les valeurs booléennes 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 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 à
+// 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 = "Ceci est une $sgl_quotes."; // => 'Ceci est une $String.'
+
+// Les caractères spéciaux sont seulement échappés avec des guillemets
+$escaped   = "Ceci contient \t une tabulation.";
+$unescaped = 'Ceci contient juste un slash et un t: \t';
+
+// En cas de besoin, placez la variable dans des accolades
+$money = "J'ai $${number} sur mon compte en banque.";
+
+// Depuis PHP 5.3, Nowdoc peut être utilisé pour faire des chaînes
+// multi-lignes non-interprétées
+$nowdoc = <<<'END'
+String
+mutli-lignes
+END;
+
+// Heredoc peut être utilisé pour faire des chaînes multi-lignes interprétées
+$heredoc = <<<END
+$sgl_quotes
+multi-lignes
+END;
+
+// La concaténation de chaînes se fait avec un .
+echo 'Cette string ' . 'est concatenée'; // => 'Cette string est concaténée'
+
+
+/********************************
+ * 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 'Ceci affiche ' . FOO;
+
+
+/********************************
+ * Tableaux (array)
+ */
+
+// Tous les tableaux en PHP sont associatifs (hashmaps),
+
+// Fonctionne dans toutes 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 du tableau
+unset($array[3]);
+
+// Depuis PHP 7, il est possible de déclarer des tableaux constants en
+// utilisant 'define'.
+define('ANIMAUX', [
+    'chien',
+    'chat',
+    'oiseau',
+]);
+
+/********************************
+ * 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"
+
+// 'echo' et 'print' sont des language constructs.
+// Il n'ont pas besoin de parenthèses car ils sont traités comme
+// des opérateurs unaires.
+echo 'Hello World!';
+print 'Hello World!'; 
+
+$paragraph = 'paragraphe';
+
+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 convivial
+print_r($array); // prints: Array ( [0] => One [1] => Two [2] => Three )
+
+/********************************
+ * Logique
+ */
+$a = 0;
+$b = '0';
+$c = '1';
+$d = '1';
+
+// assert affiche un avertissement quand l'expression booléenne passée
+// en argument n'est pas vraie.
+
+// 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é
+assert($c <> $a); // inégalité (moins courant)
+assert($a < $c);
+assert($c > $b);
+assert($a <= $b);
+assert($c >= $d);
+
+// Ces comparaisons vont seulement être vraies 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épendamment 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 nulle
+
+
+/********************************
+ * 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>Ceci est affiché si $x est faux</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éclarer 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 "The $vehicle have $wheel_count wheels";
+}
+
+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 immé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 commence par une lettre ou un souligné,
+// suivi de n'importe quelle lettre, nombre ou de soulignés.
+// Les noms des arguments d'une fonction doivent respecter le même format que
+// celui des variables.
+
+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 une balise 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 'Je suis 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 'Je suis 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"
+
+// On peut empêcher qu'une classe soit héritée
+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é 'implements').
+
+// 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';
+    }
+}
+
+// Il est possible de déclarer des classes internes anonymes depuis PHP 7
+
+interface Logger {
+    public function log(string $msg);
+}
+
+class Application {
+    private $logger;
+
+    public function getLogger(): Logger {
+         return $this->logger;
+    }
+
+    public function setLogger(Logger $logger) {
+         $this->logger = $logger;
+    }
+}
+
+$app = new Application;
+
+$app->setLogger(new class implements Logger {
+    public function log(string $msg) {
+        echo $msg;
+    }
+});
+
+var_dump($app->getLogger()); // => 'object(class@anonymous)#2 (0) {}'
+
+
+/********************************
+ * 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é par les bonnes pratiques, visitez
+[PHP The Right Way](http://www.phptherightway.com/) (anglais seulement).
+
+Si vous êtes habitué à utiliser de bons gestionaires de dépendances, regardez
+[Composer](http://getcomposer.org/).
+
+Pour consulter les standards, visitez "the PHP Framework Interoperability Groups"
+[PSR standards](https://github.com/php-fig/fig-standards).
diff --git a/fr-fr/php.html.markdown b/fr-fr/php.html.markdown
deleted file mode 100644
index d001f1d4..00000000
--- a/fr-fr/php.html.markdown
+++ /dev/null
@@ -1,741 +0,0 @@
----
-language: PHP
-filename: php-fr.php
-contributors:
-    - ["Malcolm Fell", "http://emarref.net/"]
-    - ["Trismegiste", "https://github.com/Trismegiste"]
-translators:
-    - ["Pascal Boutin", "http://pboutin.net/"]
-    - ["Julien M'Poy", "https://github.com/groovytron"]
-lang: fr-fr
----
-
-This document describes PHP 5+.
-
-Ce document décrit PHP 5+.
-
-```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 la balise '?>'
-
-// Deux barres obliques amorcent un commentaire simple.
-
-# 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-lignes.
-*/
-
-// 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
-
-// toutes 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 de soulignés.
-
-// Les valeurs booléennes 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 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 à
-// 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 = "Ceci est une $sgl_quotes."; // => 'Ceci est une $String.'
-
-// Les caractères spéciaux sont seulement échappés avec des guillemets
-$escaped   = "Ceci contient \t une tabulation.";
-$unescaped = 'Ceci contient juste un slash et un t: \t';
-
-// En cas de besoin, placez la variable dans des accolades
-$money = "J'ai $${number} sur mon compte en banque.";
-
-// Depuis PHP 5.3, Nowdoc peut être utilisé pour faire des chaînes
-// multi-lignes non-interprétées
-$nowdoc = <<<'END'
-String
-mutli-lignes
-END;
-
-// Heredoc peut être utilisé pour faire des chaînes multi-lignes interprétées
-$heredoc = <<<END
-$sgl_quotes
-multi-lignes
-END;
-
-// La concaténation de chaînes se fait avec un .
-echo 'Cette string ' . 'est concatenée'; // => 'Cette string est concaténée'
-
-
-/********************************
- * 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 'Ceci affiche ' . FOO;
-
-
-/********************************
- * Tableaux (array)
- */
-
-// Tous les tableaux en PHP sont associatifs (hashmaps),
-
-// Fonctionne dans toutes 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 du tableau
-unset($array[3]);
-
-// Depuis PHP 7, il est possible de déclarer des tableaux constants en
-// utilisant 'define'.
-define('ANIMAUX', [
-    'chien',
-    'chat',
-    'oiseau',
-]);
-
-/********************************
- * 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"
-
-// 'echo' et 'print' sont des language constructs.
-// Il n'ont pas besoin de parenthèses car ils sont traités comme
-// des opérateurs unaires.
-echo 'Hello World!';
-print 'Hello World!'; 
-
-$paragraph = 'paragraphe';
-
-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 convivial
-print_r($array); // prints: Array ( [0] => One [1] => Two [2] => Three )
-
-/********************************
- * Logique
- */
-$a = 0;
-$b = '0';
-$c = '1';
-$d = '1';
-
-// assert affiche un avertissement quand l'expression booléenne passée
-// en argument n'est pas vraie.
-
-// 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é
-assert($c <> $a); // inégalité (moins courant)
-assert($a < $c);
-assert($c > $b);
-assert($a <= $b);
-assert($c >= $d);
-
-// Ces comparaisons vont seulement être vraies 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épendamment 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 nulle
-
-
-/********************************
- * 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>Ceci est affiché si $x est faux</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éclarer 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 "The $vehicle have $wheel_count wheels";
-}
-
-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 immé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 commence par une lettre ou un souligné,
-// suivi de n'importe quelle lettre, nombre ou de soulignés.
-// Les noms des arguments d'une fonction doivent respecter le même format que
-// celui des variables.
-
-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 une balise 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 'Je suis 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 'Je suis 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"
-
-// On peut empêcher qu'une classe soit héritée
-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é 'implements').
-
-// 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';
-    }
-}
-
-// Il est possible de déclarer des classes internes anonymes depuis PHP 7
-
-interface Logger {
-    public function log(string $msg);
-}
-
-class Application {
-    private $logger;
-
-    public function getLogger(): Logger {
-         return $this->logger;
-    }
-
-    public function setLogger(Logger $logger) {
-         $this->logger = $logger;
-    }
-}
-
-$app = new Application;
-
-$app->setLogger(new class implements Logger {
-    public function log(string $msg) {
-        echo $msg;
-    }
-});
-
-var_dump($app->getLogger()); // => 'object(class@anonymous)#2 (0) {}'
-
-
-/********************************
- * 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é par les bonnes pratiques, visitez
-[PHP The Right Way](http://www.phptherightway.com/) (anglais seulement).
-
-Si vous êtes habitué à utiliser de bons gestionaires de dépendances, regardez
-[Composer](http://getcomposer.org/).
-
-Pour consulter les standards, visitez "the PHP Framework Interoperability Groups"
-[PSR standards](https://github.com/php-fig/fig-standards).
-- 
cgit v1.2.3


From 83d3efe45f3bd676b42ea6c1d3e3ae7d23e8ad85 Mon Sep 17 00:00:00 2001
From: ven <vendethiel@hotmail.fr>
Date: Thu, 7 Dec 2017 12:16:08 +0100
Subject: follow-up on #2971

---
 fr-fr/php-fr.html.markdown | 2 --
 1 file changed, 2 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/php-fr.html.markdown b/fr-fr/php-fr.html.markdown
index d001f1d4..45a02d75 100644
--- a/fr-fr/php-fr.html.markdown
+++ b/fr-fr/php-fr.html.markdown
@@ -10,8 +10,6 @@ translators:
 lang: fr-fr
 ---
 
-This document describes PHP 5+.
-
 Ce document décrit PHP 5+.
 
 ```php
-- 
cgit v1.2.3


From c0868506513421f6d748ca8faa7d1beaaff0a3af Mon Sep 17 00:00:00 2001
From: louis <viallo_l@etna-alternance.net>
Date: Tue, 27 Feb 2018 16:27:32 +0100
Subject: [crystal/fr] Corrected mistake

---
 fr-fr/crystal-fr.html.markdown | 1 -
 1 file changed, 1 deletion(-)

(limited to 'fr-fr')

diff --git a/fr-fr/crystal-fr.html.markdown b/fr-fr/crystal-fr.html.markdown
index 2c4e3dad..2bb17fc5 100644
--- a/fr-fr/crystal-fr.html.markdown
+++ b/fr-fr/crystal-fr.html.markdown
@@ -305,7 +305,6 @@ end
 (1..3).each do |index|
   puts "Index: #{index}"
 end
-# Index: 0
 # Index: 1
 # Index: 2
 # Index: 3
-- 
cgit v1.2.3


From d57fe66c4308f257af4141d135e446e1a1c383b8 Mon Sep 17 00:00:00 2001
From: Pratik Karki <predatoramigo@gmail.com>
Date: Wed, 28 Feb 2018 16:08:29 +0545
Subject: Fix language name

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

(limited to 'fr-fr')

diff --git a/fr-fr/bf-fr.html.markdown b/fr-fr/bf-fr.html.markdown
index 0fae6032..d8c7c76a 100644
--- a/fr-fr/bf-fr.html.markdown
+++ b/fr-fr/bf-fr.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: bf
+language: Brainfuck
 filename: learnbrainfuck-fr.bf
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io/"]
-- 
cgit v1.2.3


From caa8993076365c3e650e82a3c5c970dca25ed4c4 Mon Sep 17 00:00:00 2001
From: Adam Bard <adam@adambard.com>
Date: Sun, 4 Mar 2018 19:48:44 -0800
Subject: Assorted fixes

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

(limited to 'fr-fr')

diff --git a/fr-fr/markdown-fr.html.markdown b/fr-fr/markdown-fr.html.markdown
index 2e4e8461..8518f35c 100644
--- a/fr-fr/markdown-fr.html.markdown
+++ b/fr-fr/markdown-fr.html.markdown
@@ -14,7 +14,7 @@ Faites moi autant de retours que vous voulez! Sentez vous libre de "forker"
 et envoyer des pull request!
 
 
-```markdown
+```md
 <!-- Markdown est une sorte de cousin du HTML, si bien que tout document HTML 
 est un document Markdown valide. Autrement dit, vous pouvez utiliser des 
 balises HTML dans un fichier Markdown, comme la balise commentaire dans 
-- 
cgit v1.2.3


From 0345980feaf641324d02f0c0f52a7614452d1d7f Mon Sep 17 00:00:00 2001
From: Pratik Karki <predatoramigo@gmail.com>
Date: Wed, 14 Mar 2018 08:42:39 +0545
Subject: Update bf-fr.html.markdown

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

(limited to 'fr-fr')

diff --git a/fr-fr/bf-fr.html.markdown b/fr-fr/bf-fr.html.markdown
index d8c7c76a..0fae6032 100644
--- a/fr-fr/bf-fr.html.markdown
+++ b/fr-fr/bf-fr.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: Brainfuck
+language: bf
 filename: learnbrainfuck-fr.bf
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io/"]
-- 
cgit v1.2.3


From 8aa693c8cb1b5e7136603ce8e000d2142a6a20e6 Mon Sep 17 00:00:00 2001
From: Yvan Sraka <yvan@sraka.pw>
Date: Sat, 9 Jun 2018 18:35:45 +0200
Subject: Fix typos in French version of Dynamic Programming tutorial

---
 fr-fr/dynamic-programming-fr.html.markdown | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/dynamic-programming-fr.html.markdown b/fr-fr/dynamic-programming-fr.html.markdown
index 24e8c95f..b3660ac9 100644
--- a/fr-fr/dynamic-programming-fr.html.markdown
+++ b/fr-fr/dynamic-programming-fr.html.markdown
@@ -8,7 +8,6 @@ translators:
 lang: fr-fr
 ---
 
-
 # Programmation dynamique
 
 ## Introduction
@@ -17,9 +16,9 @@ La programmation dynamique est une technique très efficace pour résoudre une c
 
 ## Moyens de résoudre ces problèmes
 
-1.) *De haut en bas* : Commençons à résoudre le problème en le séparant en morceaux. Si nous voyons que le problème a déjà été résolu, alors nous retournons la réponse précédemment sauvegardée. Si le problème n'a pas été résolu, alors nous le résolvons et sauvegardons la réponse. C'est généralement facile et intuitif de réfléchir de cette façon. Cela s'appelle la Mémorisation.
+1. *De haut en bas* : Commençons à résoudre le problème en le séparant en morceaux. Si nous voyons que le problème a déjà été résolu, alors nous retournons la réponse précédemment sauvegardée. Si le problème n'a pas été résolu, alors nous le résolvons et sauvegardons la réponse. C'est généralement facile et intuitif de réfléchir de cette façon. Cela s'appelle la Mémorisation.
 
-2.) *De bas en haut* : Il faut analyser le problème et trouver les sous-problèmes, et l'ordre dans lequel il faut les résoudre. Ensuite, nous devons résoudre les sous-problèmes et monter jusqu'au problème que nous voulons résoudre. De cette façon, nous sommes assurés que les sous-problèmes sont résolus avant de résoudre le vrai problème. Cela s'appelle la Programmation Dynamique.
+2. *De bas en haut* : Il faut analyser le problème et trouver les sous-problèmes, et l'ordre dans lequel il faut les résoudre. Ensuite, nous devons résoudre les sous-problèmes et monter jusqu'au problème que nous voulons résoudre. De cette façon, nous sommes assurés que les sous-problèmes sont résolus avant de résoudre le vrai problème. Cela s'appelle la Programmation Dynamique.
 
 ## Exemple de Programmation Dynamique
 
@@ -27,7 +26,7 @@ Le problème de la plus grande sous-chaîne croissante est de trouver la plus gr
 Premièrement, nous avons à trouver la valeur de la plus grande sous-chaîne (LSi) à chaque index `i`, avec le dernier élément de la sous-chaîne étant ai. Alors, la plus grande sous-chaîne sera le plus gros LSi. Pour commencer, LSi est égal à 1, car ai est le seul élément de la chaîne (le dernier). Ensuite, pour chaque `j` tel que `j<i` et `aj<ai`, nous trouvons le plus grand LSj et ajoutons le à LSi. L'algorithme fonctionne en temps *O(n2)*.   
 
 Pseudo-code pour trouver la longueur de la plus grande sous-chaîne croissante :
-La complexité de cet algorithme peut être réduite en utilisant une meilleure structure de données qu'un tableau. Par exemple, si nous sauvegardions le tableau d'origine, ou une variable comme plus_grande_chaîne_jusqu'à_maintenant et son index, nous pourrions sauver beaucoup de temps. 
+La complexité de cet algorithme peut être réduite en utilisant une meilleure structure de données qu'un tableau. Par exemple, si nous sauvegardions le tableau d'origine, ou une variable comme `plus_grande_chaîne_jusqu'à_maintenant` et son index, nous pourrions sauver beaucoup de temps. 
 
 Le même concept peut être appliqué pour trouver le chemin le plus long dans un graphe acyclique orienté.  
 
@@ -43,12 +42,9 @@ Le même concept peut être appliqué pour trouver le chemin le plus long dans u
 
 ### Problèmes classiques de programmation dynamique
 
-L'algorithme de Floyd Warshall(EN)) - Tutorial and C Program source code:http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code
-
-Problème du sac à dos(EN) - Tutorial and C Program source code: http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem
-
-
-Plus longue sous-chaîne commune(EN) - Tutorial and C Program source code : http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence
+- L'algorithme de Floyd Warshall(EN)) - Tutorial and C Program source code:http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code
+- Problème du sac à dos(EN) - Tutorial and C Program source code: http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem
+- Plus longue sous-chaîne commune(EN) - Tutorial and C Program source code : http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence
 
 ## Online Resources
 
-- 
cgit v1.2.3


From a1680153e0fcba0b95bbd522e52d504b71410396 Mon Sep 17 00:00:00 2001
From: Yvan Sraka <yvan@sraka.pw>
Date: Sat, 9 Jun 2018 19:06:33 +0200
Subject: Translate Lambda Calculus in French

---
 fr-fr/lambda-calculus-fr.html.markdown | 105 +++++++++++++++++++++++++++++++++
 1 file changed, 105 insertions(+)
 create mode 100644 fr-fr/lambda-calculus-fr.html.markdown

(limited to 'fr-fr')

diff --git a/fr-fr/lambda-calculus-fr.html.markdown b/fr-fr/lambda-calculus-fr.html.markdown
new file mode 100644
index 00000000..68868830
--- /dev/null
+++ b/fr-fr/lambda-calculus-fr.html.markdown
@@ -0,0 +1,105 @@
+---
+category: Algorithms & Data Structures
+name: Lambda Calculus
+contributors:
+    - ["Max Sun", "http://github.com/maxsun"]
+translators:
+    - ["Yvan Sraka", "https://github.com/yvan-sraka"]
+---
+
+# Lambda-calcul
+
+Le Lambda-calcul (λ-calcul), créé à l'origine par [Alonzo Church](https://en.wikipedia.org/wiki/Alonzo_Church), est le plus petit langage de programmation au monde. En dépit de ne pas avoir de nombres, de chaînes, de booléens, ou de tout type de données sans fonction, le lambda calcul peut être utilisé pour représenter n'importe quelle machine de Turing!
+
+Le Lambda-calcul est composé de 3 éléments : **variables**, **fonctions** et **applications**.
+
+
+| Nom         | Syntaxe                            | Exemple   | Explication                                       |
+|-------------|------------------------------------|-----------|---------------------------------------------------|
+| Variable    | `<nom>`                            | `x`       | une variable nommée "x"                           |
+| Fonction    | `λ<paramètres>.<corps>`            | `λx.x`    | une fonction avec le paramètre "x" et le corps "x"|
+| Application | `<fonction><variable ou function>` | `(λx.x)a` | appel de la fonction "λx.x" avec l'argument "a"   |
+
+La fonction la plus fondamentale est la fonction identité: `λx.x` qui est équivalente à `f(x) = x`. Le premier "x" est l'argument de la fonction, et le second est le corps de la fonction.
+
+## Variables libres et liées :
+
+- Dans la fonction `λx.x`, "x" s'appelle une variable liée car elle est à la fois dans le corps de la fonction et l'un des paramètres.
+- Dans `λx.y`, "y" est appelé une variable libre car elle n'a pas été déclarée plus tôt.
+
+## Évaluation :
+
+L'évaluation est réalisée par [β-Réduction](https://en.wikipedia.org/wiki/Lambda_calculus#Beta_reduction), qui est essentiellement une substitution lexicale.
+
+Lors de l'évaluation de l'expression `(λx.x)a`, nous remplaçons toutes les occurrences de "x" dans le corps de la fonction par "a".
+
+- `(λx.x)a` vaut après évaluation: `a`
+- `(λx.y)a` vaut après évaluation: `y`
+
+Vous pouvez même créer des fonctions d'ordre supérieur:
+
+- `(λx.(λy.x))a` vaut après évaluation: `λy.a`
+
+Bien que le lambda-calcul ne prenne traditionnellement en charge que les fonctions à un seul paramètre, nous pouvons créer des fonctions multi-paramètres en utilisant une technique appelée currying.
+
+- `(λx.λy.λz.xyz)` est équivalent à `f(x, y, z) = x(y(z))`
+
+Parfois, `λxy.<corps>` est utilisé de manière interchangeable avec: `λx.λy.<corps>`
+
+----
+
+Il est important de reconnaître que le lambda-calcul traditionnel n'a pas de nombres, de caractères ou tout autre type de données sans fonction!
+
+## Logique booléenne :
+
+Il n'y a pas de "Vrai" ou de "Faux" dans le calcul lambda. Il n'y a même pas 1 ou 0.
+
+Au lieu:
+
+`T` est représenté par: `λx.λy.x`
+
+`F` est représenté par: `λx.λy.y`
+
+Premièrement, nous pouvons définir une fonction "if" `λbtf` qui renvoie `t` si `b` est vrai et `f` si `b` est faux
+
+`IF` est équivalent à: `λb.λt.λf.b t f`
+
+En utilisant `IF`, nous pouvons définir les opérateurs logiques de base booléens:
+
+`a AND b` est équivalent à: `λab.IF a b F`
+
+`a OR b` est équivalent à: `λab.IF a T b`
+
+`a NOT b` est équivalent à: `λa.IF a F T`
+
+*Note: `IF a b c` est equivalent à : `IF(a(b(c)))`*
+
+## Nombres :
+
+Bien qu'il n'y ait pas de nombres dans le lambda-calcul, nous pouvons encoder des nombres en utilisant les [nombres de Church](https://en.wikipedia.org/wiki/Church_encoding).
+
+Pour tout nombre n: <code>n = λf.f<sup>n</sup></code> donc:
+
+`0 = λf.λx.x`
+
+`1 = λf.λx.f x`
+
+`2 = λf.λx.f(f x)`
+
+`3 = λf.λx.f(f(f x))`
+
+Pour incrémenter un nombre de Church, nous utilisons la fonction successeur `S(n) = n + 1` qui est:
+
+`S = λn.λf.λx.f((n f) x)`
+
+En utilisant `S`, nous pouvons définir la fonction `ADD`:
+
+`ADD = λab.(a S)n`
+
+**Défi:** essayez de définir votre propre fonction de multiplication!
+
+## Pour aller plus loin :
+
+1. [A Tutorial Introduction to the Lambda Calculus](http://www.inf.fu-berlin.de/lehre/WS03/alpi/lambda.pdf)
+2. [Cornell CS 312 Recitation 26: The Lambda Calculus](http://www.cs.cornell.edu/courses/cs3110/2008fa/recitations/rec26.html)
+3. [Wikipedia - Lambda Calculus](https://en.wikipedia.org/wiki/Lambda_calculus)
\ No newline at end of file
-- 
cgit v1.2.3


From ee013dd2da8def229cbb219e0c6a700f150e57e8 Mon Sep 17 00:00:00 2001
From: boissonnfive <boissonnfive@gmail.com>
Date: Tue, 26 Jun 2018 23:17:27 +0200
Subject: Several corrections + copy english markdown page format.

---
 fr-fr/markdown-fr.html.markdown | 253 +++++++++++++++++++++++++---------------
 1 file changed, 156 insertions(+), 97 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/markdown-fr.html.markdown b/fr-fr/markdown-fr.html.markdown
index 8518f35c..42af1b2b 100644
--- a/fr-fr/markdown-fr.html.markdown
+++ b/fr-fr/markdown-fr.html.markdown
@@ -10,48 +10,64 @@ Markdown a été créé par John Gruber en 2004. Il se veut être d'une syntaxe
 facile à lire et à écrire, aisément convertible en HTML
  (et beaucoup d'autres formats aussi à présent).
 
-Faites moi autant de retours que vous voulez! Sentez vous libre de "forker" 
-et envoyer des pull request!
+Le Markdown est implémenté de différentes manières, selon le parser. 
+Ce guide va alors tenter de trier les fonctionnalités universelles de celles
+spécifiques à un parser.
 
+- [HTML](#html)
+- [Titres](#titres)
+- [Formatage simple du texte](#formatage-simple-du-texte)
+- [Les paragraphes](#les-paragraphes)
+- [Les listes](#les-listes)
+- [Insertion de code](#insertion-de-code)
+- [Ligne Horizontale](#ligne-horizontale)
+- [Liens](#liens)
+- [Images](#images)
+- [Divers](#divers)
 
-```md
-<!-- Markdown est une sorte de cousin du HTML, si bien que tout document HTML 
+
+## HTML
+
+Markdown est une sorte de cousin du HTML, si bien que tout document HTML 
 est un document Markdown valide. Autrement dit, vous pouvez utiliser des 
 balises HTML dans un fichier Markdown, comme la balise commentaire dans 
 laquelle nous sommes à présent, car celle-ci ne sera pas affectée par 
-le parser( analyseur syntaxique ) Markdown. -->
+le parser( analyseur syntaxique ) Markdown.
 
-<!-- Toutefois, si vous voulez créer un élément HTML dans un fichier Markdown,
+```md
+<!-- Autrement dit, vous pouvez utiliser des balises HTML dans un fichier Markdown, comme la balise commentaire dans laquelle nous sommes à présent, car celle-ci ne sera pas affectée par le parser( analyseur syntaxique ) Markdown. Toutefois, si vous voulez créer un élément HTML dans un fichier Markdown,
  vous ne pourrez pas utiliser du Markdown à l'intérieur de ce dernier. -->
+```
 
-<!--  Le Markdown est implémenté de différentes manières, selon le parser. 
-Ce guide va alors tenter de trier les fonctionnalités universelles de celles
-spécifiques à un parser.  -->
 
-<!-- Headers ( En-têtes ) -->
-<!-- Vous pouvez facilement créer des éléments HTML <h1> à <h6> en précédant
- le texte de votre futur titre par un ou plusieurs dièses ( # ), de un à six,
-  selon le niveau de titre souhaité. -->
+## Titres
+
+Vous pouvez facilement créer des éléments HTML `<h1>` à `<h6> en précédant le texte de votre futur titre par un ou plusieurs dièses ( # ), de un à six, selon le niveau de titre souhaité.
+
+```md
 # Ceci est un <h1>
 ## Ceci est un <h2>
 ### Ceci est un <h3>
 #### Ceci est un <h4>
 ##### Ceci est un <h5>
 ###### Ceci est un <h6>
+```
 
-<!-- 
-Markdown fournit également une façon alternative de marquer les h1 et h2 
--->
+Markdown fournit également une façon alternative de marquer les h1 et h2
 
+```md
 Ceci est un h1
 =============
 
 Ceci est un h2
 -------------
+```
+
+## Formatage simple du texte
 
-<!-- Styles basiques pour du texte -->
-<!-- On peut facilement rendre un texte "gras" ou "italique" en Markdown -->
+ On peut facilement rendre un texte "gras" ou "italique" en Markdown
 
+```md
 *Ce texte est en italique.*
 _Celui-ci aussi._
 
@@ -61,15 +77,23 @@ __Celui-là aussi.__
 ***Ce texte a les deux styles.***
 **_Pareil ici_**
 *__Et là!__*
+```
+
 
-<!-- Dans le "GitHub Flavored Markdown", utilisé pour interpréter le Markdown 
-sur GitHub, on a également le strikethrough ( texte barré ) : -->
+Dans le Markdown de GitHub, utilisé pour interpréter le Markdown 
+sur GitHub, on a également le strikethrough ( texte barré ) :
 
+```md
 ~~Ce texte est barré avec strikethrough.~~
+```
+
 
-<!--  Les Paragraphes sont représentés par une ou plusieurs lignes de texte 
-séparées par une ou plusieurs lignes vides. -->
+## Les paragraphes
 
+Les Paragraphes sont représentés par une ou plusieurs lignes de texte 
+séparées par une ou plusieurs lignes vides.
+
+```md
 Ceci est un paragraphe. Là, je suis dans un paragraphe, facile non?
 
 Maintenant je suis dans le paragraphe 2.
@@ -77,19 +101,21 @@ Je suis toujours dans le paragraphe 2!
 
 
 Puis là, eh oui, le paragraphe 3!
+```
 
-<!--  
 Si jamais vous souhaitez insérer une balise HTML <br />, vous pouvez ajouter 
 un ou plusieurs espaces à la fin de votre paragraphe, et en commencer 
 un nouveau.
--->
 
+```md
 J'ai deux espaces vides à la fin (sélectionnez moi pour les voir). 
 
 Bigre, il y a un <br /> au dessus de moi!
+```
 
-<!-- Les 'Blocs de Citations' sont générés aisément, grâce au caractère > -->
+Les 'Blocs de Citations' sont générés aisément, grâce au caractère `>`
 
+```md
 > Ceci est une superbe citation. Vous pouvez même
 > revenir à la ligne quand ça vous chante, et placer un `>` 
 > devant chaque bout de ligne faisant partie
@@ -99,11 +125,14 @@ Bigre, il y a un <br /> au dessus de moi!
 > Vous pouvez aussi utiliser plus d'un niveau
 >> d'imbrication!
 > Classe et facile, pas vrai?
+```
+
 
-<!-- les Listes -->
-<!-- les Listes non ordonnées sont marquées par des asterisques, 
-signes plus ou signes moins. -->
+## Les listes
 
+les Listes non ordonnées sont marquées par des asterisques, signes plus ou signes moins.
+
+```md
 * Item
 * Item
 * Un autre item
@@ -119,171 +148,201 @@ ou
 - Item
 - Item
 - Un dernier item
+```
 
-<!-- les Listes Ordonnées sont générées via un nombre suivi d'un point -->
+les Listes Ordonnées sont générées via un nombre suivi d'un point
 
+```md
 1. Item un
 2. Item deux
 3. Item trois
+```
 
-<!-- Vous pouvez même vous passer de tout numéroter, et Markdown générera 
-les bons chiffres. Ceci dit, cette variante perd en clarté.-->
+Vous pouvez même vous passer de tout numéroter, et Markdown générera les bons chiffres. Ceci dit, cette variante perd en clarté.
 
+```md
 1. Item un
 1. Item deux
 1. Item trois
-<!-- ( cette liste sera interprétée de la même façon que celle au dessus ) -->
+```
+
+(cette liste sera interprétée de la même façon que celle au-dessus)
 
-<!-- Vous pouvez également utiliser des sous-listes -->
+Vous pouvez également utiliser des sous-listes
 
+```md
 1. Item un
 2. Item deux
 3. Item trois
 * Sub-item
 * Sub-item
 4. Item quatre
+```
 
-<!-- Il y a même des "listes de Taches". Elles génèrent des champs HTML 
-de type checkbox. -->
-
-Les [ ] ci dessous, n'ayant pas de [ x ], 
-deviendront des cases à cocher HTML non-cochées.
+Il y a même des "listes de Taches". Elles génèrent des champs HTML de type checkbox. Les [ ] ci-dessous, n'ayant pas de [ x ], deviendront des cases à cocher HTML non-cochées.
 
+```md
 - [ ] Première tache à réaliser.
 - [ ] Une autre chose à faire.
 La case suivante sera une case à cocher HTML cochée.
 - [x] Ça ... c'est fait!
+```
+
 
-<!-- les Blocs de Code -->
-<!-- Pour marquer du texte comme étant du code, il suffit de commencer 
-chaque ligne en tapant 4 espaces (ou un Tab) -->
+## Insertion de code
 
+Pour marquer du texte comme étant du code, il suffit de commencer 
+chaque ligne en tapant 4 espaces (ou un Tab).
+
+```md
     echo "Ça, c'est du Code!";
     var Ça = "aussi !";
+```
 
-<!-- L'indentation par tab ou série de quatre espaces 
-fonctionne aussi à l'intérieur du bloc de code -->
+L'indentation par tab ou série de quatre espaces fonctionne aussi à l'intérieur du bloc de code.
 
+```md
     my_array.each do |item|
        puts item
     end
+```
 
-<!-- Des bouts de code en mode 'inline' s'ajoutent en les entourant de ` -->
+On peut insérer du code dans le texte des paragraphes en entourant le code par des `.
 
+```md
 La fonction `run()` ne vous oblige pas à aller courir!
+```
+
+En Markdown GitHub, vous pouvez utiliser des syntaxes spécifiques.
 
-<!-- Via GitHub Flavored Markdown, vous pouvez utiliser 
-des syntaxes spécifiques -->
 
-\`\`\`ruby 
-<!-- mais enlevez les backslashes quand vous faites ça, 
-gardez juste ```ruby ( ou nom de la syntaxe correspondant à votre code )-->
-def foobar
-puts "Hello world!"
-end
-\`\`\` <!-- pareil, pas de backslashes, juste ``` en guise de fin -->
+    ```ruby 
+    def foobar
+    puts "Hello world!"
+    end
+    ```
+
+Pas besoin d'indentation pour le code juste au dessus, de plus, GitHub 
+va utiliser une coloration syntaxique pour le langage indiqué après les ```.
 
-<-- Pas besoin d'indentation pour le code juste au dessus, de plus, GitHub 
-va utiliser une coloration syntaxique pour le langage indiqué après les ``` -->
+## Ligne Horizontale
 
-<!-- Ligne Horizontale (<hr />) -->
-<!-- Pour en insérer une, utilisez trois ou plusieurs astérisques ou tirets, 
-avec ou sans espaces entre chaque un. -->
+Pour en insérer une, utilisez trois ou plusieurs astérisques ou tirets, 
+avec ou sans espaces entre chaque un.
 
+```md
 ***
 ---
 - - -
 ****************
+```
+
+## Liens
 
-<!-- Liens -->
-<!-- Une des fonctionnalités sympathiques du Markdown est la facilité 
-d'ajouter des liens. Le texte du lien entre [ ], l'url entre ( ), 
-et voilà l'travail.
--->
+Une des fonctionnalités sympathiques du Markdown est la facilité d'ajouter des liens. Le texte du lien entre [ ], l'url entre ( ), et voilà l'travail.
 
+```md
 [Clic moi!](http://test.com/)
+```
 
-<!-- 
-Pour ajouter un attribut Title, collez le entre guillemets, avec le lien. 
--->
+Pour ajouter un attribut Title, collez-le entre guillemets, avec le lien.
 
+```md
 [Clic moi!](http://test.com/ "Lien vers Test.com")
+```
 
-<!-- les Liens Relatifs marchent aussi -->
+Les Liens Relatifs marchent aussi.
 
+```md
 [En avant la musique](/music/).
+```
 
-<!-- Les liens façon "références" sont eux aussi disponibles en Markdown -->
+Les liens façon "références" sont eux aussi disponibles en Markdown.
 
+```md
 [Cliquez ici][link1] pour plus d'information!
 [Regardez aussi par ici][foobar] si vous voulez.
 
 [link1]: http://test.com/ "Cool!"
 [foobar]: http://foobar.biz/ "Alright!"
+```
 
-<!--  Le titre peut aussi être entouré de guillemets simples, 
-entre parenthèses ou absent. Les références peuvent être placées 
-un peu où vous voulez dans le document, et les identifiants 
-(link1, foobar, ...) quoi que ce soit tant qu'ils sont uniques -->
+Le titre peut aussi être entouré de guillemets simples, entre parenthèses ou absent. Les références peuvent être placées un peu où vous voulez dans le document, et les identifiants (link1, foobar, ...) pevent être n'importe quoi tant qu'ils sont uniques.
 
-<!-- Il y a également le "nommage implicite" qui transforme le texte du lien
- en identifiant -->
+Il y a également le "nommage implicite" qui transforme le texte du lien en identifiant.
 
+```md
 [Ceci][] est un lien.
 
 [ceci]: http://ceciestunlien.com/
+```
 
-<!-- mais ce n'est pas beaucoup utilisé. -->
+mais ce n'est pas beaucoup utilisé.
 
-<!-- Images -->
-<!-- Pour les images, la syntaxe est identique aux liens, sauf que précédée
- d'un point d'exclamation! -->
+## Images
 
+Pour les images, la syntaxe est identique aux liens, sauf que précédée d'un point d'exclamation!
+
+```md
 ![Attribut ALT de l'image](http://imgur.com/monimage.jpg "Titre optionnel")
+```
 
-<!-- Là aussi, on peut utiliser le mode "références" -->
+Là aussi, on peut utiliser le mode "références".
 
+```md
 ![Ceci est l'attribut ALT de l'image][monimage]
 
 [monimage]: relative/urls/cool/image.jpg "si vous voulez un titre, c'est ici."
+```
 
-<!-- Divers -->
-<!-- Liens Automatiques -->
 
+## Divers
+
+### Liens Automatiques
+
+```md
 <http://testwebsite.com/> est équivalent à :
 [http://testwebsite.com/](http://testwebsite.com/)
+```
 
-<!-- Liens Automatiques pour emails -->
+### Liens Automatiques pour emails
 
+```md
 <foo@bar.com>
+```
+
+### Caractères d'échappement
+
+Il suffit de précéder les caractères spécifiques à ignorer par des anti slash `\`.`
 
-<!-- Escaping -->
-Il suffit de précéder les caractères spécifiques à ignorer par des backslash \
+```md
+Pour taper *ce texte* entouré d'astérisques mais pas en italique : Tapez \*ce texte\*.
+```
 
-Pour taper *ce texte* entouré d'astérisques mais pas en italique : 
-Tapez \*ce texte\*.
+### Tableaux
 
-<!-- Tableaux -->
-<!-- les Tableaux ne sont disponibles que dans le GitHub Flavored Markdown
- et c'est ce n'est pas super agréable d'utilisation. 
- Mais si vous en avez besoin :
- -->
+Les Tableaux ne sont disponibles que dans le GitHub Flavored Markdown et c'est ce n'est pas super agréable d'utilisation. Mais si vous en avez besoin :
 
+```md
 | Col1 | Col2 | Col3 |
 | :----------- | :------: | ------------: |
 | Alignement Gauche | Centé | Alignement Droite |
 | bla | bla | bla |
+```
 
-<!-- ou bien, pour un résultat équivalent : -->
+ou bien, pour un résultat équivalent :
 
+```md
 Col 1 | Col2 | Col3
 :-- | :-: | --:
 Ough que c'est moche | svp | arrêtez
+```
 
-<!-- Fin! -->
+***
 
-```
+Pour plus d'information, consultez [ici](http://daringfireball.net/projects/markdown/syntax) le post officiel de John Gruber à propos de la syntaxe, et [là](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) la superbe cheatsheet de Adam Pritchard.
 
-Pour plus d'information :
- consultez [ici](http://daringfireball.net/projects/markdown/syntax) le post officiel de Jhon Gruber à propos de la syntaxe, 
- et [là](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) la superbe cheatsheet de Adam Pritchard.
+***
+
+Faites moi autant de retours que vous voulez! Sentez vous libre de "forker" 
+et envoyer des pull request!
\ No newline at end of file
-- 
cgit v1.2.3


From 92022da0a6ea9417521563de9e537f337c426465 Mon Sep 17 00:00:00 2001
From: boissonnfive <boissonnfive@gmail.com>
Date: Wed, 27 Jun 2018 14:45:10 +0200
Subject: Corrections de majuscules, sauts de lignes, guillemets, accents +
 reformulations.

---
 fr-fr/markdown-fr.html.markdown | 85 ++++++++++++++++++-----------------------
 1 file changed, 37 insertions(+), 48 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/markdown-fr.html.markdown b/fr-fr/markdown-fr.html.markdown
index 42af1b2b..4a2ecedc 100644
--- a/fr-fr/markdown-fr.html.markdown
+++ b/fr-fr/markdown-fr.html.markdown
@@ -7,12 +7,13 @@ lang: fr-fr
 ---
 
 Markdown a été créé par John Gruber en 2004. Il se veut être d'une syntaxe
-facile à lire et à écrire, aisément convertible en HTML
- (et beaucoup d'autres formats aussi à présent).
+facile à lire et à écrire, aisément convertible en HTML (et beaucoup d'autres formats aussi à présent).
+
+Il existe de nombreuses formes de Markdown : Markown classique, Markdown GitHub, Multi-Markdown, etc. Dans ce guide, nous signalerons quand les fonctionnalités sont spécifiques à une forme.
+
+_Faites moi autant de retours que vous voulez! Sentez vous libre de "forker" 
+et envoyer des pull request!_
 
-Le Markdown est implémenté de différentes manières, selon le parser. 
-Ce guide va alors tenter de trier les fonctionnalités universelles de celles
-spécifiques à un parser.
 
 - [HTML](#html)
 - [Titres](#titres)
@@ -28,21 +29,20 @@ spécifiques à un parser.
 
 ## HTML
 
-Markdown est une sorte de cousin du HTML, si bien que tout document HTML 
-est un document Markdown valide. Autrement dit, vous pouvez utiliser des 
-balises HTML dans un fichier Markdown, comme la balise commentaire dans 
-laquelle nous sommes à présent, car celle-ci ne sera pas affectée par 
-le parser( analyseur syntaxique ) Markdown.
+Markdown est une sorte de cousin du HTML, si bien que tout document HTML est un document Markdown valide.
 
 ```md
-<!-- Autrement dit, vous pouvez utiliser des balises HTML dans un fichier Markdown, comme la balise commentaire dans laquelle nous sommes à présent, car celle-ci ne sera pas affectée par le parser( analyseur syntaxique ) Markdown. Toutefois, si vous voulez créer un élément HTML dans un fichier Markdown,
- vous ne pourrez pas utiliser du Markdown à l'intérieur de ce dernier. -->
+<!-- Autrement dit, vous pouvez utiliser des balises HTML dans un fichier
+Markdown, comme la balise commentaire dans laquelle nous sommes à présent, car 
+celle-ci ne sera pas affectée par le parser (analyseur syntaxique) Markdown.
+ Toutefois, si vous voulez créer un élément HTML dans un fichier Markdown,
+  vous ne pourrez pas utiliser du Markdown à l'intérieur de ce dernier. -->
 ```
 
 
 ## Titres
 
-Vous pouvez facilement créer des éléments HTML `<h1>` à `<h6> en précédant le texte de votre futur titre par un ou plusieurs dièses ( # ), de un à six, selon le niveau de titre souhaité.
+Vous pouvez facilement créer des titres HTML `<h1>` à `<h6>` en précédant le texte de votre futur titre par un ou plusieurs dièses (#), de un à six, selon le niveau de titre souhaité.
 
 ```md
 # Ceci est un <h1>
@@ -53,7 +53,7 @@ Vous pouvez facilement créer des éléments HTML `<h1>` à `<h6> en précédant
 ###### Ceci est un <h6>
 ```
 
-Markdown fournit également une façon alternative de marquer les h1 et h2
+Markdown fournit également une façon alternative de marquer les `<h1>` et `<h2>`
 
 ```md
 Ceci est un h1
@@ -65,7 +65,7 @@ Ceci est un h2
 
 ## Formatage simple du texte
 
- On peut facilement rendre un texte "gras" ou "italique" en Markdown
+ On peut facilement mettre un texte en « gras » ou en « italique » en Markdown
 
 ```md
 *Ce texte est en italique.*
@@ -79,9 +79,7 @@ __Celui-là aussi.__
 *__Et là!__*
 ```
 
-
-Dans le Markdown de GitHub, utilisé pour interpréter le Markdown 
-sur GitHub, on a également le strikethrough ( texte barré ) :
+Dans le Markdown GitHub, utilisé pour interpréter le Markdown sur le site de GitHub, on a également le texte barré :
 
 ```md
 ~~Ce texte est barré avec strikethrough.~~
@@ -90,8 +88,7 @@ sur GitHub, on a également le strikethrough ( texte barré ) :
 
 ## Les paragraphes
 
-Les Paragraphes sont représentés par une ou plusieurs lignes de texte 
-séparées par une ou plusieurs lignes vides.
+Les Paragraphes sont représentés par une ou plusieurs lignes de texte séparées par une ou plusieurs lignes vides.
 
 ```md
 Ceci est un paragraphe. Là, je suis dans un paragraphe, facile non?
@@ -103,17 +100,17 @@ Je suis toujours dans le paragraphe 2!
 Puis là, eh oui, le paragraphe 3!
 ```
 
-Si jamais vous souhaitez insérer une balise HTML <br />, vous pouvez ajouter 
+Si jamais vous souhaitez insérer une balise HTML `<br />`, vous pouvez ajouter 
 un ou plusieurs espaces à la fin de votre paragraphe, et en commencer 
 un nouveau.
 
 ```md
-J'ai deux espaces vides à la fin (sélectionnez moi pour les voir). 
+J'ai deux espaces vides à la fin (sélectionnez moi pour les voir).  
 
 Bigre, il y a un <br /> au dessus de moi!
 ```
 
-Les 'Blocs de Citations' sont générés aisément, grâce au caractère `>`
+Les « Blocs de Citations » sont générés aisément, grâce au caractère `>`
 
 ```md
 > Ceci est une superbe citation. Vous pouvez même
@@ -130,7 +127,7 @@ Les 'Blocs de Citations' sont générés aisément, grâce au caractère `>`
 
 ## Les listes
 
-les Listes non ordonnées sont marquées par des asterisques, signes plus ou signes moins.
+Les listes non ordonnées sont marquées par des astérisques, signes plus ou signes moins.
 
 ```md
 * Item
@@ -150,7 +147,7 @@ ou
 - Un dernier item
 ```
 
-les Listes Ordonnées sont générées via un nombre suivi d'un point
+Les listes ordonnées sont générées via un nombre suivi d'un point
 
 ```md
 1. Item un
@@ -168,7 +165,7 @@ Vous pouvez même vous passer de tout numéroter, et Markdown générera les bon
 
 (cette liste sera interprétée de la même façon que celle au-dessus)
 
-Vous pouvez également utiliser des sous-listes
+Vous pouvez également utiliser des sous-listes.
 
 ```md
 1. Item un
@@ -179,7 +176,7 @@ Vous pouvez également utiliser des sous-listes
 4. Item quatre
 ```
 
-Il y a même des "listes de Taches". Elles génèrent des champs HTML de type checkbox. Les [ ] ci-dessous, n'ayant pas de [ x ], deviendront des cases à cocher HTML non-cochées.
+En Markdown GitHub, il y a même des « listes de tâches ». Elles génèrent des champs HTML de type checkbox. Les [ ] ci-dessous, n'ayant pas de [ x ], deviendront des cases à cocher HTML non-cochées.
 
 ```md
 - [ ] Première tache à réaliser.
@@ -191,15 +188,14 @@ La case suivante sera une case à cocher HTML cochée.
 
 ## Insertion de code
 
-Pour marquer du texte comme étant du code, il suffit de commencer 
-chaque ligne en tapant 4 espaces (ou un Tab).
+Pour marquer du texte comme étant du code, il suffit de commencer chaque ligne en tapant 4 espaces (ou un Tab).
 
 ```md
     echo "Ça, c'est du Code!";
     var Ça = "aussi !";
 ```
 
-L'indentation par tab ou série de quatre espaces fonctionne aussi à l'intérieur du bloc de code.
+L'indentation par tab ou série de quatre espaces fonctionne aussi à 'intérieur du bloc de code.
 
 ```md
     my_array.each do |item|
@@ -207,7 +203,7 @@ L'indentation par tab ou série de quatre espaces fonctionne aussi à l'intérie
     end
 ```
 
-On peut insérer du code dans le texte des paragraphes en entourant le code par des `.
+On peut insérer du code à l'intérieur du texte en entourant le code par des `.
 
 ```md
 La fonction `run()` ne vous oblige pas à aller courir!
@@ -215,20 +211,18 @@ La fonction `run()` ne vous oblige pas à aller courir!
 
 En Markdown GitHub, vous pouvez utiliser des syntaxes spécifiques.
 
-
     ```ruby 
     def foobar
     puts "Hello world!"
     end
     ```
 
-Pas besoin d'indentation pour le code juste au dessus, de plus, GitHub 
+Pas besoin d'indentation pour le code juste au-dessus, de plus, GitHub 
 va utiliser une coloration syntaxique pour le langage indiqué après les ```.
 
 ## Ligne Horizontale
 
-Pour en insérer une, utilisez trois ou plusieurs astérisques ou tirets, 
-avec ou sans espaces entre chaque un.
+Pour insérer une ligne horizontale, utilisez trois ou plusieurs astérisques ou tirets, avec ou sans espaces entre.
 
 ```md
 ***
@@ -245,19 +239,19 @@ Une des fonctionnalités sympathiques du Markdown est la facilité d'ajouter des
 [Clic moi!](http://test.com/)
 ```
 
-Pour ajouter un attribut Title, collez-le entre guillemets, avec le lien.
+Pour ajouter un attribut `Title`, collez-le entre guillemets, avec le lien.
 
 ```md
 [Clic moi!](http://test.com/ "Lien vers Test.com")
 ```
 
-Les Liens Relatifs marchent aussi.
+Les liens relatifs marchent aussi.
 
 ```md
 [En avant la musique](/music/).
 ```
 
-Les liens façon "références" sont eux aussi disponibles en Markdown.
+Les liens façon « références » sont eux aussi disponibles en Markdown.
 
 ```md
 [Cliquez ici][link1] pour plus d'information!
@@ -267,9 +261,9 @@ Les liens façon "références" sont eux aussi disponibles en Markdown.
 [foobar]: http://foobar.biz/ "Alright!"
 ```
 
-Le titre peut aussi être entouré de guillemets simples, entre parenthèses ou absent. Les références peuvent être placées un peu où vous voulez dans le document, et les identifiants (link1, foobar, ...) pevent être n'importe quoi tant qu'ils sont uniques.
+Le titre peut aussi être entouré de guillemets simples, entre parenthèses ou absent. Les références peuvent être placées un peu où vous voulez dans le document, et les identifiants (link1, foobar, ...) peuvent être n'importe quoi tant qu'ils sont uniques.
 
-Il y a également le "nommage implicite" qui transforme le texte du lien en identifiant.
+Il y a également le « nommage implicite » qui transforme le texte du lien en identifiant.
 
 ```md
 [Ceci][] est un lien.
@@ -277,7 +271,7 @@ Il y a également le "nommage implicite" qui transforme le texte du lien en iden
 [ceci]: http://ceciestunlien.com/
 ```
 
-mais ce n'est pas beaucoup utilisé.
+Mais ce n'est pas beaucoup utilisé.
 
 ## Images
 
@@ -313,7 +307,7 @@ Là aussi, on peut utiliser le mode "références".
 
 ### Caractères d'échappement
 
-Il suffit de précéder les caractères spécifiques à ignorer par des anti slash `\`.`
+Il suffit de faire précéder les caractères spécifiques à ignorer par des anti slash `\`.`
 
 ```md
 Pour taper *ce texte* entouré d'astérisques mais pas en italique : Tapez \*ce texte\*.
@@ -321,7 +315,7 @@ Pour taper *ce texte* entouré d'astérisques mais pas en italique : Tapez \*ce
 
 ### Tableaux
 
-Les Tableaux ne sont disponibles que dans le GitHub Flavored Markdown et c'est ce n'est pas super agréable d'utilisation. Mais si vous en avez besoin :
+Les Tableaux ne sont disponibles que dans le Markdown GitHub et ce n'est pas super agréable d'utilisation. Mais si vous en avez besoin :
 
 ```md
 | Col1 | Col2 | Col3 |
@@ -341,8 +335,3 @@ Ough que c'est moche | svp | arrêtez
 ***
 
 Pour plus d'information, consultez [ici](http://daringfireball.net/projects/markdown/syntax) le post officiel de John Gruber à propos de la syntaxe, et [là](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) la superbe cheatsheet de Adam Pritchard.
-
-***
-
-Faites moi autant de retours que vous voulez! Sentez vous libre de "forker" 
-et envoyer des pull request!
\ No newline at end of file
-- 
cgit v1.2.3


From 21c899e41b9dfb7891acdd042d51406f307124a8 Mon Sep 17 00:00:00 2001
From: DevHugo <hugo.contactpro@gmail.com>
Date: Tue, 14 Aug 2018 19:15:58 +0200
Subject: Fix(mardown layout): Missing one caracter

Just a Markdown fix for the layout that broke the display on the website.
---
 fr-fr/jquery-fr.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'fr-fr')

diff --git a/fr-fr/jquery-fr.html.markdown b/fr-fr/jquery-fr.html.markdown
index 1842e02b..aeddbd53 100644
--- a/fr-fr/jquery-fr.html.markdown
+++ b/fr-fr/jquery-fr.html.markdown
@@ -138,5 +138,5 @@ $('p').each(function() {
 });
 
 
-``
+```
 
-- 
cgit v1.2.3


From 93499a09469335fda9b43d68bdf40bb87b67c071 Mon Sep 17 00:00:00 2001
From: DevHugo <hugo.contactpro@gmail.com>
Date: Tue, 14 Aug 2018 19:20:36 +0200
Subject: Translate: Header + Part 1

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

(limited to 'fr-fr')

diff --git a/fr-fr/pyqt-fr.html.markdown b/fr-fr/pyqt-fr.html.markdown
new file mode 100644
index 00000000..a0df8be5
--- /dev/null
+++ b/fr-fr/pyqt-fr.html.markdown
@@ -0,0 +1,85 @@
+---
+category: tool
+tool: PyQT
+filename: learnpyqt-fr.py
+contributors:
+    - ["Nathan Hughes", "https://github.com/sirsharpest"]
+translators:
+    - ["DevHugo", "http://twitter.com/devhugo"]
+lang: fr-fr
+---
+
+**Qt** est un framework très connu pour le développement de logiciel cross-platform qui peuvent être lancé sur différents systèmes avec de petit ou aucun changement dans le code, tout en ayant la puissance et la vitesse des applications natives. Bien que **Qt** ait été écrit à l'origine en *C++*.
+
+
+Ceci est une adaptation de l'intro C++ à QT par [Aleksey Kholovchuk](https://github.com/vortexxx192
+), certains exemples du code doivent avoir la même fonctionnalité,
+cette version ayant juste été faite en utilisant pyqt! 
+
+```python
+import sys
+from PyQt4 import QtGui
+	
+def window():
+	# Création de l'objet application 
+    app = QtGui.QApplication(sys.argv)
+	# Création d'un widget où notre label sera placé
+    w = QtGui.QWidget()
+	# Ajout d'un label au widget
+    b = QtGui.QLabel(w)
+	# Assignation de texte au label
+    b.setText("Hello World!")
+	# Assignation des tailles et des informations de placement
+    w.setGeometry(100, 100, 200, 50)
+    b.move(50, 20)
+	# Assignation d'un nom à notre fenêtre
+    w.setWindowTitle("PyQt")
+	# Affichage de la fenêtre
+    w.show()
+	# Exécution de l'application
+    sys.exit(app.exec_())
+
+if __name__ == '__main__':
+    window()
+
+```
+
+In order to get some of the more advanced features in **pyqt** we need to start looking at building additional elements. 
+Here we show how to introduce a dialog popup box, useful for asking the user to confirm a decision or to provide information.
+
+```Python 
+import sys
+from PyQt4.QtGui import *
+from PyQt4.QtCore import *
+
+
+def window():
+    app = QApplication(sys.argv)
+    w = QWidget()
+    # Create a button and attach to widget w
+    b = QPushButton(w)
+    b.setText("Press me")
+    b.move(50, 50)
+    # Tell b to call this function when clicked
+    # notice the lack of "()" on the function call
+    b.clicked.connect(showdialog)
+    w.setWindowTitle("PyQt Dialog")
+    w.show()
+    sys.exit(app.exec_())
+	
+# This function should create a dialog window with a button
+# that waits to be clicked and then exits the program
+def showdialog():
+    d = QDialog()
+    b1 = QPushButton("ok", d)
+    b1.move(50, 50)
+    d.setWindowTitle("Dialog")
+    # This modality tells the popup to block the parent whilst it's active
+    d.setWindowModality(Qt.ApplicationModal)
+    # On click I'd like the entire process to end
+    b1.clicked.connect(sys.exit)
+    d.exec_()
+
+if __name__ == '__main__':
+    window()
+```
-- 
cgit v1.2.3


From 440247a59706603bd980016821ecd6a72a6182d1 Mon Sep 17 00:00:00 2001
From: Adam Bard <adam@adambard.com>
Date: Tue, 28 Aug 2018 08:49:41 -0700
Subject: Update jquery-fr.html.markdown

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

(limited to 'fr-fr')

diff --git a/fr-fr/jquery-fr.html.markdown b/fr-fr/jquery-fr.html.markdown
index aeddbd53..1a5baf71 100644
--- a/fr-fr/jquery-fr.html.markdown
+++ b/fr-fr/jquery-fr.html.markdown
@@ -13,6 +13,7 @@ jQuery est une bibliothèque JavaScript dont le but est de permettre de "faire p
 C'est pourquoi aujourd'hui, jQuery est utilisée par de nombreuses grandes entreprises et par des développeurs du monde entier.
 
 Étant donné que jQuery est une bibliothèque JavaScript, vous devriez d'abord [apprendre le JavaScript](https://learnxinyminutes.com/docs/fr-fr/javascript-fr/)
+
 ```js
 
 
-- 
cgit v1.2.3


From 478a43c1d4a230a36420cd6d4bc0a27a23f4afef Mon Sep 17 00:00:00 2001
From: Divay Prakash <divayprakash3@gmail.com>
Date: Tue, 4 Sep 2018 18:25:57 +0530
Subject: Add language code suffix (#3206)

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

(limited to 'fr-fr')

diff --git a/fr-fr/java-fr.html.markdown b/fr-fr/java-fr.html.markdown
index d0f91611..d6c68343 100644
--- a/fr-fr/java-fr.html.markdown
+++ b/fr-fr/java-fr.html.markdown
@@ -11,7 +11,7 @@ contributors:
     - ["Michael Dähnert", "https://github.com/JaXt0r"]
     - ["Rob Rose", "https://github.com/RobRoseKnows"]
     - ["Sean Nam", "https://github.com/seannam"]
-filename: JavaFr.java
+filename: java-fr.java
 translators:
     - ['Mathieu Gemard', 'https://github.com/mgemard']
 lang: fr-fr
-- 
cgit v1.2.3


From b955d9386b302c185fa882c627e1df66f9a87c76 Mon Sep 17 00:00:00 2001
From: DevHugo <hugo.contactpro@gmail.com>
Date: Wed, 5 Sep 2018 10:34:20 +0200
Subject: Translate: Part 2

---
 fr-fr/pyqt-fr.html.markdown | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/pyqt-fr.html.markdown b/fr-fr/pyqt-fr.html.markdown
index a0df8be5..870a2c4e 100644
--- a/fr-fr/pyqt-fr.html.markdown
+++ b/fr-fr/pyqt-fr.html.markdown
@@ -44,8 +44,8 @@ if __name__ == '__main__':
 
 ```
 
-In order to get some of the more advanced features in **pyqt** we need to start looking at building additional elements. 
-Here we show how to introduce a dialog popup box, useful for asking the user to confirm a decision or to provide information.
+Pour obtenir certaines des fonctionnalités les plus avancées de **pyqt** nous devons commencer par chercher à construire des éléments supplémentaires.
+Ici nous voyons comment introduire une boîte de dialogue popup, utile pour demander une confirmation à un utilisateur ou fournir des informations.
 
 ```Python 
 import sys
@@ -56,27 +56,27 @@ from PyQt4.QtCore import *
 def window():
     app = QApplication(sys.argv)
     w = QWidget()
-    # Create a button and attach to widget w
+    # Creation d'un bouton attaché au widget w
     b = QPushButton(w)
     b.setText("Press me")
     b.move(50, 50)
-    # Tell b to call this function when clicked
-    # notice the lack of "()" on the function call
+    # Dire à b d'appeler cette fonction quand il est cliqué
+    # remarquez l'absence de "()" sur l'appel de la fonction
     b.clicked.connect(showdialog)
     w.setWindowTitle("PyQt Dialog")
     w.show()
     sys.exit(app.exec_())
 	
-# This function should create a dialog window with a button
-# that waits to be clicked and then exits the program
+# Cette fonction devrait créer une fenêtre de dialogue avec un bouton
+# qui attend d'être cliqué puis quitte le programme
 def showdialog():
     d = QDialog()
     b1 = QPushButton("ok", d)
     b1.move(50, 50)
     d.setWindowTitle("Dialog")
-    # This modality tells the popup to block the parent whilst it's active
+    # Cette "Modality" dit au popup de bloquer le parent pendant qu'il est actif
     d.setWindowModality(Qt.ApplicationModal)
-    # On click I'd like the entire process to end
+    # En cliquant je voudrais que tout le processus se termine
     b1.clicked.connect(sys.exit)
     d.exec_()
 
-- 
cgit v1.2.3


From 305e08b9594b65a3f0a62920e6ad165a9d861ce9 Mon Sep 17 00:00:00 2001
From: DevHugo <hugo.contactpro@gmail.com>
Date: Mon, 10 Sep 2018 11:54:47 +0200
Subject: Update pyqt-fr.html.markdown

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

(limited to 'fr-fr')

diff --git a/fr-fr/pyqt-fr.html.markdown b/fr-fr/pyqt-fr.html.markdown
index 870a2c4e..6da9a380 100644
--- a/fr-fr/pyqt-fr.html.markdown
+++ b/fr-fr/pyqt-fr.html.markdown
@@ -74,7 +74,7 @@ def showdialog():
     b1 = QPushButton("ok", d)
     b1.move(50, 50)
     d.setWindowTitle("Dialog")
-    # Cette "Modality" dit au popup de bloquer le parent pendant qu'il est actif
+    # Cette modalité dit au popup de bloquer le parent pendant qu'il est actif
     d.setWindowModality(Qt.ApplicationModal)
     # En cliquant je voudrais que tout le processus se termine
     b1.clicked.connect(sys.exit)
-- 
cgit v1.2.3


From d3335643d1709b6bf4b9c60b4b34de679b84b32b Mon Sep 17 00:00:00 2001
From: Yvan Sraka <yvan@sraka.pw>
Date: Mon, 17 Sep 2018 08:14:02 +0200
Subject: Update lambda-calculus-fr.html.markdown

---
 fr-fr/lambda-calculus-fr.html.markdown | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'fr-fr')

diff --git a/fr-fr/lambda-calculus-fr.html.markdown b/fr-fr/lambda-calculus-fr.html.markdown
index 68868830..c91f21d6 100644
--- a/fr-fr/lambda-calculus-fr.html.markdown
+++ b/fr-fr/lambda-calculus-fr.html.markdown
@@ -5,6 +5,7 @@ contributors:
     - ["Max Sun", "http://github.com/maxsun"]
 translators:
     - ["Yvan Sraka", "https://github.com/yvan-sraka"]
+lang: fr-fr
 ---
 
 # Lambda-calcul
@@ -102,4 +103,4 @@ En utilisant `S`, nous pouvons définir la fonction `ADD`:
 
 1. [A Tutorial Introduction to the Lambda Calculus](http://www.inf.fu-berlin.de/lehre/WS03/alpi/lambda.pdf)
 2. [Cornell CS 312 Recitation 26: The Lambda Calculus](http://www.cs.cornell.edu/courses/cs3110/2008fa/recitations/rec26.html)
-3. [Wikipedia - Lambda Calculus](https://en.wikipedia.org/wiki/Lambda_calculus)
\ No newline at end of file
+3. [Wikipedia - Lambda Calculus](https://en.wikipedia.org/wiki/Lambda_calculus)
-- 
cgit v1.2.3


From 4b9c35047b54d4e886011cffd4adce015584f846 Mon Sep 17 00:00:00 2001
From: Divay Prakash <divayprakash3@gmail.com>
Date: Sun, 14 Oct 2018 05:33:23 +0530
Subject: Fix links and list styling

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

(limited to 'fr-fr')

diff --git a/fr-fr/c++-fr.html.markdown b/fr-fr/c++-fr.html.markdown
index acbaed58..8cd494e8 100644
--- a/fr-fr/c++-fr.html.markdown
+++ b/fr-fr/c++-fr.html.markdown
@@ -910,7 +910,5 @@ v.swap(vector<Foo>());
 ```
 Lecture complémentaire :
 
-Une référence à jour du langage est disponible à
-<http://cppreference.com/w/cpp>
-
-Des ressources supplémentaires sont disponibles à <http://cplusplus.com>
+* Une référence à jour du langage est disponible à [CPP Reference](http://cppreference.com/w/cpp).
+* Des ressources supplémentaires sont disponibles à [CPlusPlus](http://cplusplus.com).
-- 
cgit v1.2.3


From 99618d394e33c51ed8073b2dc013623442201c51 Mon Sep 17 00:00:00 2001
From: Divay Prakash <divayprakash3@gmail.com>
Date: Sun, 14 Oct 2018 05:51:14 +0530
Subject: Add new link from 2242ad7

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

(limited to 'fr-fr')

diff --git a/fr-fr/c++-fr.html.markdown b/fr-fr/c++-fr.html.markdown
index 8cd494e8..863162f7 100644
--- a/fr-fr/c++-fr.html.markdown
+++ b/fr-fr/c++-fr.html.markdown
@@ -912,3 +912,4 @@ Lecture complémentaire :
 
 * Une référence à jour du langage est disponible à [CPP Reference](http://cppreference.com/w/cpp).
 * Des ressources supplémentaires sont disponibles à [CPlusPlus](http://cplusplus.com).
+* Un tutoriel couvrant les bases du langage et la configuration d'un environnement de codage est disponible à l'adresse [TheChernoProject - C ++](https://www.youtube.com/playlist?list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb).
-- 
cgit v1.2.3


From 3359cb0a20d96ad9507e12bbabd7744920d26c28 Mon Sep 17 00:00:00 2001
From: Divay Prakash <divayprakash3@gmail.com>
Date: Sun, 14 Oct 2018 06:04:13 +0530
Subject: Fix links

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

(limited to 'fr-fr')

diff --git a/fr-fr/dynamic-programming-fr.html.markdown b/fr-fr/dynamic-programming-fr.html.markdown
index b3660ac9..54cca001 100644
--- a/fr-fr/dynamic-programming-fr.html.markdown
+++ b/fr-fr/dynamic-programming-fr.html.markdown
@@ -42,9 +42,9 @@ Le même concept peut être appliqué pour trouver le chemin le plus long dans u
 
 ### Problèmes classiques de programmation dynamique
 
-- L'algorithme de Floyd Warshall(EN)) - Tutorial and C Program source code:http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code
-- Problème du sac à dos(EN) - Tutorial and C Program source code: http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem
-- Plus longue sous-chaîne commune(EN) - Tutorial and C Program source code : http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence
+- L'algorithme de Floyd Warshall(EN) - Tutorial and C Program source code: [http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code]()
+- Problème du sac à dos(EN) - Tutorial and C Program source code: [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem]()
+- Plus longue sous-chaîne commune(EN) - Tutorial and C Program source code : [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence]()
 
 ## Online Resources
 
-- 
cgit v1.2.3


From 8b6e7fb9e3883686ed0cdf959ede065c72645f60 Mon Sep 17 00:00:00 2001
From: Vincent Chafouin <vincent@chafou.in>
Date: Tue, 16 Oct 2018 20:45:28 +0300
Subject: Update markdown-fr-html.mardown

* Fix issue #2864
* Fix formatting
* Fix ruby code snippet
* Fix translation
* Add missing keyboard keys section
---
 fr-fr/markdown-fr.html.markdown | 294 +++++++++++++++++++++++++---------------
 1 file changed, 188 insertions(+), 106 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/markdown-fr.html.markdown b/fr-fr/markdown-fr.html.markdown
index 8518f35c..2955fd14 100644
--- a/fr-fr/markdown-fr.html.markdown
+++ b/fr-fr/markdown-fr.html.markdown
@@ -6,52 +6,69 @@ filename: markdown-fr.md
 lang: fr-fr
 ---
 
+
 Markdown a été créé par John Gruber en 2004. Il se veut être d'une syntaxe
-facile à lire et à écrire, aisément convertible en HTML
- (et beaucoup d'autres formats aussi à présent).
+facile à lire et à écrire, aisément convertible en HTML (et dans beaucoup
+d'autres formats aussi).
+
+Les implémentations du Markdown varient d'un analyseur syntaxique à un autre.
+Ce guide va essayer de clarifier quand une fonctionnalité est universelle ou
+quand elle est specifique à un certain analyseur syntaxique.
+
+- [Balises HTML](#balises-html)
+- [En-têtes](#en-tetes)
+- [Styles de texte basiques](#style-de-text-basiques)
+- [Paragraphes](#paragraphes)
+- [Listes](#listes)
+- [Blocs de code](#blocs-de-code)
+- [Séparateur horizontal](#separateur-horizontal)
+- [Liens hypertextes](#liens-hypertextes)
+- [Images](#images)
+- [Divers](#divers)
 
-Faites moi autant de retours que vous voulez! Sentez vous libre de "forker" 
-et envoyer des pull request!
+## Balises HTML
 
+Markdown est un sur-ensemble du HTML, donc tout fichier HTML est un ficher
+Markdown valide.
 
 ```md
-<!-- Markdown est une sorte de cousin du HTML, si bien que tout document HTML 
-est un document Markdown valide. Autrement dit, vous pouvez utiliser des 
-balises HTML dans un fichier Markdown, comme la balise commentaire dans 
-laquelle nous sommes à présent, car celle-ci ne sera pas affectée par 
-le parser( analyseur syntaxique ) Markdown. -->
+<!-- Ce qui veut dire que vous pouvez utiliser des balises HTML dans un fichier
+Markdown, comme la balise commentaire dans laquelle nous sommes à présent, car
+celle-ci ne sera pas affectée par l'analyseur syntaxique du Markdown.
+Toutefois, si vous voulez créer une balise HTML dans un fichier Markdown,
+vous ne pourrez pas utiliser du Markdown à l'intérieur de cette derniere. -->
+```
 
-<!-- Toutefois, si vous voulez créer un élément HTML dans un fichier Markdown,
- vous ne pourrez pas utiliser du Markdown à l'intérieur de ce dernier. -->
+## En-têtes
 
-<!--  Le Markdown est implémenté de différentes manières, selon le parser. 
-Ce guide va alors tenter de trier les fonctionnalités universelles de celles
-spécifiques à un parser.  -->
+Vous pouvez facilement créer des balises HTML `<h1>` à `<h6>` en précédant le
+texte de votre futur titre par un ou plusieurs dièses ( # ), de un à six, selon
+le niveau de titre souhaité.
 
-<!-- Headers ( En-têtes ) -->
-<!-- Vous pouvez facilement créer des éléments HTML <h1> à <h6> en précédant
- le texte de votre futur titre par un ou plusieurs dièses ( # ), de un à six,
-  selon le niveau de titre souhaité. -->
+```md
 # Ceci est un <h1>
 ## Ceci est un <h2>
 ### Ceci est un <h3>
 #### Ceci est un <h4>
 ##### Ceci est un <h5>
 ###### Ceci est un <h6>
+```
 
-<!-- 
-Markdown fournit également une façon alternative de marquer les h1 et h2 
--->
+Markdown fournit également une façon alternative de marquer les h1 et h2.
 
+```md
 Ceci est un h1
 =============
 
 Ceci est un h2
 -------------
+```
+
+## Styles de texte basiques
 
-<!-- Styles basiques pour du texte -->
-<!-- On peut facilement rendre un texte "gras" ou "italique" en Markdown -->
+On peut facilement rendre un texte "gras" ou "italique" en Markdown.
 
+```md
 *Ce texte est en italique.*
 _Celui-ci aussi._
 
@@ -61,15 +78,21 @@ __Celui-là aussi.__
 ***Ce texte a les deux styles.***
 **_Pareil ici_**
 *__Et là!__*
+```
 
-<!-- Dans le "GitHub Flavored Markdown", utilisé pour interpréter le Markdown 
-sur GitHub, on a également le strikethrough ( texte barré ) : -->
+Dans le "GitHub Flavored Markdown", utilisé pour interpréter le Markdown sur
+GitHub, on a également le texte barré.
 
-~~Ce texte est barré avec strikethrough.~~
+```md
+~~Ce texte est barré.~~
+```
+
+## Paragraphes
 
-<!--  Les Paragraphes sont représentés par une ou plusieurs lignes de texte 
-séparées par une ou plusieurs lignes vides. -->
+Les paragraphes sont représentés par une ou plusieurs lignes de texte séparées
+par une ou plusieurs lignes vides.
 
+```md
 Ceci est un paragraphe. Là, je suis dans un paragraphe, facile non?
 
 Maintenant je suis dans le paragraphe 2.
@@ -77,21 +100,23 @@ Je suis toujours dans le paragraphe 2!
 
 
 Puis là, eh oui, le paragraphe 3!
+```
 
-<!--  
-Si jamais vous souhaitez insérer une balise HTML <br />, vous pouvez ajouter 
-un ou plusieurs espaces à la fin de votre paragraphe, et en commencer 
-un nouveau.
--->
+Si jamais vous souhaitez insérer une balise HTML `<br />`, vous pouvez ajouter
+un ou plusieurs espaces à la fin de votre paragraphe, et en commencer un
+nouveau.
 
-J'ai deux espaces vides à la fin (sélectionnez moi pour les voir). 
+```md
+J'ai deux espaces vides à la fin (sélectionnez moi pour les voir).
 
 Bigre, il y a un <br /> au dessus de moi!
+```
 
-<!-- Les 'Blocs de Citations' sont générés aisément, grâce au caractère > -->
+Les blocs de citations sont générés aisément, grâce au caractère >.
 
+```md
 > Ceci est une superbe citation. Vous pouvez même
-> revenir à la ligne quand ça vous chante, et placer un `>` 
+> revenir à la ligne quand ça vous chante, et placer un `>`
 > devant chaque bout de ligne faisant partie
 > de la citation.
 > La taille ne compte pas^^ tant que chaque ligne commence par un `>`.
@@ -99,191 +124,248 @@ Bigre, il y a un <br /> au dessus de moi!
 > Vous pouvez aussi utiliser plus d'un niveau
 >> d'imbrication!
 > Classe et facile, pas vrai?
+```
+
+## Listes
 
-<!-- les Listes -->
-<!-- les Listes non ordonnées sont marquées par des asterisques, 
-signes plus ou signes moins. -->
+Les listes non ordonnées sont marquées par des asterisques, signes plus ou
+signes moins.
 
+```md
 * Item
 * Item
 * Un autre item
+```
 
 ou
 
+```md
 + Item
 + Item
 + Encore un item
+```
 
 ou
 
+```md
 - Item
 - Item
 - Un dernier item
+```
 
-<!-- les Listes Ordonnées sont générées via un nombre suivi d'un point -->
+Les listes ordonnées sont générées via un nombre suivi d'un point.
 
+```md
 1. Item un
 2. Item deux
 3. Item trois
+```
 
-<!-- Vous pouvez même vous passer de tout numéroter, et Markdown générera 
-les bons chiffres. Ceci dit, cette variante perd en clarté.-->
+Vous pouvez même vous passer de tout numéroter, et Markdown générera les bons
+chiffres. Ceci dit, cette variante perd en clarté.
 
+```md
 1. Item un
 1. Item deux
 1. Item trois
-<!-- ( cette liste sera interprétée de la même façon que celle au dessus ) -->
+```
 
-<!-- Vous pouvez également utiliser des sous-listes -->
+(Cette liste sera interprétée de la même façon que celle au dessus)
 
+Vous pouvez également utiliser des sous-listes.
+
+```md
 1. Item un
 2. Item deux
 3. Item trois
 * Sub-item
 * Sub-item
 4. Item quatre
+```
 
-<!-- Il y a même des "listes de Taches". Elles génèrent des champs HTML 
-de type checkbox. -->
-
-Les [ ] ci dessous, n'ayant pas de [ x ], 
-deviendront des cases à cocher HTML non-cochées.
+Il y a même des listes de taches. Elles génèrent des champs HTML de type case à
+cocher.
 
+```md
+Les [ ] ci-dessous, n'ayant pas de [ x ], deviendront des cases à cocher HTML
+non-cochées.
 - [ ] Première tache à réaliser.
 - [ ] Une autre chose à faire.
 La case suivante sera une case à cocher HTML cochée.
 - [x] Ça ... c'est fait!
+```
+
+## Blocs de code
 
-<!-- les Blocs de Code -->
-<!-- Pour marquer du texte comme étant du code, il suffit de commencer 
-chaque ligne en tapant 4 espaces (ou un Tab) -->
+Pour marquer du texte comme étant du code (qui utilise la balise `<code>`), il
+suffit d'indenter chaque ligne avec 4 espaces ou une tabulation.
 
+```md
     echo "Ça, c'est du Code!";
     var Ça = "aussi !";
+```
 
-<!-- L'indentation par tab ou série de quatre espaces 
-fonctionne aussi à l'intérieur du bloc de code -->
+L'indentation par tabulation (ou série de quatre espaces) fonctionne aussi à
+l'intérieur du bloc de code.
 
+```md
     my_array.each do |item|
        puts item
     end
+```
 
-<!-- Des bouts de code en mode 'inline' s'ajoutent en les entourant de ` -->
+Des bouts de code en mode en ligne s'ajoutent en utilisant le caractères
+`` ` ``.
 
+```md
 La fonction `run()` ne vous oblige pas à aller courir!
+```
 
-<!-- Via GitHub Flavored Markdown, vous pouvez utiliser 
-des syntaxes spécifiques -->
+En "GitHub Flavored Markdown", vous pouvez utiliser des syntaxes spécifiques
+selon le language.
 
-\`\`\`ruby 
-<!-- mais enlevez les backslashes quand vous faites ça, 
-gardez juste ```ruby ( ou nom de la syntaxe correspondant à votre code )-->
+<pre>
+<code class="highlight">&#x60;&#x60;&#x60;ruby
 def foobar
-puts "Hello world!"
+    puts "Hello world!"
 end
-\`\`\` <!-- pareil, pas de backslashes, juste ``` en guise de fin -->
+&#x60;&#x60;&#x60;</code>
+</pre>
 
-<-- Pas besoin d'indentation pour le code juste au dessus, de plus, GitHub 
-va utiliser une coloration syntaxique pour le langage indiqué après les ``` -->
+Pas besoin d'indentation pour le code juste au dessus, de plus, GitHub va
+utiliser une coloration syntaxique pour le langage indiqué après les \`\`\`.
 
-<!-- Ligne Horizontale (<hr />) -->
-<!-- Pour en insérer une, utilisez trois ou plusieurs astérisques ou tirets, 
-avec ou sans espaces entre chaque un. -->
+## Séparateur horizontal
 
+La balise `<hr/>` peut être aisement ajoutée en utilisant trois ou plus
+astérisques ou tirets, avec ou sans espaces entre chacun.
+
+```md
 ***
 ---
 - - -
 ****************
+```
 
-<!-- Liens -->
-<!-- Une des fonctionnalités sympathiques du Markdown est la facilité 
-d'ajouter des liens. Le texte du lien entre [ ], l'url entre ( ), 
-et voilà l'travail.
--->
+## Liens hypertextes
 
+Une des fonctionnalités sympathiques du Markdown est la facilité d'ajouter des
+liens hypertextes. Le texte du lien entre crochet `` [] ``, l'url entre
+parenthèses `` () ``, et voilà le travail.
+
+```md
 [Clic moi!](http://test.com/)
+```
 
-<!-- 
-Pour ajouter un attribut Title, collez le entre guillemets, avec le lien. 
--->
+Pour ajouter un attribut titre, ajoutez le entre les parenthèses entre
+guillemets apres le lien.
 
+```md
 [Clic moi!](http://test.com/ "Lien vers Test.com")
+```
 
-<!-- les Liens Relatifs marchent aussi -->
+Markdown supporte aussi les liens relatifs.
 
+```md
 [En avant la musique](/music/).
+```
 
-<!-- Les liens façon "références" sont eux aussi disponibles en Markdown -->
+Les liens de références sont eux aussi disponibles en Markdown.
 
+```md
 [Cliquez ici][link1] pour plus d'information!
 [Regardez aussi par ici][foobar] si vous voulez.
 
 [link1]: http://test.com/ "Cool!"
-[foobar]: http://foobar.biz/ "Alright!"
+[foobar]: http://foobar.biz/ "Génial!"
+```
 
-<!--  Le titre peut aussi être entouré de guillemets simples, 
-entre parenthèses ou absent. Les références peuvent être placées 
-un peu où vous voulez dans le document, et les identifiants 
-(link1, foobar, ...) quoi que ce soit tant qu'ils sont uniques -->
+Le titre peut aussi être entouré de guillemets simples, ou de parenthèses, ou
+absent. Les références peuvent être placées où vous voulez dans le document et
+les identifiants peuvent être n'importe quoi tant qu'ils sont uniques.
 
-<!-- Il y a également le "nommage implicite" qui transforme le texte du lien
- en identifiant -->
+Il y a également le nommage implicite qui transforme le texte du lien en
+identifiant.
 
+```md
 [Ceci][] est un lien.
 
 [ceci]: http://ceciestunlien.com/
+```
+
+Mais ce n'est pas beaucoup utilisé.
 
-<!-- mais ce n'est pas beaucoup utilisé. -->
+## Images
 
-<!-- Images -->
-<!-- Pour les images, la syntaxe est identique aux liens, sauf que précédée
- d'un point d'exclamation! -->
+Pour les images, la syntaxe est identique à celle des liens, sauf que précédée
+d'un point d'exclamation!
 
+```md
 ![Attribut ALT de l'image](http://imgur.com/monimage.jpg "Titre optionnel")
+```
 
-<!-- Là aussi, on peut utiliser le mode "références" -->
+Là aussi, on peut utiliser les références.
 
+```md
 ![Ceci est l'attribut ALT de l'image][monimage]
 
 [monimage]: relative/urls/cool/image.jpg "si vous voulez un titre, c'est ici."
+```
+
+## Divers
 
-<!-- Divers -->
-<!-- Liens Automatiques -->
+### Liens hypertextes automatiques
 
+```md
 <http://testwebsite.com/> est équivalent à :
 [http://testwebsite.com/](http://testwebsite.com/)
+```
 
-<!-- Liens Automatiques pour emails -->
+### Liens hypertextes automatiques pour emails
 
+```md
 <foo@bar.com>
+```
+
+### Caracteres d'echappement
 
-<!-- Escaping -->
 Il suffit de précéder les caractères spécifiques à ignorer par des backslash \
 
-Pour taper *ce texte* entouré d'astérisques mais pas en italique : 
+```md
+Pour taper *ce texte* entouré d'astérisques mais pas en italique :
 Tapez \*ce texte\*.
+```
+
+### Touches de clavier
 
-<!-- Tableaux -->
-<!-- les Tableaux ne sont disponibles que dans le GitHub Flavored Markdown
- et c'est ce n'est pas super agréable d'utilisation. 
- Mais si vous en avez besoin :
- -->
+Avec le "Github Flavored Markdown", vous pouvez utiliser la balise `<kdb>`
+pour représenter une touche du clavier.
 
+```md
+Ton ordinateur a planté? Essayer de taper :
+<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
+```
+
+### Tableaux
+
+Les tableaux ne sont disponibles que dans le "GitHub Flavored Markdown" et
+ne sont pas tres agréable d'utilisation. Mais si vous en avez besoin :
+
+```md
 | Col1 | Col2 | Col3 |
 | :----------- | :------: | ------------: |
 | Alignement Gauche | Centé | Alignement Droite |
 | bla | bla | bla |
+```
 
-<!-- ou bien, pour un résultat équivalent : -->
+ou bien, pour un résultat équivalent :
 
+```md
 Col 1 | Col2 | Col3
 :-- | :-: | --:
 Ough que c'est moche | svp | arrêtez
-
-<!-- Fin! -->
-
 ```
 
-Pour plus d'information :
- consultez [ici](http://daringfireball.net/projects/markdown/syntax) le post officiel de Jhon Gruber à propos de la syntaxe, 
- et [là](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) la superbe cheatsheet de Adam Pritchard.
+Pour plus d'information, consultez le post officiel de Jhon Gruber à propos de
+la syntaxe [ici](http://daringfireball.net/projects/markdown/syntax) et la
+superbe fiche pense-bête de Adam Pritchard [là](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
-- 
cgit v1.2.3


From 3027bf2c3030aa5277f8e14c8bd5f9fb753faf97 Mon Sep 17 00:00:00 2001
From: LukaxFeh <outrolucas2002@gmail.com>
Date: Tue, 30 Oct 2018 23:29:14 -0300
Subject: [Dynamic programmimg-DE/DE]

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

(limited to 'fr-fr')

diff --git a/fr-fr/dynamic-programming-fr.html.markdown b/fr-fr/dynamic-programming-fr.html.markdown
index 54cca001..0a22b58b 100644
--- a/fr-fr/dynamic-programming-fr.html.markdown
+++ b/fr-fr/dynamic-programming-fr.html.markdown
@@ -42,9 +42,9 @@ Le même concept peut être appliqué pour trouver le chemin le plus long dans u
 
 ### Problèmes classiques de programmation dynamique
 
-- L'algorithme de Floyd Warshall(EN) - Tutorial and C Program source code: [http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code]()
-- Problème du sac à dos(EN) - Tutorial and C Program source code: [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem]()
-- Plus longue sous-chaîne commune(EN) - Tutorial and C Program source code : [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence]()
+- [L'algorithme de Floyd Warshall(EN) - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code])
+- [Problème du sac à dos(EN) - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem)
+- [Plus longue sous-chaîne commune(EN) - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence)
 
 ## Online Resources
 
-- 
cgit v1.2.3


From d553a02345298eabe3eb5e567bdc478dff773c81 Mon Sep 17 00:00:00 2001
From: LukaxFeh <outrolucas2002@gmail.com>
Date: Wed, 31 Oct 2018 18:10:03 -0300
Subject: [Dynamic programming - FR/FR] Fixed links

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

(limited to 'fr-fr')

diff --git a/fr-fr/dynamic-programming-fr.html.markdown b/fr-fr/dynamic-programming-fr.html.markdown
index 0a22b58b..ea547dae 100644
--- a/fr-fr/dynamic-programming-fr.html.markdown
+++ b/fr-fr/dynamic-programming-fr.html.markdown
@@ -42,7 +42,7 @@ Le même concept peut être appliqué pour trouver le chemin le plus long dans u
 
 ### Problèmes classiques de programmation dynamique
 
-- [L'algorithme de Floyd Warshall(EN) - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code])
+- [L'algorithme de Floyd Warshall(EN) - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code)
 - [Problème du sac à dos(EN) - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem)
 - [Plus longue sous-chaîne commune(EN) - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence)
 
-- 
cgit v1.2.3


From 89ff5da650d616651e9b291a09cabf17b9382c06 Mon Sep 17 00:00:00 2001
From: Antoine Braut <antoine.braut@gmail.com>
Date: Fri, 11 Jan 2019 11:27:25 +0100
Subject: Correcting missing 'r'
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Line 353 the word `centré` was write `centé`
---
 fr-fr/markdown-fr.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'fr-fr')

diff --git a/fr-fr/markdown-fr.html.markdown b/fr-fr/markdown-fr.html.markdown
index b3b7de85..26c2546a 100644
--- a/fr-fr/markdown-fr.html.markdown
+++ b/fr-fr/markdown-fr.html.markdown
@@ -350,7 +350,7 @@ ne sont pas tres agréable d'utilisation. Mais si vous en avez besoin :
 ```md
 | Col1 | Col2 | Col3 |
 | :----------- | :------: | ------------: |
-| Alignement Gauche | Centé | Alignement Droite |
+| Alignement Gauche | Centré | Alignement Droite |
 | bla | bla | bla |
 ```
 
-- 
cgit v1.2.3


From 9b5b5f6d31b64be55e64c5f45084e45115f2f350 Mon Sep 17 00:00:00 2001
From: Anindya Srivastava <pro.anindya@gmail.com>
Date: Wed, 6 Feb 2019 07:26:25 +0530
Subject: Type correction for the output of math.sqrt() propagated across
 versions and languages

---
 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 d78291be..0ae410de 100644
--- a/fr-fr/python-fr.html.markdown
+++ b/fr-fr/python-fr.html.markdown
@@ -444,7 +444,7 @@ Human.grunt() #=> "*grunt*"
 
 # On peut importer des modules
 import math
-print math.sqrt(16) #=> 4
+print math.sqrt(16) #=> 4.0
 
 # Et récupérer des fonctions spécifiques d'un module
 from math import ceil, floor
-- 
cgit v1.2.3


From 77310658c8201f0193adb2ac4eb55a6093923243 Mon Sep 17 00:00:00 2001
From: GannonTdW <32203939+GannonTdW@users.noreply.github.com>
Date: Sat, 2 Mar 2019 23:48:17 +0100
Subject: [awk/fr] add awk-fr.html.markdown (#3482)

* add awk-fr.html.markdown

* correction of an oversight

* it's done

* vendethiel review (1/2)

* vendethiel review (2/2)

* vendethiel review (3)
---
 fr-fr/awk-fr.html.markdown | 376 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 376 insertions(+)
 create mode 100644 fr-fr/awk-fr.html.markdown

(limited to 'fr-fr')

diff --git a/fr-fr/awk-fr.html.markdown b/fr-fr/awk-fr.html.markdown
new file mode 100644
index 00000000..750703f4
--- /dev/null
+++ b/fr-fr/awk-fr.html.markdown
@@ -0,0 +1,376 @@
+---
+language: awk
+filename: learnawk-fr.awk
+contributors:
+     - ["Marshall Mason", "http://github.com/marshallmason"]
+translators:
+    - ["GannonTdW", "https://github.com/GannonTdW"]
+lang: fr-fr
+
+---
+
+AWK est un outil standard présent dans chaque système UNIX conforme aux normes POSIX.
+C’est un outil en ligne de commande qui ressemble au Perl et qui est excellent dans les tâches de traitement de fichiers texte.
+Vous pouvez l’appeler à partir d’un script shell, ou l’utiliser comme un langage de script autonome.
+
+Pourquoi utiliser AWK au lieu du langage Perl ?
+Principalement, car AWK fait partie d'UNIX et est donc présent par défaut sur une très grande partie des systèmes d'exploitation UNIX et Linux. 
+AWK est aussi plus facile à lire que le langage Perl ; et est l'outil idéal pour ce qui concerne le traitement de texte simple. Notamment le traitement de ceux qui necéssitent de lire des fichiers ligne par ligne ; chaque ligne comportant des champs séparés par des délimiteur.
+
+
+```awk
+#!/usr/bin/awk -f
+
+# Les commentaires commencent par un #
+
+
+# les programmes AWK consistent en une collection de règles et d'actions
+règle1 { action; }
+règle2 { action; }
+
+# AWK lit et analyse automatiquement chaque ligne de chaque fichier fourni.
+# Chaque ligne est divisée par un délimiteur FS qui est par défaut l'espace (plusieurs espaces ou une tabulation comptent pour un espace). Ce délimiteur peut être changer grâce à l'option -F ou être renseigné au début d'un bloc (exemple: FS = " ").
+
+# BEGIN est une règle spécifique exécutée au début du programme. C'est à cet endroit que vous mettrez tout le code à exécuter avant de traiter les fichiers texte. Si vous ne disposez pas de fichiers texte, considérez BEGIN comme le point d’entrée principal du script.
+# A l'opposé de BEGIN, il existe la règle END. Cette règle est présente après chaque fin de fichier (EOF : End Of File).
+
+BEGIN {
+
+    # Les variables sont globales. Pas besoin de les déclarer.
+    count = 0;
+
+    # les opérateurs sont identiques au langage C et aux langages similaires (exemple: C#, C++)
+    a = count + 1; # addition
+    b = count - 1; # soustraction
+    c = count * 1; # multiplication
+    d = count / 1; # division entière
+    e = count % 1; # modulo, reste de la division entière
+    f = count ^ 1; # exponentiel
+
+    a += 1;
+    b -= 1;
+    c *= 1;
+    d /= 1;
+    e %= 1;
+    f ^= 1;
+
+    # Incrémenter et décrémenter par un
+    a++;
+    b--;
+
+    # En tant qu'opérateur préfixé, c'est la valeur incrémentée qui est retournée
+    ++a;
+    --b;
+
+    # Instruction de contrôle
+    if (conteur == 0)
+        print "Nombre de départ 0";
+    else
+        print "Hein?";
+
+    # Vous pouvez aussi utiliser l'opérateur ternaire
+    print (compteur == 0) ? "Nombre de départ 0" : "Hein?";
+
+    # Les blocs sont composés d'une multitude de lignes entre accolades
+    while (a < 10) {
+        print "La concaténation de chaînes de caractères" " se fait avec des séries de chaînes "    " séparées par des espaces";
+        print a;
+
+        a++;
+    }
+
+    for (i = 0; i < 10; i++)
+        print "le bon vieux for pour les boucles";
+
+    # Les opérateurs de comparaison sont standard
+    # a < b   # plus petit que
+    # a <= b  # plus petit ou égale à
+    # a != b  # non égale
+    # a == b  # égale
+    # a > b   # Plus grand que
+    # a >= b  # Plus grand ou égale à
+
+    # Les opérateurs logiques sont
+    # a && b  # ET
+    # a || b  # OU
+
+    # En plus, il y a les expressions régulières
+    if ("foo" ~ "^fo+$")
+        print "Fooey!";
+    if ("boo" !~ "^fo+$")
+        print "Boo!";
+
+    # Les Tableaux
+    arr[0] = "foo";
+    arr[1] = "bar";
+
+    # Vous pouvez aussi initialiser un tableau avec la fonction split()
+
+    n = split("foo:bar:baz", arr, ":");
+
+    # Il y a aussi les tableaux associatifs
+    assoc["foo"] = "bar";
+    assoc["bar"] = "baz";
+
+    # et les tableaux multi-dimentions, avec certaines limitations que l'on ne mentionnera pas ici
+    multidim[0,0] = "foo";
+    multidim[0,1] = "bar";
+    multidim[1,0] = "baz";
+    multidim[1,1] = "boo";
+
+    # Vous pouvez tester l'appartenance à un tableau
+    if ("foo" in assoc)
+        print "Fooey!";
+
+    # Vous pouvez aussi utilisez l'opérateur 'in' pour parcourir les clés d'un tableau
+    for (key in assoc)
+        print assoc[key];
+
+    # La ligne de commande est dans un tableau spécifique appelé ARGV
+    for (argnum in ARGV)
+        print ARGV[argnum];
+
+    # Vous pouvez supprimer des éléments d'un tableau
+    # C'est utile pour empêcher AWK de supposer que certains arguments soient des fichiers à traiter.
+    delete ARGV[1];
+
+    # Le nombre d'arguments de la ligne de commande est dans une variable appellée ARGC
+    print ARGC;
+
+    # AWK inclue trois catégories de fonction.
+    # On les examinera plus tard
+
+    return_value = arithmetic_functions(a, b, c);
+    string_functions();
+    io_functions();
+}
+
+# Voici comment définir une fonction
+function arithmetic_functions(a, b, c,     d) {
+
+    # La partie la plus ennuieuse de AWK est probablement l’absence de variables locales.
+    # Tout est global. Pour les scripts courts, c'est très utile, mais pour les scripts plus longs,
+    # cela peut poser problème.
+
+    # Il y a cepandant une solution de contournement (enfin ... une bidouille).
+    # Les arguments d'une fonction sont locaux à cette fonction.
+    # Et AWK vous permet de définir plus d'arguments à la fonction que nécessaire.
+    # Il suffit donc de mettre une variable locale dans la déclaration de fonction,
+    # comme ci-dessus. La convention veut que vous mettiez quelques espaces supplémentaires
+    # pour faire la distinction entre les paramètres réels et les variables locales.
+    # Dans cet exemple, a, b et c sont des paramètres réels,
+    # alors que d est simplement une variable locale.
+
+    # Maintenant, les fonctions arithmétiques
+
+    # La plupart des implémentations de AWK ont des fonctions trigonométriques standards
+    localvar = sin(a);
+    localvar = cos(a);
+    localvar = atan2(b, a); # arc tangente de b / a
+
+    # Les exponentiels et logarithmes décimaux sont aussi là
+    localvar = exp(a);
+    localvar = log(a);
+
+    # Les racines carrées
+    localvar = sqrt(a);
+
+    # Tronquer un nombre décimal en nombre entier
+    localvar = int(5.34); # localvar => 5
+
+    # Les nombres aléatoires
+    srand(); 
+    # L'argument de la fonction srand() est la valeur de départ pour générer
+    # les nombres aléatoires . Par défaut, il utilise l'heure du système
+    
+    localvar = rand(); # Nombre aléatoire entre 0 et 1.
+
+    # Maintenant on retourne la valeur
+    return localvar;
+}
+
+function string_functions(    localvar, arr) {
+
+    # AWK a plusieurs fonctions pour le traitement des chaînes de caractères,
+    # dont beaucoup reposent sur des expressions régulières.
+
+    # Chercher et remplacer, la première occurence (sub) ou toutes les occurences (gsub)
+    # Les deux renvoient le nombre de correspondances remplacées
+    localvar = "fooooobar";
+    sub("fo+", "Meet me at the ", localvar); # localvar => "Meet me at the bar"
+    gsub("e+", ".", localvar); # localvar => "m..t m. at th. bar"
+
+    # Rechercher une chaîne de caractères qui correspond à une expression régulière
+    # index() fait la même chose, mais n'autorise pas les expressions régulières
+    match(localvar, "t"); # => 4, puisque 't' est le quatrième caractère
+
+    # Séparer par un délimiteur
+    n = split("foo-bar-baz", arr, "-"); # a[1] = "foo"; a[2] = "bar"; a[3] = "baz"; n = 3
+
+    # Autre astuces utiles
+    sprintf("%s %d %d %d", "Testing", 1, 2, 3); # => "Testing 1 2 3"
+    substr("foobar", 2, 3); # => "oob"
+    substr("foobar", 4); # => "bar"
+    length("foo"); # => 3
+    tolower("FOO"); # => "foo"
+    toupper("foo"); # => "FOO"
+}
+
+function io_functions(    localvar) {
+
+    # Vous avez déjà vu print
+    print "Hello world";
+
+    # Mais il y a aussi printf
+    printf("%s %d %d %d\n", "Testing", 1, 2, 3);
+
+    # AWK n'a pas de descripteur de fichier en soi. Il ouvrira automatiquement
+    # un descripteur de fichier lorsque vous utilisez quelque chose qui en a besoin.
+    # La chaîne de caractères que vous avez utilisée pour cela peut être traitée
+    # comme un descripteur de fichier à des fins d'entrée / sortie.
+
+    outfile = "/tmp/foobar.txt";
+
+    print "foobar" > outfile;
+
+    # Maintenant, la chaîne de caractères "outfile" est un descripteur de fichier.
+    # Vous pouvez le fermer
+    close(outfile);
+
+    # Voici comment exécuter quelque chose dans le shell
+    system("echo foobar"); # => affiche foobar
+
+    # Lire quelque chose depuis l'entrée standard et la stocker dans une variable locale
+    getline localvar;
+
+    # Lire quelque chose à partir d'un pipe (encore une fois, utilisez une chaine de caractère
+    # que vous fermerez proprement)
+    "echo foobar" | getline localvar # localvar => "foobar"
+    close("echo foobar")
+
+    # Lire une ligne d'un fichier et la stocker dans une variable locale
+    infile = "/tmp/foobar.txt";
+    getline localvar < infile;
+    close(infile);
+}
+
+# Comme dit au début, AWK consiste en une collection de règles et d'actions.
+# Vous connaissez déjà les règles BEGIN et END. Les autres règles ne sont utilisées que si vous traitez 
+# des lignes à partir de fichiers ou l'entrée standard (stdin).
+# Quand vous passez des arguments à AWK, ils sont considérés comme des noms de fichiers à traiter.
+# AWK les traitera tous dans l'ordre. Voyez les comme dans à une boucle implicite,
+# parcourant les lignes de ces fichiers.
+# Ces règles et ces actions ressemblent à des instructions switch dans la boucle.
+
+/^fo+bar$/ {
+
+    # Cette action sera exécutée pour chaque ligne qui correspond à l'expression régulière,
+    # /^fo+bar$/, et sera ignorée pour toute ligne qui n'y correspond pas.
+    # Imprimons simplement la ligne:
+
+    print;
+
+    # Pas d'argument ! C'est parce que print a un défaut : $0.
+    # $0 est le nom de la ligne en cours de traitement. Il est créé automatiquement.
+
+    # Vous devinez probablement qu'il existe d'autres variables $.
+    # Chaque ligne est divisée implicitement avant que chaque action soit exécutée, comme
+    # le fait le shell. Et, comme le shell, chaque champ est accessible avec un signe dollar
+
+     # Ceci affichera les deuxième et quatrième champs de la ligne.
+    print $2, $4;
+
+    # AWK défini automatiquement beaucoup d'autres variables qui peuvent vous aider
+    # à inspecter et traiter chaque ligne. La plus importante est NF
+
+    # Affiche le nombre de champs de la ligne
+    print NF;
+
+    # Afficher le dernier champ de la ligne
+    print $NF;
+}
+
+# Chaque règle est en réalité un test conditionel. 
+
+a > 0 {
+    # Ceci s’exécutera une fois pour chaque ligne, tant que le test est positif
+}
+
+# Les expressions régulières sont également des tests conditionels.
+#Si le test de l'expression régulières n'est pas vrais alors le bloc n'est pas executé
+$0 /^fobar/ { 
+   print "la ligne commance par fobar"  
+}
+
+# Dans le cas où vous voulez tester votre chaine de caractères sur la ligne en cours de traitement
+# $0 est optionnelle.
+
+/^[a-zA-Z0-9]$/ {
+    print "La ligne courante ne contient que des caractères alphanumériques.";
+}
+
+
+# AWK peut parcourir un fichier texte ligne par ligne et exécuter des actions en fonction de règles établies
+# Cela est si courant sous UNIX qu'AWK est un langage de script.
+
+# Ce qui suit est un exemple rapide d'un petit script, pour lequel AWK est parfait.
+# Le script lit un nom à partir de l'entrée standard, puis affiche l'âge moyen de toutes les
+# personnes portant ce prénom.
+# Supposons que vous fournissiez comme argument le nom d'un fichier comportant ces données:
+#
+# Bob Jones 32
+# Jane Doe 22
+# Steve Stevens 83
+# Bob Smith 29
+# Bob Barker 72
+#
+# Le script est le suivant :
+
+BEGIN {
+
+    # Premièrement, on demande à l'utilisateur le prénom voulu
+    print "Pour quel prénom vouldriez vous savoir l'age moyen ?";
+
+    # On récupère la ligne à partir de l'entrée standard, pas de la ligne de commande
+    getline name < "/dev/stdin";
+}
+
+# Maintenant, pour chaque ligne dont le premier champ est le prénom donné
+$1 == name {
+
+    # Ici, nous avons accès à un certain nombre de variables utiles déjà préchargées :
+    # $0 est la ligne entière
+    # $3 est le troisième champ. Ici il correspond à l'age qui nous intéresse
+    # NF est le nombre de champs et vaut 3
+    # NR est le nombre d'enregistrements (lignes) vus jusqu'à présent
+    # FILENAME est le nom du fichier en cours de traitement
+    # FS est séparateur de champs, ici c'est " " (un espace)
+    # ...etc. Et beaucoup d'autre que vous pouvez connaître dans le manuel de man.
+    # Pour cela exécutez "man awk" dans votre terminal
+
+    # Garder une trace du total accumulé et du nombre de lignes correspondant.
+    sum += $3;
+    nlines++;
+}
+
+# Un autre motif spécial est END. Il fonctionnera après le traitement de tous
+# les fichiers texte. Contrairement à BEGIN, il ne fonctionne que si vous lui
+# donnez une entrée à traiter. Il sera exécuté une fois que tous les fichiers
+# auront été lus et traités conformément aux règles et aux actions que vous
+# avez fournies. Le but est généralement de produire un rapport final
+# ou de faire quelque chose avec l'ensemble des données que vous avez
+# accumulées au cours du script.
+
+
+END {
+    if (nlines)
+        print "L'age moyen pour le prénom " name " est " sum / nlines;
+}
+
+```
+Pour plus d'informations :
+
+* [Awk tutorial](http://www.grymoire.com/Unix/Awk.html)
+* [Awk man page](https://linux.die.net/man/1/awk)
+* [The GNU Awk User's Guide](https://www.gnu.org/software/gawk/manual/gawk.html) GNU Awk est dans la majorité des systèmes Linux.
+* [AWK one-liner collection](http://tuxgraphics.org/~guido/scripts/awk-one-liner.html)
-- 
cgit v1.2.3


From ed100434e33ed95e69620fc9ff6167bb130d3862 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pierre-Fran=C3=A7ois=20Clement?= <likeyn@gmail.com>
Date: Fri, 8 Mar 2019 17:18:42 +0100
Subject: Move "awk" articles to the "tool" category

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

(limited to 'fr-fr')

diff --git a/fr-fr/awk-fr.html.markdown b/fr-fr/awk-fr.html.markdown
index 750703f4..75c48811 100644
--- a/fr-fr/awk-fr.html.markdown
+++ b/fr-fr/awk-fr.html.markdown
@@ -1,5 +1,6 @@
 ---
-language: awk
+category: tool
+tool: awk
 filename: learnawk-fr.awk
 contributors:
      - ["Marshall Mason", "http://github.com/marshallmason"]
-- 
cgit v1.2.3


From 0a3207587d7a548f1691f11a7bff2bfead264026 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pierre-Fran=C3=A7ois=20Clement?= <likeyn@gmail.com>
Date: Fri, 8 Mar 2019 17:21:53 +0100
Subject: Move "make" articles to the "tool" category

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

(limited to 'fr-fr')

diff --git a/fr-fr/make-fr.html.markdown b/fr-fr/make-fr.html.markdown
index 48d24549..7b4864b5 100644
--- a/fr-fr/make-fr.html.markdown
+++ b/fr-fr/make-fr.html.markdown
@@ -1,5 +1,6 @@
 ---
-language: make
+category: tool
+tool: make
 contributors:
     - ["Robert Steed", "https://github.com/robochat"]
 translators:
-- 
cgit v1.2.3


From 9b3fc28432fcdf0970bfcc765291ae16139d7746 Mon Sep 17 00:00:00 2001
From: Alexandre Peyroux <alex@px.io>
Date: Fri, 24 May 2019 16:36:31 +0200
Subject: fix syntax

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

(limited to 'fr-fr')

diff --git a/fr-fr/erlang-fr.html.markdown b/fr-fr/erlang-fr.html.markdown
index 55453c56..1073d6ad 100644
--- a/fr-fr/erlang-fr.html.markdown
+++ b/fr-fr/erlang-fr.html.markdown
@@ -28,7 +28,7 @@ lang: fr-fr
 %% 1. Variables et filtrage par motif
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
-(L'équivalent anglais de *filtrage par motif* est *pattern patching*.)
+(L'équivalent anglais de *filtrage par motif* est *pattern matching*.)
 
 Nb = 42.  % Chaque nom de variable doit commencer par une lettre majuscule.
 
@@ -64,7 +64,7 @@ Point = {point, 10, 45}.
 {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
+% intéressent pas. Le symbole `_` 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}},
-- 
cgit v1.2.3


From f0eb830ebded612e53eef019776d6573fbc42ab0 Mon Sep 17 00:00:00 2001
From: Timothe Pardieu <timothe.pardieu@outlook.com>
Date: Wed, 9 Oct 2019 11:41:14 +0200
Subject: [elixir/fr-fr] Add french translation (#3679)

* Translate Elixir.html.markdown in french

* Add fixes in Elixir.html.markdown #3679
---
 fr-fr/elixir-fr.html.markdown | 479 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 479 insertions(+)
 create mode 100644 fr-fr/elixir-fr.html.markdown

(limited to 'fr-fr')

diff --git a/fr-fr/elixir-fr.html.markdown b/fr-fr/elixir-fr.html.markdown
new file mode 100644
index 00000000..90cdad7c
--- /dev/null
+++ b/fr-fr/elixir-fr.html.markdown
@@ -0,0 +1,479 @@
+---
+language: elixir
+contributors:
+    - ["Joao Marques", "http://github.com/mrshankly"]
+    - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+    - ["Ryan Plant", "https://github.com/ryanplant-au"]
+    - ["Ev Bogdanov", "https://github.com/evbogdanov"]
+translator:
+    - ["Timothé Pardieu", "https://github.com/timprd"]
+filename: learnelixir-fr.ex
+lang: fr-fr
+---
+Elixir est un langage de programmation fonctionnel moderne reposant sur la machine virtuelle BEAM, qui héberge aussi Erlang.
+Il est totalement compatible avec Erlang mais dispose d'une syntaxe plus agréable et apporte de nouvelles fonctionnalités. 
+
+
+```elixir
+
+# Un commentaire simple sur une seule ligne commence par un dièse.
+
+# Il n'y a pas de commentaire multi-ligne,
+# Mais il est possible de les empiler comme ici.
+
+# La commande `iex` permet de lancer le shell Elixir.
+# La commande `elixirc` permet de compiler vos modules.
+
+# Les deux devraient être dans votre path si vous avez installé Elixir correctement.
+
+## ---------------------------
+## -- Types basiques
+## ---------------------------
+
+# Il y a les nombres
+3    # Integer 
+0x1F # Integer
+3.0  # Float
+
+# Les atomes, des littéraux, qui sont des constantes avec comme valeur leur nom. 
+# Ils commencent par `:`.
+
+:hello # atom
+
+# Il existe également des n-uplets dont les valeurs sont stockés de manière contiguë 
+# en mémoire.
+
+{1,2,3} # tuple
+
+# Il est possible d'accéder à un element d'un tuple avec la fonction 
+# `elem`:
+elem({1, 2, 3}, 0) #=> 1
+
+# Les listes sont implémentées sous forme de listes chainées.
+[1,2,3] # list
+
+# La tête et le reste d'une liste peuvent être récupérés comme cela :
+[head | tail] = [1,2,3]
+head #=> 1
+tail #=> [2,3]
+
+# En Elixir, comme en Erlang, le `=` dénote un 'pattern matching' 
+# (Filtrage par motif) et non une affectation.
+# Cela signifie que la partie de gauche (pattern) est comparé (match) à 
+# la partie de droite. 
+
+
+# Une erreur sera lancée si aucun model (match) est trouvé.
+# Dans cet exemple les tuples ont des tailles différentes
+# {a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}
+
+# Il y a aussi les binaires
+<<1,2,3>> # binary
+
+# Chaine de caractères et liste de caractères
+"hello" # string
+'hello' # char list
+
+# Chaine de caractères sur plusieurs lignes
+"""
+Je suis une chaine de caractères
+sur plusieurs lignes.
+"""
+#=> "Je suis une chaine de caractères\nsur plusieurs lignes.\n"
+
+# Les chaines de caractères sont encodées en UTF-8 :
+"héllò" #=> "héllò"
+
+# Les chaines de caractères sont des binaires tandis que
+# les listes de caractères sont des listes.
+<<?a, ?b, ?c>> #=> "abc"
+[?a, ?b, ?c]   #=> 'abc'
+
+# `?a` en Elixir retourne le code ASCII (Integer) de la lettre `a`
+?a #=> 97
+
+# Pour concaténer des listes il faut utiliser `++`, et `<>` pour les
+# binaires
+[1,2,3] ++ [4,5]     #=> [1,2,3,4,5]
+'hello ' ++ 'world'  #=> 'hello world'
+
+<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>>
+"hello " <> "world"  #=> "hello world"
+
+# Les intervalles sont représentés de cette sorte `début..fin`
+# (tout deux inclusifs)
+1..10 #=> 1..10
+bas..haut = 1..10 # Possibilité d'utiliser le pattern matching sur les intervalles aussi.
+[bas, haut] #=> [1, 10]
+
+# Les Maps (Tableau associatif) sont des paires clée - valeur
+genders = %{"david" => "male", "gillian" => "female"}
+genders["david"] #=> "male"
+
+# Les maps avec des atomes peuvent être utilisés comme cela
+genders = %{david: "male", gillian: "female"}
+genders.gillian #=> "female"
+
+## ---------------------------
+## -- Operateurs
+## ---------------------------
+
+# Mathématiques
+1 + 1  #=> 2
+10 - 5 #=> 5
+5 * 2  #=> 10
+10 / 2 #=> 5.0
+
+# En Elixir l'opérateur `/` retourne toujours un Float (virgule flottante).
+
+# Pour faire une division avec entier il faut utiliser `div`
+div(10, 2) #=> 5
+
+# Pour obtenir le reste de la division il faut utiliser `rem`
+rem(10, 3) #=> 1
+
+# Il y a aussi les opérateurs booléen: `or`, `and` et `not`.
+# Ces opérateurs attendent un booléen en premier argument.
+true and true #=> true
+false or true #=> true
+# 1 and true
+#=> ** (BadBooleanError) expected a booléens on left-side of "and", got: 1
+
+# Elixir fournit aussi `||`, `&&` et `!` qui acceptent des arguments de
+# tout type.
+# Chaque valeur sauf `false` et `nil` seront évalués à vrai (true).
+1 || true  #=> 1
+false && 1 #=> false
+nil && 20  #=> nil
+!true #=> false
+
+# Pour les comparaisons il y a : `==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` et `>`
+1 == 1 #=> true
+1 != 1 #=> false
+1 < 2  #=> true
+
+# `===` et `!==` sont plus stricts en comparant les Integers (entiers) 
+# et les Floats (nombres à virgules) :
+1 == 1.0  #=> true
+1 === 1.0 #=> false
+
+# On peut aussi comparer deux types de données différents :
+1 < :hello #=> true
+
+# L'ordre est défini de la sorte :
+# number < atom < reference < functions < port < pid < tuple < list < bit string
+
+# Pour citer Joe Armstrong : "The actual order is not important,
+# but that a total ordering is well defined is important."
+
+## ---------------------------
+## -- Structure de contrôle
+## ---------------------------
+
+# Condition avec `if` (si)
+if false do
+  "Cela ne sera pas vu"
+else
+  "Cela le sera"
+end
+
+# Condition avec `unless` (sauf).
+# Il correspond à la négation d'un `if` (si) 
+unless true do
+  "Cela ne sera pas vu"
+else
+  "Cela le sera"
+end
+
+# Beaucoup de structures en Elixir se basent sur le pattern matching.
+# `case` permet de comparer une valeur à plusieurs modèles:
+case {:one, :two} do
+  {:four, :five} ->
+    "Ne match pas"
+  {:one, x} ->
+    "Match et lie `x` à `:two` dans ce cas"
+  _ ->
+    "Match toutes les valeurs"
+end
+
+# Il est commun de lier la valeur à `_` si on ne l'utilise pas.
+# Par exemple, si seulement la tête d'une liste nous intéresse:
+[head | _] = [1,2,3]
+head #=> 1
+
+# Pour plus de lisibilité, ce procédé est utilisé:
+[head | _tail] = [:a, :b, :c]
+head #=> :a
+
+# `cond` permet de vérifier plusieurs conditions à la fois.
+# Il est conseillé d'utiliser `cond` plutôt que des `if` imbriqués.
+cond do
+  1 + 1 == 3 ->
+    "Je ne serai pas vu"
+  2 * 5 == 12 ->
+    "Moi non plus"
+  1 + 2 == 3 ->
+    "Mais moi oui"
+end
+
+# Il est commun d'attribuer la dernière condition à true (vrai), qui
+# matchera toujours.
+cond do
+  1 + 1 == 3 ->
+    "Je ne serai pas vu"
+  2 * 5 == 12 ->
+    "Moi non plus"
+  true ->
+    "Mais moi oui (représente un else)" 
+end
+
+# `try/catch` est utilisé pour attraper les valeurs rejetées. 
+# Il supporte aussi un 
+# `after` qui est appelé autant si une valeur est jetée ou non.
+try do
+  throw(:hello)
+catch
+  message -> "Message : #{message}."
+after
+  IO.puts("Je suis la clause after (après).")
+end
+#=> Je suis la clause after (après).
+# "Message : :hello"
+
+## ---------------------------
+## -- Modules et Fonctions
+## ---------------------------
+
+# Fonctions anonymes (notez le point).
+square = fn(x) -> x * x end
+square.(5) #=> 25
+
+# Les fonctions anonymes acceptent aussi de nombreuses clauses et guards (gardes).
+# Les guards permettent d'affiner le pattern matching,
+# ils sont indiqués par le mot-clef `when` :
+f = fn
+  x, y when x > 0 -> x + y
+  x, y -> x * y
+end
+
+f.(1, 3)  #=> 4
+f.(-1, 3) #=> -3
+
+# Elixir propose aussi de nombreuses fonctions internes.
+is_number(10)    #=> true
+is_list("hello") #=> false
+elem({1,2,3}, 0) #=> 1
+
+# Il est possible de grouper plusieurs fonctions dans un module.
+# Dans un module, les fonctions sont définies par `def`
+defmodule Math do
+  def sum(a, b) do
+    a + b
+  end
+
+  def square(x) do
+    x * x
+  end
+end
+
+Math.sum(1, 2)  #=> 3
+Math.square(3) #=> 9
+
+# Pour compiler notre module `Math`,
+# il faut le sauvegarder en tant que `math.ex` et utiliser `elixirc`.
+# Executez ainsi `elixirc math.ex` dans le terminal.
+
+# Au sein d'un module, nous pouvons définir les fonctions avec `def`
+# et `defp` pour les fonctions privées.
+# Une fonction définie par `def` est disponible dans les autres
+# modules. Une fonction privée est disponible localement seulement.
+defmodule PrivateMath do
+  def sum(a, b) do
+    do_sum(a, b)
+  end
+
+  defp do_sum(a, b) do
+    a + b
+  end
+end
+
+PrivateMath.sum(1, 2)    #=> 3
+# PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError)
+
+# La déclaration de fonction supporte également les guards (gardes) 
+# et les clauses. 
+# Quand une fonction avec plusieurs clauses est appelée,
+# la première fonction dont la clause est satisfaite par les arguments sera appelée.
+# Exemple: le code `area({:circle, 3})` appelle la deuxième fonction definie plus bas,
+# et non la première car ses arguments correspondent à la signature de cette dernière:
+defmodule Geometry do
+  def area({:rectangle, w, h}) do
+    w * h
+  end
+
+  def area({:circle, r}) when is_number(r) do
+    3.14 * r * r
+  end
+end
+
+Geometry.area({:rectangle, 2, 3}) #=> 6
+Geometry.area({:circle, 3})       #=> 28.25999999999999801048
+# Geometry.area({:circle, "not_a_number"})
+#=> ** (FunctionClauseError) no function clause matching in Geometry.area/1
+
+# En raison de l'immutabilité, la récursivité est une grande partie
+# d'Elixir
+defmodule Recursion do
+  def sum_list([head | tail], acc) do
+    sum_list(tail, acc + head)
+  end
+
+  def sum_list([], acc) do
+    acc
+  end
+end
+
+Recursion.sum_list([1,2,3], 0) #=> 6
+
+# Les modules Elixir supportent des attributs internes,
+# ceux-ci peuvent aussi être personnalisés.
+defmodule MyMod do
+  @moduledoc """
+  This is a built-in attribute on a example module.
+  """
+
+  @my_data 100 # Attribut personnel.
+  IO.inspect(@my_data) #=> 100
+end
+
+# L'opérateur pipe (|>) permet de passer la sortie d'une expression
+# en premier paramètre d'une fonction. 
+
+Range.new(1,10)
+|> Enum.map(fn x -> x * x end)
+|> Enum.filter(fn x -> rem(x, 2) == 0 end)
+#=> [4, 16, 36, 64, 100]
+
+## ---------------------------
+## -- Structs et Exceptions
+## ---------------------------
+
+# Les Structs sont des extensions des Maps.
+# Apportant en plus les valeurs par defaut, le polymorphisme et 
+# la vérification à la compilation dans Elixir.
+defmodule Person do
+  defstruct name: nil, age: 0, height: 0
+end
+
+jean_info = %Person{ name: "Jean", age: 30, height: 180 }
+#=> %Person{age: 30, height: 180, name: "Jean"}
+
+# Access the value of name
+jean_info.name #=> "Jean"
+
+# Update the value of age
+older_jean_info = %{ jean_info | age: 31 }
+#=> %Person{age: 31, height: 180, name: "Jean"}
+
+# Le bloc `try` avec le mot-clef `rescue` est utilisé pour gérer les exceptions
+try do
+  raise "some error"
+rescue
+  RuntimeError -> "rescued a runtime error"
+  _error -> "this will rescue any error"
+end
+#=> "rescued a runtime error"
+
+# Chaque exception possède un message
+try do
+  raise "some error"
+rescue
+  x in [RuntimeError] ->
+    x.message
+end
+#=> "some error"
+
+## ---------------------------
+## -- Concurrence
+## ---------------------------
+
+# Elixir se repose sur le modèle d'acteur pour gérer la concurrence.
+# Pour écrire un programme concurrent en Elixir il faut trois 
+# primitives: spawning processes (création), sending messages (envoi) 
+# et receiving messages (réception).
+
+# Pour débuter un nouveau processus, il faut utiliser 
+# la fonction `spawn` qui prend en argument une fonction.
+f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>
+spawn(f) #=> #PID<0.40.0>
+
+# `spawn` retourn un pid (identifiant de processus), il est possible 
+# d'utiliser ce pid pour envoyer un message au processus.
+# Pour faire parvenir le message il faut utiliser l'opérateur `send`.
+# Pour que cela soit utile il faut être capable de recevoir les 
+# messages.
+# Cela est possible grâce au mechanisme de `receive`:
+
+# Le bloc `receive do` est utilisé pour écouter les messages et les traiter
+# au moment de la réception. Un bloc `receive do` pourra traiter un seul
+# message reçu.
+# Pour traiter plusieurs messages, une fonction avec un bloc `receive do` 
+# doit s'appeler elle-même récursivement.
+
+defmodule Geometry do
+  def area_loop do
+    receive do
+      {:rectangle, w, h} ->
+        IO.puts("Area = #{w * h}")
+        area_loop()
+      {:circle, r} ->
+        IO.puts("Area = #{3.14 * r * r}")
+        area_loop()
+    end
+  end
+end
+
+# Ceci compile le module et créer un processus qui évalue dans le terminal `area_loop`
+pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0>
+# Alternativement
+pid = spawn(Geometry, :area_loop, [])
+
+# On envoi un message au `pid` qui correspond à la régle de réception.
+send pid, {:rectangle, 2, 3}
+#=> Area = 6
+#   {:rectangle,2,3}
+
+send pid, {:circle, 2}
+#=> Area = 12.56000000000000049738
+#   {:circle,2}
+
+# Le shell est aussi un processus, il est possible d'utiliser `self`
+# pour obtenir le pid du processus courant.
+self() #=> #PID<0.27.0>
+
+## ---------------------------
+## -- Agents
+## ---------------------------
+
+# Un agent est un processus qui garde les traces des valeurs modifiées.
+
+# Pour créer un agent on utilise `Agent.start_link` avec une fonction.
+# L'état initial de l'agent sera ce que la fonction retourne
+{ok, my_agent} = Agent.start_link(fn -> ["red", "green"] end)
+
+# `Agent.get` prend un nom d'agent et une fonction (`fn`).
+# Qu'importe ce que cette `fn` retourne, l'état sera ce qui est retourné.
+Agent.get(my_agent, fn colors -> colors end) #=> ["red", "green"]
+
+# Modification de l'état de l'agent
+Agent.update(my_agent, fn colors -> ["blue" | colors] end)
+```
+
+## Références
+
+* [Guide de debut](http://elixir-lang.org/getting-started/introduction.html) depuis le site [Elixir](http://elixir-lang.org)
+* [Documentation Elixir ](https://elixir-lang.org/docs.html)
+* ["Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) de Dave Thomas
+* [Elixir Cheat Sheet](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf)
+* ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) de Fred Hebert
+* ["Programming Erlang: Software for a Concurrent World"](https://pragprog.com/book/jaerlang2/programming-erlang) de Joe Armstrong
-- 
cgit v1.2.3