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

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