From 18058567c4e7570ca7fd053299eefd0d36658329 Mon Sep 17 00:00:00 2001
From: Matteo Taroli <taroli.matteo@gmail.com>
Date: Fri, 2 Oct 2015 22:17:16 +0200
Subject: Add French translation for Perl 5

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

(limited to 'fr-fr')

diff --git a/fr-fr/perl-fr.html.markdown b/fr-fr/perl-fr.html.markdown
new file mode 100644
index 00000000..7a061da7
--- /dev/null
+++ b/fr-fr/perl-fr.html.markdown
@@ -0,0 +1,166 @@
+---
+name: perl
+category: language
+language: perl
+filename: learnperl-fr.pl
+contributors:
+    - ["Korjavin Ivan", "http://github.com/korjavin"]
+translators:
+    - ["Matteo Taroli", "http://www.matteotaroli.be"]
+lang: fr-fr
+---
+Perl 5 est un langage de programmation riche en fonctionnalité, avec plus de 25 ans de développement.
+
+Perl 5 fonctionne sur plus de 100 plateformes, allant des pc portables aux mainframes et
+est autant adapté à un prototypage rapide qu'à des projets de grande envergure.
+
+```perl
+#  Les commentaires en une ligne commencent par un dièse
+
+
+#### Types de variables de Perl
+
+# Les variables comment par un symbole précisant le type.
+# Un nom de variable valide commence par une lettre ou un underscore,
+# suivi d'un nombre quelconque de lettres, chiffres ou underscores.
+
+### Perl a trois types principaux de variables: $scalaire, @tableau and %hash
+
+## Scalaires
+#  Un scalaire représente une valeure unique :
+my $animal = "chameau";
+my $reponse = 42;
+
+# Les valeurs scalaires peuvent être des strings, des entiers ou des nombres à virgule flottante
+# et Perl les convertira automatiquement entre elles quand nécessaire.
+
+## Tableaux
+#  Un tableau représente une liste de valeurs :
+my @animaux = ("chameau", "lama", "chouette");
+my @nombres = (23, 42, 69);
+my @melange = ("chameau", 42, 1.23);
+
+## Hashes
+#  Un hash représente un ensemble de paires de clé/valeur :
+my %fruit_couleur = ("pomme", "rouge", "banane", "jaune");
+
+# Vous pouvez utiliser des espaces et l'opérateur "=>" pour les disposer plus joliment :
+
+my %fruit_couleur = (
+	pomme  => "rouge",
+	banane => "jaune"
+);
+
+# Les scalaires, tableaux et hashes sont plus amplement documentés dans le perldata
+# (perldoc perldata)
+
+# Des types de données plus complexes peuvent être construits en utilisant des références,
+# vous permettant de construire des listes et des hashes à l'intérieur d'autres listes et hashes.
+
+#### Conditions et boucles
+
+# Perl possède la plupart des conditions et boucles habituelles.
+
+if ($var) {
+  ...
+} elsif ($var eq 'bar') {
+  ...
+} else {
+  ...
+}
+
+unless (condition) {
+  ...
+}
+# Ceci est fourni en tant que version plus lisible de "if (!condition)"
+
+# la postcondition à la sauce Perl
+
+print "Yow!" if $zippy;
+print "Nous n'avons pas de banane." unless $bananes;
+
+#  while
+while (condition) {
+  ...
+}
+
+# boucle for et iteration
+for (my $i = 0; $i < $max; $i++) {
+  print "l'index est $i";
+}
+
+for (my $i = 0; $i < @elements; $i++) {
+  print "L'élément courant est " . $elements[$i];
+}
+
+for my $element (@elements) {
+  print $element;
+}
+
+# implicitement
+
+for (@elements) {
+  print;
+}
+
+
+#### Expressions régulières
+
+# Le support des expressions régulières par Perl est aussi large que profond
+# et est sujet à une longue documentation sur perlrequick, perlretut et ailleurs.
+# Cependant, pour faire court :
+
+# Simple correspondance
+if (/foo/)       { ... }  # vrai si $_ contient "foo"
+if ($a =~ /foo/) { ... }  # vrai si $a contient "foo"
+
+# Simple substitution
+
+$a =~ s/foo/bar/;         # remplace foo par bar dans $a
+$a =~ s/foo/bar/g;        # remplace TOUTES LES INSTANCES de foo par bar dans $a
+
+
+#### Fichiers and E/S
+
+# Vous pouvez ouvrir un fichier pour y écrire ou pour le lire avec la fonction "open()".
+
+open(my $in,  "<",  "input.txt")  or die "Impossible d'ouvrir input.txt: $!";
+open(my $out, ">",  "output.txt") or die "Impossible d'ouvrir output.txt: $!";
+open(my $log, ">>", "my.log")     or die "Impossible d'ouvrir my.log: $!";
+
+# Vous pouvez lire depuis un descripteur de fichier grâce à l'opérateur "<>".
+# Dans un contexte scalaire, il lit une seule ligne depuis le descripteur de fichier
+# et dans un contexte de liste, il lit le fichier complet, assignant chaque ligne à un
+# élément de la liste :
+
+my $ligne = <$in>
+my $lignes = <$in>
+
+#### Ecrire des sous-programmes
+
+# Ecrire des sous-programmes est facile :
+
+sub logger {
+  my $logmessage = shift;
+
+  open my $logfile, ">>", "my.log" or die "Impossible d'ouvrir my.log: $!";
+
+  print $logfile $logmessage;
+}
+
+# Maintenant, nous pouvons utiliser le sous-programme comme n'importe quelle fonction intégrée :
+
+logger("On a un sous-programme de logging!!");
+```
+
+#### Utiliser des modules Perl
+
+Les modules Perl fournissent une palette de fonctionnalités vous évitant de réinventer la roue et peuvent être téléchargés depuis CPAN (http://www.cpan.org/). Un certain nombre de modules populaires sont inclus dans la distribution même de Perl.
+
+Perlfaq contiens des questions et réponses liées aux tâches habituelles et propose souvent des suggestions quant aux bons modules à utiliser.
+
+#### Pour en savoir plus
+ - [perl-tutorial](http://perl-tutorial.org/)
+ - [Learn at www.perl.com](http://www.perl.org/learn.html)
+ - [perldoc](http://perldoc.perl.org/)
+ - and perl built-in : `perldoc perlintro`
-- 
cgit v1.2.3


From b723d3284bbccbcbf5e7ecedee3469b87f4d5959 Mon Sep 17 00:00:00 2001
From: Matteo Taroli <taroli.matteo@gmail.com>
Date: Thu, 8 Oct 2015 12:38:19 +0200
Subject: Add explanation about $_ and fix typos

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

(limited to 'fr-fr')

diff --git a/fr-fr/perl-fr.html.markdown b/fr-fr/perl-fr.html.markdown
index 7a061da7..e737b7aa 100644
--- a/fr-fr/perl-fr.html.markdown
+++ b/fr-fr/perl-fr.html.markdown
@@ -5,6 +5,7 @@ language: perl
 filename: learnperl-fr.pl
 contributors:
     - ["Korjavin Ivan", "http://github.com/korjavin"]
+    - ["Matteo Taroli", "http://www.matteotaroli.be"]
 translators:
     - ["Matteo Taroli", "http://www.matteotaroli.be"]
 lang: fr-fr
@@ -27,7 +28,7 @@ est autant adapté à un prototypage rapide qu'à des projets de grande envergur
 ### Perl a trois types principaux de variables: $scalaire, @tableau and %hash
 
 ## Scalaires
-#  Un scalaire représente une valeure unique :
+#  Un scalaire représente une valeur unique :
 my $animal = "chameau";
 my $reponse = 42;
 
@@ -99,8 +100,15 @@ for my $element (@elements) {
 
 # implicitement
 
+# La variable de contexte scalaire $_ est utilisée par défaut dans différentes
+# situations, comme par exemple dans la boucle foreach ou en argument par défaut
+# de la plupart des fonctions pour en simplifier l'écriture.
+
+# Dans l'exemple suivant, $_ prends successivement la valeur de
+# chaque élément de la liste.  
+
 for (@elements) {
-  print;
+  print; # affiche le contenu de $_
 }
 
 
@@ -116,11 +124,11 @@ if ($a =~ /foo/) { ... }  # vrai si $a contient "foo"
 
 # Simple substitution
 
-$a =~ s/foo/bar/;         # remplace foo par bar dans $a
+$a =~ s/foo/bar/;         # remplace le premier foo par bar dans $a
 $a =~ s/foo/bar/g;        # remplace TOUTES LES INSTANCES de foo par bar dans $a
 
 
-#### Fichiers and E/S
+#### Fichiers et E/S
 
 # Vous pouvez ouvrir un fichier pour y écrire ou pour le lire avec la fonction "open()".
 
@@ -136,9 +144,9 @@ open(my $log, ">>", "my.log")     or die "Impossible d'ouvrir my.log: $!";
 my $ligne = <$in>
 my $lignes = <$in>
 
-#### Ecrire des sous-programmes
+#### Ecrire des fonctions
 
-# Ecrire des sous-programmes est facile :
+# Ecrire des fonctions est facile :
 
 sub logger {
   my $logmessage = shift;
@@ -148,9 +156,9 @@ sub logger {
   print $logfile $logmessage;
 }
 
-# Maintenant, nous pouvons utiliser le sous-programme comme n'importe quelle fonction intégrée :
+# Maintenant, nous pouvons utiliser cette fonction comme n'importe quelle fonction intégrée :
 
-logger("On a un sous-programme de logging!!");
+logger("On a une fonction de logging!!");
 ```
 
 #### Utiliser des modules Perl
-- 
cgit v1.2.3


From 5c84b03a49553856049e4d9c677b09c9a7eb9419 Mon Sep 17 00:00:00 2001
From: Gnomino <gnomino@gnomino.eu>
Date: Sun, 18 Oct 2015 18:38:01 +0200
Subject: [css/fr] Corrects some French mistakes

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

(limited to 'fr-fr')

diff --git a/fr-fr/css-fr.html.markdown b/fr-fr/css-fr.html.markdown
index bdab9715..a3a5cf55 100644
--- a/fr-fr/css-fr.html.markdown
+++ b/fr-fr/css-fr.html.markdown
@@ -8,7 +8,7 @@ translators:
 lang: fr-fr
 ---
 
-Au début du web, il n'y avait pas d'élements visuels, simplement du texte pure. Mais avec le dévelopement des navigateurs,
+Au début du web, il n'y avait pas d'élements visuels, simplement du texte pur. Mais avec le dévelopement des navigateurs,
 des pages avec du contenu visuel sont arrivées.
 CSS est le langage standard qui existe et permet de garder une séparation entre
 le contenu (HTML) et le style d'une page web.
@@ -16,8 +16,8 @@ le contenu (HTML) et le style d'une page web.
 En résumé, CSS fournit une syntaxe qui vous permet de cibler des élements présents
 sur une page HTML afin de leur donner des propriétés visuelles différentes.
 
-Comme tous les autres langages, CSS a plusieurs versions. Ici, nous allons parlons de CSS2.0
-qui n'est pas le plus récent, mais qui reste le plus utilisé et le plus compatible avec les différents navigateur.
+Comme tous les autres langages, CSS a plusieurs versions. Ici, nous allons parler de CSS2.0
+qui n'est pas le plus récent, mais qui reste le plus utilisé et le plus compatible avec les différents navigateurs.
 
 **NOTE :** Vous pouvez tester les effets visuels que vous ajoutez au fur et à mesure du tutoriel sur des sites comme [dabblet](http://dabblet.com/) afin de voir les résultats, comprendre, et vous familiariser avec le langage.
 Cet article porte principalement sur la syntaxe et quelques astuces.
@@ -33,7 +33,7 @@ Cet article porte principalement sur la syntaxe et quelques astuces.
 /* Généralement, la première déclaration en CSS est très simple */
 selecteur { propriete: valeur; /* autres proprietés...*/ }
 
-/* Le sélécteur sert à cibler un élément du HTML
+/* Le sélecteur sert à cibler un élément du HTML
 
 Vous pouvez cibler tous les éléments d'une page! */
 * { color:red; }
@@ -81,7 +81,7 @@ div.une-classe[attr$='eu'] { }
 /* Un élément qui est en enfant direct */
 div.un-parent > .enfant {}
 
-/* Cela cible aussi les .enfants plus profonds dans la structure HTML */
+/*  dans la structure HTML */
 div.un-parent .enfants {}
 
 /* Attention : le même sélecteur sans espace a un autre sens. */
-- 
cgit v1.2.3


From fe4ed9080dc258e35a9fffd3a52d097eb457c745 Mon Sep 17 00:00:00 2001
From: Gnomino <gnomino@gnomino.eu>
Date: Sun, 18 Oct 2015 18:39:21 +0200
Subject: Brings text back

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

(limited to 'fr-fr')

diff --git a/fr-fr/css-fr.html.markdown b/fr-fr/css-fr.html.markdown
index a3a5cf55..35673c47 100644
--- a/fr-fr/css-fr.html.markdown
+++ b/fr-fr/css-fr.html.markdown
@@ -81,7 +81,7 @@ div.une-classe[attr$='eu'] { }
 /* Un élément qui est en enfant direct */
 div.un-parent > .enfant {}
 
-/*  dans la structure HTML */
+/* Cela cible aussi les .enfants plus profonds dans la structure HTML */
 div.un-parent .enfants {}
 
 /* Attention : le même sélecteur sans espace a un autre sens. */
-- 
cgit v1.2.3


From a8ebd498338183f3469e37f7763aad6d644780e1 Mon Sep 17 00:00:00 2001
From: aceawan <aceawan@acelaptop>
Date: Mon, 19 Oct 2015 13:34:59 +0200
Subject: [d/fr] adds translation

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

(limited to 'fr-fr')

diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown
new file mode 100644
index 00000000..dfc3519d
--- /dev/null
+++ b/fr-fr/d.html.markdown
@@ -0,0 +1,291 @@
+---
+language: D
+filename: learnd.d
+contributors:
+    - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"]
+	- ["Quentin Ladeveze", "aceawan.eu"]
+lang: fr
+---
+
+```d
+// 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-paradigme qui contient
+des fonctionnalités aussi bien de bas-niveau que haut-niveau.
+
+D is actively developed by a large group of super-smart people and is spearheaded by
+[Walter Bright](https://en.wikipedia.org/wiki/Walter_Bright) and
+[Andrei Alexandrescu](https://en.wikipedia.org/wiki/Andrei_Alexandrescu).
+With all that out of the way, let's look at some examples!
+
+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.
+
+```d
+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 continue 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 !");
+        }
+    }
+}
+```
+
+We can define new types with `struct`, `class`, `union`, and `enum`. Structs and unions
+are passed to functions by value (i.e. copied) and classes are passed by reference. Futhermore,
+we can use templates to parameterize all of these on both types and values!
+
+On peut définir de nouveaux types avec les mots-clés `struct`, `class`,
+`union` et `enum`. Les structures et les unions sont passées au fonctions par
+valeurs (elle sont copiées) et les classes sont passées par référence. De plus,
+On peut utiliser les templates pour rendre toutes ces abstractions génériques.
+
+```d
+// 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;
+
+	// Si il n'y a qu'un seul paramètre de template,
+	// on peut s'abstenir de 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.
+
+```d
+// 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'apellent 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);
+}
+```
+
+With properties, we can add any amount of logic to
+our getter and setter methods, and keep the clean syntax of
+accessing members directly!
+
+Other object-oriented goodies at our disposal
+include `interface`s, `abstract class`es,
+and `override`ing methods. D does inheritance just like Java:
+Extend one class, implement as many interfaces as you please.
+
+We've seen D's OOP facilities, but let's switch gears. D offers
+functional programming with first-class functions, `pure`
+functions, and immutable data. In addition, all of your favorite
+functional algorithms (map, filter, reduce and friends) can be
+found in the wonderful `std.algorithm` module!
+
+Avec les propriétés, on peut constuire nos setters et nos getters
+comme on le souhaite, tout en gardant un 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 `pure` et les données immuables.
+De plus, tout vos algorithmes fonctionelles favoris (map, reduce, filter)
+sont disponibles dans le module `std.algorithm`.
+
+```d
+import std.algorithm : map, filter, reduce;
+import std.range : iota; // construit un intervalle excluant la dernière valeur.
+
+void main() {
+	// On veut un algorithm qui affiche la somme de la listes des carrés
+	// des entiers paires de 1 à 100. Un jeu d'enfant !
+
+	// On se content de passer des expressions lambda en paramètre à des templates.
+	// On peut fournier 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 comme on a calculé `num` comme on le ferait en haskell par exemple ?
+C'est grâce à une innvoation de D qu'on appelle "Uniform Function Call Syntax".
+Avec l'UFCS, on peut choisir d'écrire un appelle à une fonction de manière
+classique, ou comme un appelle à 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 les parallélisme ? Bien sur que vous aimez ça
+Voyons comment on le fait en D !
+
+```d
+import std.stdio;
+import std.parallelism : parallel;
+import std.math : sqrt;
+
+void main() {
+	// On veut calculer la racine carré 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);
+    }
+}
+
+
+```
-- 
cgit v1.2.3


From 6313536895742385f743b05ed84c1efc274204f7 Mon Sep 17 00:00:00 2001
From: aceawan <aceawan@acelaptop>
Date: Mon, 19 Oct 2015 13:35:38 +0200
Subject: [d/fr] adds translation

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

(limited to 'fr-fr')

diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown
index dfc3519d..5d72a2d0 100644
--- a/fr-fr/d.html.markdown
+++ b/fr-fr/d.html.markdown
@@ -1,10 +1,10 @@
 ---
 language: D
-filename: learnd.d
+filename: learnd-fr.d
 contributors:
     - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"]
 	- ["Quentin Ladeveze", "aceawan.eu"]
-lang: fr
+lang: fr-f
 ---
 
 ```d
-- 
cgit v1.2.3


From 7f8b8d036302ee7e7ba2c47b11c3833b864bffab Mon Sep 17 00:00:00 2001
From: aceawan <aceawan@acelaptop>
Date: Mon, 19 Oct 2015 13:38:10 +0200
Subject: correct translator name

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

(limited to 'fr-fr')

diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown
index 5d72a2d0..f9dececb 100644
--- a/fr-fr/d.html.markdown
+++ b/fr-fr/d.html.markdown
@@ -3,6 +3,7 @@ language: D
 filename: learnd-fr.d
 contributors:
     - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"]
+translators:
 	- ["Quentin Ladeveze", "aceawan.eu"]
 lang: fr-f
 ---
-- 
cgit v1.2.3


From 5507a389903c4b2ff66aa811f6952a78e99c3c7a Mon Sep 17 00:00:00 2001
From: aceawan <aceawan@acelaptop>
Date: Mon, 19 Oct 2015 13:39:05 +0200
Subject: correct language

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

(limited to 'fr-fr')

diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown
index f9dececb..2c90a628 100644
--- a/fr-fr/d.html.markdown
+++ b/fr-fr/d.html.markdown
@@ -5,7 +5,7 @@ contributors:
     - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"]
 translators:
 	- ["Quentin Ladeveze", "aceawan.eu"]
-lang: fr-f
+lang: fr-fr
 ---
 
 ```d
-- 
cgit v1.2.3


From c759b6ea2bc1dd1ddad8d08bcdf5741d7e7711b0 Mon Sep 17 00:00:00 2001
From: aceawan <aceawan@acelaptop>
Date: Mon, 19 Oct 2015 13:39:44 +0200
Subject: removes english text

---
 fr-fr/d.html.markdown | 5 -----
 1 file changed, 5 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown
index 2c90a628..d75f1083 100644
--- a/fr-fr/d.html.markdown
+++ b/fr-fr/d.html.markdown
@@ -25,11 +25,6 @@ de grandes chances pour que vous ayez déjà entendu parler du [D](http://dlang.
 D est un langage de programmation moderne, généraliste, multi-paradigme qui contient
 des fonctionnalités aussi bien de bas-niveau que haut-niveau.
 
-D is actively developed by a large group of super-smart people and is spearheaded by
-[Walter Bright](https://en.wikipedia.org/wiki/Walter_Bright) and
-[Andrei Alexandrescu](https://en.wikipedia.org/wiki/Andrei_Alexandrescu).
-With all that out of the way, let's look at some examples!
-
 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).
-- 
cgit v1.2.3


From 00182d32f4e2eebf46d12910e885b0dde3eabdbc Mon Sep 17 00:00:00 2001
From: aceawan <aceawan@acelaptop>
Date: Mon, 19 Oct 2015 13:40:27 +0200
Subject: removes english text

---
 fr-fr/d.html.markdown | 21 ---------------------
 1 file changed, 21 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown
index d75f1083..702de206 100644
--- a/fr-fr/d.html.markdown
+++ b/fr-fr/d.html.markdown
@@ -72,11 +72,6 @@ void main() {
     }
 }
 ```
-
-We can define new types with `struct`, `class`, `union`, and `enum`. Structs and unions
-are passed to functions by value (i.e. copied) and classes are passed by reference. Futhermore,
-we can use templates to parameterize all of these on both types and values!
-
 On peut définir de nouveaux types avec les mots-clés `struct`, `class`,
 `union` et `enum`. Les structures et les unions sont passées au fonctions par
 valeurs (elle sont copiées) et les classes sont passées par référence. De plus,
@@ -204,22 +199,6 @@ void main() {
     writefln("Later: data = %d, str = %s", mc.data, mc.other);
 }
 ```
-
-With properties, we can add any amount of logic to
-our getter and setter methods, and keep the clean syntax of
-accessing members directly!
-
-Other object-oriented goodies at our disposal
-include `interface`s, `abstract class`es,
-and `override`ing methods. D does inheritance just like Java:
-Extend one class, implement as many interfaces as you please.
-
-We've seen D's OOP facilities, but let's switch gears. D offers
-functional programming with first-class functions, `pure`
-functions, and immutable data. In addition, all of your favorite
-functional algorithms (map, filter, reduce and friends) can be
-found in the wonderful `std.algorithm` module!
-
 Avec les propriétés, on peut constuire nos setters et nos getters
 comme on le souhaite, tout en gardant un syntaxe très propre,
 comme si on accédait directement à des membres de la classe.
-- 
cgit v1.2.3


From f8a2b28890d5d68a252d5bc0fd8247495b680e09 Mon Sep 17 00:00:00 2001
From: aceawan <aceawan@acelaptop>
Date: Mon, 19 Oct 2015 15:28:43 +0200
Subject: fix indentation and typos

---
 fr-fr/d.html.markdown | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown
index 702de206..6782142d 100644
--- a/fr-fr/d.html.markdown
+++ b/fr-fr/d.html.markdown
@@ -4,7 +4,7 @@ filename: learnd-fr.d
 contributors:
     - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"]
 translators:
-	- ["Quentin Ladeveze", "aceawan.eu"]
+    - ["Quentin Ladeveze", "aceawan.eu"]
 lang: fr-fr
 ---
 
@@ -22,8 +22,8 @@ void main(string[] args) {
 
 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-paradigme qui contient
-des fonctionnalités aussi bien de bas-niveau que haut-niveau.
+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
@@ -34,18 +34,17 @@ Après cette petite introduction, jetons un coup d'oeil à quelques exemples.
 import std.stdio;
 
 void main() {
-
-	//Les conditions et les boucles sont classiques.
+    //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.
+    // 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 `_`.
+    // en y insérant des `_`.
     while(n < 10_000) {
         n += n;
     }
-- 
cgit v1.2.3


From 13c9d9af5cc60ae747d42f73d795f360a15f3fd8 Mon Sep 17 00:00:00 2001
From: aceawan <aceawan@acelaptop>
Date: Mon, 19 Oct 2015 15:33:48 +0200
Subject: fix indentation and typos

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

(limited to 'fr-fr')

diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown
index 6782142d..ee69ca34 100644
--- a/fr-fr/d.html.markdown
+++ b/fr-fr/d.html.markdown
@@ -90,7 +90,7 @@ class BinTree(T) {
     T data = null;
 
 	// Si il n'y a qu'un seul paramètre de template,
-	// on peut s'abstenir de parenthèses.
+	// on peut s'abstenir de mettre des parenthèses.
     BinTree!T left;
     BinTree!T right;
 }
-- 
cgit v1.2.3


From d7e3def01ec674a7578581c1fb8b003cd164d335 Mon Sep 17 00:00:00 2001
From: aceawan <aceawan@acelaptop>
Date: Mon, 19 Oct 2015 15:40:44 +0200
Subject: fix indentation and typos

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

(limited to 'fr-fr')

diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown
index ee69ca34..96158683 100644
--- a/fr-fr/d.html.markdown
+++ b/fr-fr/d.html.markdown
@@ -72,9 +72,8 @@ void main() {
 }
 ```
 On peut définir de nouveaux types avec les mots-clés `struct`, `class`,
-`union` et `enum`. Les structures et les unions sont passées au fonctions par
-valeurs (elle sont copiées) et les classes sont passées par référence. De plus,
-On peut utiliser les templates pour rendre toutes ces abstractions génériques.
+`union` et `enum`. Ces types sont passés au fonction par valeur (ils sont copiés)
+De plus, on peut utiliser les templates pour rendre toutes ces abstractions génériques.
 
 ```d
 // Ici, 'T' est un paramètre de type. Il est similaire au <T> de C++/C#/Java.
-- 
cgit v1.2.3


From 24ff15fe7a327232a0c33600ea70f8bc5c566eb3 Mon Sep 17 00:00:00 2001
From: aceawan <aceawan@acelaptop>
Date: Wed, 21 Oct 2015 19:08:03 +0200
Subject: correct indentation

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

(limited to 'fr-fr')

diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown
index 96158683..9eacc2aa 100644
--- a/fr-fr/d.html.markdown
+++ b/fr-fr/d.html.markdown
@@ -88,8 +88,8 @@ struct LinkedList(T) {
 class BinTree(T) {
     T data = null;
 
-	// Si il n'y a qu'un seul paramètre de template,
-	// on peut s'abstenir de mettre des parenthèses.
+    // Si 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;
 }
-- 
cgit v1.2.3


From a15486c2a843c7b1c76f0343da9436bf39d2e227 Mon Sep 17 00:00:00 2001
From: aceawan <aceawan@acelaptop>
Date: Wed, 21 Oct 2015 19:08:52 +0200
Subject: correct indentation

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

(limited to 'fr-fr')

diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown
index 9eacc2aa..d9bd9b48 100644
--- a/fr-fr/d.html.markdown
+++ b/fr-fr/d.html.markdown
@@ -248,13 +248,13 @@ import std.parallelism : parallel;
 import std.math : sqrt;
 
 void main() {
-	// On veut calculer la racine carré de tous les nombres
-	// dans notre tableau, et profiter de tous les coeurs
-	// à notre disposition.
+    // On veut calculer la racine carré 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 !
+    // 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);
     }
-- 
cgit v1.2.3


From 951a51379aaf95eac83e6df2fdb8717ff0e64ec0 Mon Sep 17 00:00:00 2001
From: Morgan <morgan.bohn@unistra.fr>
Date: Wed, 28 Oct 2015 11:52:21 +0100
Subject: [livescript/fr] Correct the translator github repository

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

(limited to 'fr-fr')

diff --git a/fr-fr/livescript-fr.html.markdown b/fr-fr/livescript-fr.html.markdown
index 9c3b8003..13bbffe5 100644
--- a/fr-fr/livescript-fr.html.markdown
+++ b/fr-fr/livescript-fr.html.markdown
@@ -4,7 +4,7 @@ filename: learnLivescript-fr.ls
 contributors:
     - ["Christina Whyte", "http://github.com/kurisuwhyte/"]
 translators:
-    - ["Morgan Bohn", "https://github.com/morganbohn"]
+    - ["Morgan Bohn", "https://github.com/dotmobo"]
 lang: fr-fr
 ---
 
-- 
cgit v1.2.3


From ae26df01957eb870401494b2f0a993920c7da665 Mon Sep 17 00:00:00 2001
From: WinChris <christophe.thomas@etu.unistra.fr>
Date: Tue, 3 Nov 2015 09:42:26 +0100
Subject: Create HTML-fr.html.markdown

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

(limited to 'fr-fr')

diff --git a/fr-fr/HTML-fr.html.markdown b/fr-fr/HTML-fr.html.markdown
new file mode 100644
index 00000000..fdde9107
--- /dev/null
+++ b/fr-fr/HTML-fr.html.markdown
@@ -0,0 +1,115 @@
+---
+language: html
+filename: learnhtml-fr.html
+contributors:
+    - ["Christophe THOMAS", "https://github.com/WinChris"]
+lang: fr-fr
+---
+HTML signifie HyperText Markup Language. 
+C'est un langage (format de fichiers) qui permet d'écrire des pages internet.
+C’est un langage de balisage, il nous permet d'écrire des pages HTML au moyen de balises (Markup, en anglais).
+Les fichiers HTML sont en réalité de simple fichier texte.
+Qu'est-ce que le balisage ? C'est une façon de hiérarchiser ses données en les entourant par une balise ouvrante et une balise fermante. 
+Ce balisage sert à donner une signification au texte ainsi entouré.
+Comme tous les autres langages, HTML a plusieurs versions. Ici, nous allons parlons de HTML5.
+
+**NOTE :** Vous pouvez tester les différentes balises que nous allons voir au fur et à mesure du tutoriel sur des sites comme [codepen](http://codepen.io/pen/) afin de voir les résultats, comprendre, et vous familiariser avec le langage.
+Cet article porte principalement sur la syntaxe et quelques astuces.
+
+
+```HTML
+<!-- Les commentaires sont entouré comme cette ligne! -->
+
+<!-- #################### Les balises #################### -->
+   
+<!-- Voici un exemple de fichier HTML que nous allons analyser -->
+<!-- Venez voir ce que ça donne  --> 
+
+<!doctype html>
+	<html>
+		<head>
+			<title>Mon Site</title>
+		</head>
+		<body>
+			<h1>Hello, world!</h1>
+			<a href = "http://codepen.io/anon/pen/xwjLbZ">Venez voir ce que ça donne</a>
+			<p>Ceci est un paragraphe</p>
+			<p>Ceci est un autre paragraphe</p>
+			<ul>
+				<li>Ceci est un item d'une liste non ordonnée (liste à puces)</li>
+				<li>Ceci est un autre item</li>
+				<li>Et ceci est le dernier item de la liste</li>
+			</ul>
+		</body>
+	</html>
+
+<!-- Un fichier HTML débute toujours par indiquer au navigateur que notre page est faite en HTML -->
+
+<!doctype html>
+
+<!-- Après ça on commence par ouvrir une balise <html> -->
+<html>
+</html>
+<!-- Et puis on la referme à la fin du fichier avec </html> -->
+<!-- après cette balise de fin, plus rien ne doit apparaître. -->
+
+<!-- À l'intérieur (entre la balise ouvrant et fermante <html></html>), on trouve : -->
+
+<!-- Un entête (<head> en anglais ; il faut le refermer avec </head>) -->
+<!-- L'entête contient des descriptions et informations annexes qui ne sont pas affichées : se sont les métadonnées -->
+
+<head>
+	<title>Mon Site</title><!-- La balise <title> permet d'indiquer au navigateur le titre à afficher dans la barre de l'onglet de la fenêtre -->
+</head>
+
+<!-- Après la balise <head>, on trouve la balise <body> -->
+<!-- Pour le moment, rien n'est encore affiché dans la fenêtre du navigateur. -->
+<!-- Il faut ensuite remplir le corps (balise <body>) avec du contenu -->
+
+<body>
+	<h1>Hello, world!</h1> <!-- La balise h1 permet de structurer le texte, c'est  un titre -->
+	<!-- Il exite différents sous-titres à <h1> qui sont hiérarchisés du plus important (h2) au plus précis (h6) -->
+	<a href = "http://codepen.io/anon/pen/xwjLbZ">Venez voir ce que ça donne</a> <!-- Lien vers la source cible indiqué dans href="" -->
+	<p>Ceci est un paragraphe </p> <!-- La balise <p> permet d'inclure du texte à la page html -->
+	<p>Ceci est un autre paragraphe</p>
+	<ul> <!-- La balise <ul> permet d'introduire une liste à puces -->
+	<!-- Si on souhaite une liste ordonnée : <ol> liste numérotée, 1. pour le premier élément, 2. pour le second, etc -->
+		<li>Ceci est un item d'une liste non ordonnée (liste à puces)</li>
+		<li>Ceci est un autre item</li>
+		<li>Et ceci est le dernier item de la liste</li>
+	</ul>
+</body>
+
+<!-- Voilà comment créer un fichier HTML simple -->
+
+<!-- Mais il est possible d'ajouter encore des balises plus spécifiques -->
+
+<!-- Pour insérer une image -->
+<img src="http://i.imgur.com/XWG0O.gif"/> <!-- On indique la source de l'image dans src="" -->
+<!-- La source peut-être un URL ou encore la destination d'un fichier de votre ordinateur -->
+
+<!-- Il est possible de réaliser des tableaux également -->
+
+<table> <!-- On ouvre la balise <table> -->
+	<tr> <!-- <tr> permet de créer une ligne -->
+		<th>First Header</th> <!-- <th> permet de créer un titre au tableau -->
+		<th>Second Header</th>
+	</tr>
+	<tr>
+		<td>Première ligne, première cellule</td> <!-- <td> permet de créer une cellule -->
+		<td>Première ligne, deuxième cellule</td>
+	</tr>
+	<tr>
+		<td>Deuxième ligne, première cellule</td>
+		<td>Deuxième ligne, deuxième cellule</td>
+	</tr>
+</table>
+
+## Utilisation
+
+Le HTML s'écrit dans des fichiers `.html`.
+
+## En savoir plus 
+
+* [Tutoriel HTML](http://slaout.linux62.org/html_css/html.html)
+* [W3School](http://www.w3schools.com/html/html_intro.asp)
-- 
cgit v1.2.3


From 3c1311a298211e099bb1d199947e88c2e09fddd4 Mon Sep 17 00:00:00 2001
From: Gnomino <gnomino@gnomino.eu>
Date: Sat, 7 Nov 2015 18:12:21 +0100
Subject: [markdown/fr] Corrects the filename

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

(limited to 'fr-fr')

diff --git a/fr-fr/markdown.html.markdown b/fr-fr/markdown.html.markdown
index e5e7c73a..66f0efbe 100644
--- a/fr-fr/markdown.html.markdown
+++ b/fr-fr/markdown.html.markdown
@@ -2,7 +2,7 @@
 language: markdown
 contributors:
 - ["Andrei Curelaru", "http://www.infinidad.fr"]
-filename: markdown.md
+filename: markdown-fr.md
 lang: fr-fr
 ---
 
-- 
cgit v1.2.3


From ce0c0a2853dee805350a0423dae070bff0098eb4 Mon Sep 17 00:00:00 2001
From: Hughes Perreault <perreault.hughes@gmail.com>
Date: Wed, 11 Nov 2015 22:50:15 -0500
Subject: [hy/fr]

A translation of Hy in french.
---
 fr-fr/hy-fr.html.markdown | 180 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 180 insertions(+)
 create mode 100644 fr-fr/hy-fr.html.markdown

(limited to 'fr-fr')

diff --git a/fr-fr/hy-fr.html.markdown b/fr-fr/hy-fr.html.markdown
new file mode 100644
index 00000000..ccd397cf
--- /dev/null
+++ b/fr-fr/hy-fr.html.markdown
@@ -0,0 +1,180 @@
+---
+language: hy
+filename: learnhy.hy
+contributors:
+    - ["Abhishek L", "http://twitter.com/abhishekl"]
+translators:
+  - ["Hughes Perreault", "https://github.com/hperreault"]
+lang: fr-fr
+---
+
+Hy est un dialecte du lisp bâti par dessus python. Il fonctionne en
+convertissant le code hy en un arbre de syntaxe abstraite de python (ast).
+Ceci permet à hy d'appeler du code python et à python d'appeler du code hy.
+
+Ce tutoriel fonctionne pour hy > 0.9.12
+
+```clojure
+;; Ceci est une introduction facile à hy, pour un tutoriel rapide aller à
+;; http://try-hy.appspot.com
+;;
+; Les commentaires se font avec des points-virgules, comme les autres LISPS
+
+;; les s-expression de bases
+; Les programmes Lisp sont fait d'expressions symboliques ou sexps qui
+; ressemble à
+(some-function args)
+; maintenant le quintessentiel hello world
+(print "hello world")
+
+;; les types de données simples
+; Tous les types de données simples sont exactement similaires à leurs
+; homologues de python
+42 ; => 42
+3.14 ; => 3.14
+True ; => True
+4+10j ; => (4+10j) un nombre complexe
+
+; Commençons par un peu d'arithmétique très simple
+(+ 4 1) ;=> 5
+; l'opérateur est appliqué à tous les arguments, comme les autres lisps
+(+ 4 1 2 3) ;=> 10
+(- 2 1) ;=> 1
+(* 4 2) ;=> 8
+(/ 4 1) ;=> 4
+(% 4 2) ;=> 0 l'opérateur modulo
+; l'opérateur d'élévation à la puissance est représenté par ** comme en python
+(** 3 2) ;=> 9
+; les expressions imbriquées vont se comporter comme on s'y attend
+(+ 2 (* 4 2)) ;=> 10
+; aussi, les opérateurs logiques and or not et equal to etc. vont se comporter
+; comme on s'y attend
+(= 5 4) ;=> False
+(not (= 5 4)) ;=> True
+
+;; variables
+; les variables sont déclarées en utilisant setv, les noms de variables
+; peuvent utiliser UTF-8 à l'exception de ()[]{}",'`;#|
+(setv a 42)
+(setv π 3.14159)
+(def *foo* 42)
+;; d'autres types de données conteneur
+; les chaînes, les listes, les tuples et dicts
+; ce sont exactement les mêmes que les types de conteneurs de python
+"hello world" ;=> "hello world"
+; les opérations sur les chaînes fonctionnent comme en python
+(+ "hello " "world") ;=> "hello world"
+; les listes sont créés en utilisant [], l'indexation commence à 0
+(setv mylist [1 2 3 4])
+; les tuples sont des structures de données immuables
+(setv mytuple (, 1 2))
+; les dictionnaires sont des paires clé-valeur
+(setv dict1 {"key1" 42 "key2" 21})
+; :nam peut être utilisé pour définir des mots clés dans hy qui peuvent être
+;  utilisées comme clés
+(setv dict2 {:key1 41 :key2 20})
+; utilisez `get' pour obtenir l'élément à l'index / clé
+(get mylist 1) ;=> 2
+(get dict1 "key1") ;=> 42
+; Alternativement, si des mots clés ont été utilisés, l'élément peut être
+; obtenu directement
+(:key1 dict2) ;=> 41
+
+;; fonctions et autres constructions de programme
+; les fonctions sont définies en utilisant defn, la dernière sexp est renvoyé par défaut
+(defn greet [name]
+  "A simple greeting" ; une docstring optionnelle
+  (print "hello " name))
+
+(greet "bilbo") ;=> "hello bilbo"
+
+; les fonctions peuvent prendre des arguments optionnels ainsi que des
+; arguments sous forme de mots clés
+(defn foolists [arg1 &optional [arg2 2]]
+  [arg1 arg2])
+
+(foolists 3) ;=> [3 2]
+(foolists 10 3) ;=> [10 3]
+
+; les fonctions anonymes sont créés en utilisant `fn' ou `lambda'
+; qui sont semblable à `defn '
+(map (fn [x] (* x x)) [1 2 3 4]) ;=> [1 4 9 16]
+
+;; Opérations sur les séquences
+; hy a des utilitaires pré-construit pour les opérations sur les séquences etc.
+; récupérez le premier élément en utilisant  `first' ou `car'
+(setv mylist [1 2 3 4])
+(setv mydict {"a" 1 "b" 2})
+(first mylist) ;=> 1
+
+; découpez les listes en utilisant slice
+(slice mylist 1 3) ;=> [2 3]
+
+; obtenez les éléments d'une liste ou dict en utilisant `get'
+(get mylist 1) ;=> 2
+(get mydict "b") ;=> 2
+; l'indexation des listes commence à 0 comme en python
+; assoc peut définir les éléments à clés/index
+(assoc mylist 2 10) ; makes mylist [1 2 10 4]
+(assoc mydict "c" 3) ; makes mydict {"a" 1 "b" 2 "c" 3}
+; il ya tout un tas d'autres fonctions de base qui rend le travail avec
+; les séquences amusant
+
+;; les importations fonctionnent comme en pyhtonn
+(import datetime)
+(import [functools [partial reduce]]) ; importe fun1 et fun2 de module1
+(import [matplotlib.pyplot :as plt]) ; faire une importation foo comme bar
+; toutes les méthodes pré-construites de python sont accessibles à partir de hy
+; a.foo(arg) est appelé (.foo un arg)
+(.split (.strip "hello world  ")) ;=> ["hello" "world"]
+
+;; Conditionelles
+; (if condition (body-if-true) (body-if-false)
+(if (= passcode "moria")
+  (print "welcome")
+  (print "Speak friend, and Enter!"))
+
+; imbriquez plusieurs if else if avec le mot clé cond
+(cond
+ [(= someval 42)
+  (print "Life, universe and everything else!")]
+ [(> someval 42)
+  (print "val too large")]
+ [(< someval 42)
+  (print "val too small")])
+
+; groupez les expressions avec do, ceux-ci seront executé séquentiellemnt
+; les expressions comme defn ont un do implicite
+(do
+ (setv someval 10)
+ (print "someval is set to " someval)) ;=> 10
+
+; créer une liaison lexicale avec `let', toutes les variables déclarées
+; comme cela ont une portée locale
+(let [[nemesis {"superman" "lex luther"
+                "sherlock" "moriarty"
+                "seinfeld" "newman"}]]
+  (for [(, h v) (.items nemesis)]
+	(print (.format "{0}'s nemesis was {1}" h v))))
+
+;; classes
+; les classes sont définies comme ceci
+(defclass Wizard [object]
+  [[--init-- (fn [self spell]
+             (setv self.spell spell) ; init the spell attr
+             None)]
+   [get-spell (fn [self]
+              self.spell)]])
+
+;; allez voir hylang.org
+```
+
+### Lectures complémentaires
+
+Ce tutoriel est juste une simple introduction à hy/lisp/python.
+
+La documentation de HY: [http://hy.readthedocs.org](http://hy.readthedocs.org)
+
+Le repo GitHub de HY: [http://github.com/hylang/hy](http://github.com/hylang/hy)
+
+Sur freenode irc #hy, twitter hashtag #hylang
-- 
cgit v1.2.3


From 5aceaa8c3469998b43642fc7e5f5251466376eda Mon Sep 17 00:00:00 2001
From: Hughes Perreault <perreault.hughes@gmail.com>
Date: Thu, 12 Nov 2015 12:11:40 -0500
Subject: Add "-fr" before filename extansion, Replace "facile" with "simple"

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

(limited to 'fr-fr')

diff --git a/fr-fr/hy-fr.html.markdown b/fr-fr/hy-fr.html.markdown
index ccd397cf..07007061 100644
--- a/fr-fr/hy-fr.html.markdown
+++ b/fr-fr/hy-fr.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: hy
-filename: learnhy.hy
+filename: learnhy-fr.hy
 contributors:
     - ["Abhishek L", "http://twitter.com/abhishekl"]
 translators:
@@ -15,7 +15,7 @@ Ceci permet à hy d'appeler du code python et à python d'appeler du code hy.
 Ce tutoriel fonctionne pour hy > 0.9.12
 
 ```clojure
-;; Ceci est une introduction facile à hy, pour un tutoriel rapide aller à
+;; Ceci est une introduction simple à hy, pour un tutoriel rapide aller à
 ;; http://try-hy.appspot.com
 ;;
 ; Les commentaires se font avec des points-virgules, comme les autres LISPS
-- 
cgit v1.2.3


From 3b59da1f3d055b5fd9f0804de2142df90c7b762c Mon Sep 17 00:00:00 2001
From: Hughes Perreault <perreault.hughes@gmail.com>
Date: Thu, 12 Nov 2015 15:40:53 -0500
Subject: =?UTF-8?q?UTF-8=20->=20l'UTF-8,=20donn=C3=A9es=20conteneur=20->?=
 =?UTF-8?q?=20conteneurs?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

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

(limited to 'fr-fr')

diff --git a/fr-fr/hy-fr.html.markdown b/fr-fr/hy-fr.html.markdown
index 07007061..841179f5 100644
--- a/fr-fr/hy-fr.html.markdown
+++ b/fr-fr/hy-fr.html.markdown
@@ -54,11 +54,11 @@ True ; => True
 
 ;; variables
 ; les variables sont déclarées en utilisant setv, les noms de variables
-; peuvent utiliser UTF-8 à l'exception de ()[]{}",'`;#|
+; peuvent utiliser l'UTF-8 à l'exception de ()[]{}",'`;#|
 (setv a 42)
 (setv π 3.14159)
 (def *foo* 42)
-;; d'autres types de données conteneur
+;; d'autres types de conteneurs
 ; les chaînes, les listes, les tuples et dicts
 ; ce sont exactement les mêmes que les types de conteneurs de python
 "hello world" ;=> "hello world"
-- 
cgit v1.2.3


From 2c33662024b3b2c9975c184d9dfb5f8f8ddd02fc Mon Sep 17 00:00:00 2001
From: Hughes Perreault <perreault.hughes@gmail.com>
Date: Fri, 13 Nov 2015 11:15:58 -0500
Subject: =?UTF-8?q?nam=20->=20nom,=20pr=C3=A9-construit=20->=20natif,=20un?=
 =?UTF-8?q?=20->=20a?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

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

(limited to 'fr-fr')

diff --git a/fr-fr/hy-fr.html.markdown b/fr-fr/hy-fr.html.markdown
index 841179f5..5220fb65 100644
--- a/fr-fr/hy-fr.html.markdown
+++ b/fr-fr/hy-fr.html.markdown
@@ -70,7 +70,7 @@ True ; => True
 (setv mytuple (, 1 2))
 ; les dictionnaires sont des paires clé-valeur
 (setv dict1 {"key1" 42 "key2" 21})
-; :nam peut être utilisé pour définir des mots clés dans hy qui peuvent être
+; :nom peut être utilisé pour définir des mots clés dans hy qui peuvent être
 ;  utilisées comme clés
 (setv dict2 {:key1 41 :key2 20})
 ; utilisez `get' pour obtenir l'élément à l'index / clé
@@ -101,7 +101,7 @@ True ; => True
 (map (fn [x] (* x x)) [1 2 3 4]) ;=> [1 4 9 16]
 
 ;; Opérations sur les séquences
-; hy a des utilitaires pré-construit pour les opérations sur les séquences etc.
+; hy a des utilitaires natifs pour les opérations sur les séquences etc.
 ; récupérez le premier élément en utilisant  `first' ou `car'
 (setv mylist [1 2 3 4])
 (setv mydict {"a" 1 "b" 2})
@@ -124,8 +124,8 @@ True ; => True
 (import datetime)
 (import [functools [partial reduce]]) ; importe fun1 et fun2 de module1
 (import [matplotlib.pyplot :as plt]) ; faire une importation foo comme bar
-; toutes les méthodes pré-construites de python sont accessibles à partir de hy
-; a.foo(arg) est appelé (.foo un arg)
+; toutes les méthodes natives de python sont accessibles à partir de hy
+; a.foo(arg) est appelé (.foo a arg)
 (.split (.strip "hello world  ")) ;=> ["hello" "world"]
 
 ;; Conditionelles
-- 
cgit v1.2.3


From e3de8870ca586cd0f084f00cc96ea540cf022638 Mon Sep 17 00:00:00 2001
From: Hughes Perreault <perreault.hughes@gmail.com>
Date: Fri, 13 Nov 2015 11:48:48 -0500
Subject: ressemble -> ressemblent

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

(limited to 'fr-fr')

diff --git a/fr-fr/hy-fr.html.markdown b/fr-fr/hy-fr.html.markdown
index 5220fb65..bd7c6839 100644
--- a/fr-fr/hy-fr.html.markdown
+++ b/fr-fr/hy-fr.html.markdown
@@ -22,7 +22,7 @@ Ce tutoriel fonctionne pour hy > 0.9.12
 
 ;; les s-expression de bases
 ; Les programmes Lisp sont fait d'expressions symboliques ou sexps qui
-; ressemble à
+; ressemblent à
 (some-function args)
 ; maintenant le quintessentiel hello world
 (print "hello world")
-- 
cgit v1.2.3


From 946b4f260220cc4caaaa9ab7d45109148579ca5f Mon Sep 17 00:00:00 2001
From: Michel Antoine <michel1.antoine@epitech.eu>
Date: Wed, 18 Nov 2015 23:39:51 -0800
Subject: Add French Javascript ES6

---
 fr-fr/javascript-fr.html.markdown | 275 +++++++++++++++++++++++++++++++++-----
 1 file changed, 243 insertions(+), 32 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/javascript-fr.html.markdown b/fr-fr/javascript-fr.html.markdown
index 15478cdb..fd1d40a3 100644
--- a/fr-fr/javascript-fr.html.markdown
+++ b/fr-fr/javascript-fr.html.markdown
@@ -6,23 +6,26 @@ contributors:
 filename: javascript-fr.js
 translators:
     - ['@nbrugneaux', 'https://nicolasbrugneaux.me']
+    - ['Michel Antoine', 'https://github.com/antoin-m']
 lang: fr-fr
 ---
 
 JavaScript a été créé par Brendan Eich, travaillant alors a Netscape, en 1995.
 Le langage avait à l'origine pour but d'être un langage de scripting simple
 pour les sites web, complétant le Java (à ne pas confondre avec JavaScript)
-pour des applications web complexes. Mais son intégration très proche et 
-simple des pages web, ainsi que le support natif des navigateurs a rendu 
-le JavaScript incontournable aujourd'hui tant bien dans le front-end que 
+pour des applications web complexes. Mais son intégration très proche et
+simple des pages web, ainsi que le support natif des navigateurs a rendu
+le JavaScript incontournable aujourd'hui tant bien dans le front-end que
 dans le back-end.
 
 En effet, le JavaScript n'est plus uniquement limité aux navigateurs, grâce à
-Node.JS, un projet qui offre un environnement indépendant dans lequel un 
-interpréteur Javascript, basé sur le célèbre moteur V8 de Google Chrome, 
+Node.JS, un projet qui offre un environnement indépendant dans lequel un
+interpréteur Javascript, basé sur le célèbre moteur V8 de Google Chrome,
 peut être utilisé directement côté serveur pour exécuter des programmes écrits
 en JavaScript.
 
+ECMAScript (la norme du langage Javascript) entre en version 6. Cette version introduit de nombreuses mises à jour tout en restant rétrocompatible. L'implémentation de ces nouvelles fonctionnalités est en cours et celles-ci ne sont donc pas forcément compatibles avec tous les navigateurs.
+
 ```js
 // Les commentaires sont comme en C. Les commentaires mono-ligne commencent par 2 slashs,
 /* et les commentaires sur plusieurs lignes commencent avec slash-étoile
@@ -31,7 +34,7 @@ en JavaScript.
 // Toutes les expressions peuvent finir par ;
 doStuff();
 
-// ... mais n'en n'ont pas forcément besoin, les point-virgules sont ajoutés 
+// ... mais n'en n'ont pas forcément besoin, les point-virgules sont ajoutés
 // lors de l’interprétation aux sauts de ligne, sauf exceptions
 doStuff()
 
@@ -79,6 +82,12 @@ false; // faux
 "abc";
 'Hello, world';
 
+// *ES6:* Les chaines de caractères peuvent être crées en utilisant un modèle
+// entouré des quotes inverses (`) à la place des quotes classiques (' ou ").
+// Les variables sont interprétées avec ${var}
+let banta = "Harry", santa = "Hermione";
+`${banta}, your santa is ${santa}.` // = "Harry, your santa is Hermione."
+
 // La négation utilise le symbole !
 !true; // = false
 !false; // = true
@@ -117,26 +126,34 @@ false; // faux
 
 // Il y a également null et undefined
 null; // utilisé pour une non-valeur
-undefined; // utilisé pour une valeur actuellement non présente (cependant, 
+undefined; // utilisé pour une valeur actuellement non présente (cependant,
            // undefined est aussi une valeur valide)
 
 // false, null, undefined, NaN, 0 and '' sont 'presque-faux' (falsy), tout le reste
 // est 'presque-vrai' (truthy)
 // Notez que 0 est falsy mais '0' est truthy, alors même que 0 == '0' (mais 0 !== '0')
 
+// *ES6:* Introduction d'un nouveau type primitif : Symbol
+var symbol_one = Symbol();
+var symbol_two = Symbol('This is optional description, for debugging');
+typeof symbol_one === 'symbol' // = true
+
+// *ES6:* Un Symbol est immutable et unique
+Symbol() === Symbol() // = false
+Symbol('learnx') === Symbol('learnx') // = false
 
 ///////////////////////////////////
-// 2. Variables, Tableaux et Objets
+// 2. Variables, Tableaux, Objets, Maps et Sets
 
-// Les variables sont déclarées avec le mot clé var. Le typage en JavaScript est 
+// Les variables sont déclarées avec le mot clé var. Le typage en JavaScript est
 // dynamique, donc pas besoin de spécifier le type. L'assignement utilise un seul =.
 var someVar = 5;
 
 // si vous oubliez le mot clé var, vous n'aurez pas d'erreur (sauf en mode strict)
 someOtherVar = 10;
 
-// ... mais la variable aura une portée globale (plus communément trouvé en tant 
-// que "global scope" en anglais), et non pas une portée limitée à la fonction 
+// ... mais la variable aura une portée globale (plus communément trouvé en tant
+// que "global scope" en anglais), et non pas une portée limitée à la fonction
 // dans laquelle vous l'aviez définie.
 
 // Les variables déclarées et non assignées sont undefined par défaut
@@ -145,6 +162,32 @@ var someThirdVar = undefined;
 
 // ... sont deux déclarations identiques.
 
+// Il est possible de déclarer plusieurs variables en séparant leur déclaration
+// avec l'opérateur virgule
+var someFourthVar = 2, someFifthVar = 4;
+
+// *ES6:* Les variables peuvent maintenant être déclarées avec les mots-clés
+// `let` et `const`
+let someSixthVar = 6;
+const someSeventhVar = 7;
+
+// *ES6:* Le mot-clé `let` attache la variable au block de code et non à la fonction
+// à l'inverse de `var`
+for (let i = 0; i < 10; i++) {
+    x += 10;
+}
+i; // = raises ReferenceError
+
+// *ES6:* Les variables "const" doivent être assignées lors de l'initialisation
+const someEighthVar = 7;
+const someNinthVar; // raises SyntaxError
+
+// *ES6:* Modifier une variable constante ne lève par d'erreur mais échoue
+// silencieusement
+const someNinthVar = 9;
+someNinthVar = 10;
+someNinthVar; // = 9
+
 // Il y a des raccourcis pour les opérations mathématiques:
 someVar += 5; // équivalent pour someVar = someVar + 5;
 someVar *= 10; // de même, someVar = someVar * 100;
@@ -165,6 +208,22 @@ myArray.length; // = 4
 // Ajout/Modification à un index spécifique
 myArray[3] = 'Hello';
 
+// *ES6:* Les Arrays peuvent maintenant être déstructurés en utilisant le pattern matching
+var [a, b] = [1, 2];
+var [a, , b] = [1, -2, 2]
+
+a; // = 1
+b; // = 2
+
+// *ES6:* La déstructuration peut échouer silencieusement.
+// Il est aussi possible d'utiliser des valeurs par défaut
+var [a] = [];
+a; // = undefined;
+var [a = 1] = [];
+a; // = 1;
+var [a = 1] = [2];
+a; // = 2;
+
 // Les objets JavaScript sont appelés 'dictionnaires' ou 'maps' dans certains autres
 // langages : ils sont une liste non-ordonnée de paires clé-valeur.
 var myObj = {key1: 'Hello', key2: 'World'};
@@ -179,12 +238,82 @@ myObj['my other key']; // = 4
 // .. ou avec un point si la clé est un identifiant valide.
 myObj.myKey; // = 'myValue'
 
+// *ES6:* Un Symbol peut être utilisé en tant que clé. Puisque ceux-ci sont uniques,
+// le seul moyen d'accéder à la propriété est d'avoir une référence sur ce Symbol.
+myObj["key"] = "public value";
+myObj[Symbol("key")] = "secret value";
+myObj[Symbol("key")]; // = undefined
+
 // Les objets sont eux aussi modifiables.
 myObj.myThirdKey = true;
 
 // Si vous essayez d'accéder à une valeur non-définie, vous obtiendrez undefined
 myObj.myFourthKey; // = undefined
 
+// *ES6:* Comme les Arrays, les Objects peuvent être déstructurés en utilisant le pattern matching
+var {foo} = {foo: "bar"};
+foo // = "bar"
+
+// *ES6:* Les Objects déstructurés peuvent utiliser des noms de variables différents
+// de ceux d'origine grâce au pattern matching
+var {foo, moo: baz} = {foo: "bar", moo: "car"};
+foo // = "bar"
+baz // = "car"
+
+// *ES6:* Il est possible d'utiliser des valeurs par défaut lor de la déstructuration d'un Object
+var {foo="bar"} = {moo: "car"};
+foo // = "bar"
+
+// *ES6:* Une erreur lors de la déstructuration restera silencieuse
+var {foo} = {};
+foo // = undefined
+
+// *ES6:* ES6 ajoute les iterateurs. Pour accéder à l'iterateur de n'importe quel
+// objet il faut utiliser la clé `Symbol.iterator`.
+var iterator1 = myArr[Symbol.iterator]; // = returns iterator function
+
+// *ES6:* Si l'objet possède une valeur à la clé `Symbol.iterator` alors la
+// collection est itérable
+if (typeof myObj[Symbol.iterator] !== "undefined") {
+    console.log("You can iterate over myObj");
+}
+
+// *ES6:* En utilisant la méthode next() de l'iterateur nous recevons un objet
+// avec deux propriétés : `value` et `done`
+var iterator = myArr[Symbol.iterator]; // myArr = [1,2]
+var myArrItem = null;
+
+myArrItem = iterator.next();
+myArrItem.value; // = 1
+myArrItem.done; // = false
+
+myArrItem = iterator.next();
+myArrItem.value; // = 2
+myArrItem.done; // = false
+
+myArrItem = iterator.next();
+myArrItem.value; // = undefined
+myArrItem.done; // = true
+
+// *ES6:* Les Maps sont des objets itérables de type clé-valeur.
+// Il est possible de créer une nouvelle map en utilisant `new Map()`
+var myMap = new Map();
+
+// *ES6:* Il est possible d'ajouter un couple clé-valeur avec la méthode `.set()`,
+// de récupérer une valeur avec `.get()`,
+// de vérifier qu'une clé existe avec `.has()`
+// et enfin de supprimer un couple clé-valeur avec `.delete()`
+
+myMap.set("name", "Douglas");
+myMap.get("name"); // = "Douglas"
+myMap.has("name"); // = true
+myMap.delete("name");
+
+// *ES6:* Les Sets sont des ensembles de valeurs uniques.
+// Il est possible de créer un set avec `new Set()`.
+// Toute valeur non unique est ignorée.
+var mySet = new Set([1,2,2]);
+console.log([...mySet]); // = [1,2]
 
 ///////////////////////////////////
 // 3. Logique et structures de contrôle
@@ -198,7 +327,7 @@ else if (count === 4) {
   // uniquement quand count est 4
 }
 else {
-  // le reste du temps, si ni 3, ni 4. 
+  // le reste du temps, si ni 3, ni 4.
 }
 
 // De même pour while.
@@ -264,7 +393,21 @@ function myFunction(thing){
 }
 myFunction('foo'); // = 'FOO'
 
-// Les fonctions JavaScript sont des objets de première classe, donc peuvent 
+// Attention, la valeur à retourner doit se trouver sur la même ligne que
+// le mot-clé `return` sinon la fonction retournera systématiquement `undefined`
+function myFunction(){
+    return // <- semicolon automatically inserted here
+    {thisIsAn: 'object literal'}
+}
+myFunction(); // = undefined
+
+// *ES6:* Les paramètres des fonctions peuvent désormais avoir des valeurs par défaut
+function default(x, y = 2) {
+    return x + y;
+}
+default(10); // == 12
+
+// Les fonctions JavaScript sont des objets de première classe, donc peuvent
 // être réassignées à d'autres variables et passées en tant que paramètres pour
 // d'autres fonctions
 function myFunction(){
@@ -274,13 +417,17 @@ setTimeout(myFunction, 5000);
 // Note: setTimeout ne fait pas parti du langage, mais les navigateurs ainsi
 // que Node.js le rendent disponible
 
-// Les fonctions n'ont pas nécessairement besoin d'un nom, elles peuvent être 
+// Les fonctions n'ont pas nécessairement besoin d'un nom, elles peuvent être
 // anonymes
 setTimeout(function(){
     // ce code s'exécutera dans 5 secondes
 }, 5000);
 
-// Le Javascript crée uniquement un scope, une portée d'action limitée, pour 
+// *ES6:* Introduction d'un sucre syntaxique permettant de créer
+// une fonction anonyme de la forme : `param => returnValue`.
+setTimeout(() => console.log('5 seconds, are up.'), 5000);
+
+// Le Javascript crée uniquement un scope, une portée d'action limitée, pour
 // les fonctions, et pas dans les autres blocs.
 if (true){
     var i = 5;
@@ -293,7 +440,7 @@ i; // = 5 - et non undefined comme vous pourriez vous y attendre
     var temporary = 5;
     // Nous pouvons accéder au scope global en assignant à l'objet global,
     // qui dans les navigateurs est "window". Il est différent dans Node.js,
-    // le scope global sera en fait local au module dans lequel vous 
+    // le scope global sera en fait local au module dans lequel vous
     // vous trouvez. http://nodejs.org/api/globals.html
     window.permanent = 10;
 })();
@@ -302,8 +449,8 @@ i; // = 5 - et non undefined comme vous pourriez vous y attendre
 temporary; // raises ReferenceError
 permanent; // = 10
 
-// Une des fonctionnalités les plus puissantes de Javascript est le système de 
-// closures. Si une fonction est définie dans une autre fonction, alors la 
+// Une des fonctionnalités les plus puissantes de Javascript est le système de
+// closures. Si une fonction est définie dans une autre fonction, alors la
 // fonction interne aura accès aux variables de la fonction parente, même si
 // celle-ci a déjà finie son exécution.
 function sayHelloInFiveSeconds(name){
@@ -318,6 +465,18 @@ function sayHelloInFiveSeconds(name){
 }
 sayHelloInFiveSeconds('Adam'); // ouvre un popup avec 'Hello, Adam!' dans 5sec
 
+// *ES6:* Les paramètres des fonctions appelées avec un tableau en entré
+// préfixé par `...` vont se peupler avec les éléments du tableau
+function spread(x, y, z) {
+    return x + y + z;
+}
+spread(...[1,2,3]); // == 6
+
+// *ES6:* Les fonctions peuvent recevoir les paramètres dans un tableau en utilisant l'opérateur `...`
+function spread(x, y, z) {
+    return x + y + z;
+}
+spread(...[1,2,3]); // == 6
 
 ///////////////////////////////////
 // 5. Encore plus à propos des Objets; Constructeurs and Prototypes
@@ -340,7 +499,7 @@ myObj = {
 };
 myObj.myFunc(); // = 'Hello world!'
 
-// La valeur de "this" change de par l'endroit où la fonction est appelée, et 
+// La valeur de "this" change de par l'endroit où la fonction est appelée, et
 // non de l'endroit où elle est définie. Donc elle ne fonctionnera pas si elle
 // est appelée hors du contexte l'objet.
 var myFunc = myObj.myFunc;
@@ -356,7 +515,7 @@ myObj.myOtherFunc = myOtherFunc;
 myObj.myOtherFunc(); // = 'HELLO WORLD!'
 
 // Le contexte correspond à la valeur de "this".
-// Nous pouvons aussi spécifier un contexte, forcer la valeur de "this, 
+// Nous pouvons aussi spécifier un contexte, forcer la valeur de "this,
 // pour une fonction quand elle est appelée grâce à "call" ou "apply".
 var anotherFunc = function(s){
     return this.myString + s;
@@ -371,19 +530,19 @@ Math.min(42, 6, 27); // = 6
 Math.min([42, 6, 27]); // = NaN (uh-oh!)
 Math.min.apply(Math, [42, 6, 27]); // = 6
 
-// Mais, "call" and "apply" fonctionnenent uniquement au moment de l'appel de la 
-// fonction. Pour lier le contexte de façon permanente, nous pouvons utiliser 
+// Mais, "call" and "apply" fonctionnenent uniquement au moment de l'appel de la
+// fonction. Pour lier le contexte de façon permanente, nous pouvons utiliser
 // "bind" pour garder une référence à la fonction avec ce "this".
 var boundFunc = anotherFunc.bind(myObj);
 boundFunc(' And Hello Saturn!'); // = 'Hello World! And Hello Saturn!'
 
-// "bind" peut aussi être utilisé pour créer une application partielle de la 
+// "bind" peut aussi être utilisé pour créer une application partielle de la
 // fonction (curry)
 var product = function(a, b){ return a * b; }
 var doubler = product.bind(this, 2);
 doubler(8); // = 16
 
-// Lorsque vous appelez une fonction avec le mot clé "new", un nouvel objet est 
+// Lorsque vous appelez une fonction avec le mot clé "new", un nouvel objet est
 // crée et mis à disposition de la fonction via "this". Ces fonctions sont
 // communément appelées constructeurs.
 var MyConstructor = function(){
@@ -395,8 +554,8 @@ myNewObj.myNumber; // = 5
 // Chaque objet en Javascript a un "prototype". Quand vous essayez d'accéder à
 // une propriété que l'objet n'a pas, l'interpréteur va regarder son prototype.
 
-// Quelques implémentations de JS vous laissent accéder au prototype avec la 
-// propriété "magique" __proto__. Ceci peut être utile, mais n'est pas standard 
+// Quelques implémentations de JS vous laissent accéder au prototype avec la
+// propriété "magique" __proto__. Ceci peut être utile, mais n'est pas standard
 // et ne fonctionne pas dans certains des navigateurs actuels.
 var myObj = {
     myString: 'Hello world!'
@@ -478,7 +637,7 @@ String.prototype.firstCharacter = function(){
 'abc'.firstCharacter(); // = 'a'
 
 // C'est très souvent utilisé pour le "polyfilling", qui implémente des nouvelles
-// fonctionnalités de JavaScript dans de plus anciens environnements, tels que 
+// fonctionnalités de JavaScript dans de plus anciens environnements, tels que
 // les vieux navigateurs.
 
 //Par exemple, Object.create est assez récent, mais peut être implémenté grâce à
@@ -492,31 +651,83 @@ if (Object.create === undefined){ // pour ne pas reécrire si la fonction existe
         return new Constructor();
     }
 }
+
+// *ES6:* Les objets peuvent être équipés de proxies qui permettent d'intercepter
+// les actions sur leurs propriétés. Voici comment créer un proxy sur un objet :
+var proxyObject = new Proxy(object, handler);
+
+// *ES6:* Les méthodes d'un objet handler sont appelées lors de l'interception d'une action.
+// La méthode `.get()` est appelée à chaque lecture d'une propriété
+// tandis que la méthode `.set()` est appelée à chaque écriture.
+var handler = {
+  get (target, key) {
+    console.info('Get on property' + key);
+    return target[key];
+  },
+  set (target, key, value) {
+    console.info('Set on property' + key);
+    return true;
+  }
+}
+
+// *ES6:* Les classes peuvent désormais être définies en utilisant le mot-clé `class`.
+// Le constructeur s'appelle `constructor` et les méthodes statiques utilisent le mot-clé `static`
+class Foo {
+    constructor() {console.log("constructing Foo");}
+    bar() {return "bar";}
+    static baz() {return "baz";}
+}
+
+// *ES6:* Les objets issus des classes sont initialisés avec le mot-clé `new`.
+// Il est possible d'hériter d'une classe avec le mot-clé `extends`
+var FooObject = new Foo(); // = "constructing Foo"
+class Zoo extends Foo {}
+
+// *ES6:* Les méthodes statiques doivent être appelées par la classe, les autres méthodes par l'objet
+Foo.baz() // = "baz"
+FooObject.bar() // = "bar"
+
+// *ES6:* Il est désormais possible d'exporter des valeurs en tant que module.
+// Les exports peuvent être n'importe quel objet, valeur ou fonction.
+var api = {
+  foo: "bar",
+  baz: "ponyfoo"
+};
+export default api;
+
+// *ES6:* La syntaxe `export default` permet d'exporter l'objet sans en changer le nom.
+// Il y a plusieurs façons de l'importer:
+import coolapi from "api"; // = importe le module dans la variable `coolapi`
+import {foo, baz} from "api"; // = importe les attributs `foo` et `baz` du module
+import {foo as moo, baz} from "api"; // = importe les attributs `foo` (en le renommant `moo`) et `baz` du module
+import _, {map} from "api"; // = importe les exports par défaut ET `map`
+import * as coolapi from "api"; // = importe le namespace global du module
+
 ```
 
 ## Pour aller plus loin (en anglais)
 
 The [Mozilla Developer
 Network](https://developer.mozilla.org/fr-FR/docs/Web/JavaScript) expose une
-excellente documentation pour le Javascript dans les navigateurs. Et contient 
+excellente documentation pour le Javascript dans les navigateurs. Et contient
 également un wiki pour s'entraider.
 
 MDN's [A re-introduction to
 JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
 recouvre les principaux sujets vus ici. Le guide est délibérément uniquement
-à propos du JavaScript, et ne parle pas des navigateurs; pour cela, dirigez vous 
+à propos du JavaScript, et ne parle pas des navigateurs; pour cela, dirigez vous
 plutôt ici :
 [Document Object
 Model](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core)
 
-[Learn Javascript by Example and with Challenges](http://www.learneroo.com/modules/64/nodes/350) quelques challenges. 
+[Learn Javascript by Example and with Challenges](http://www.learneroo.com/modules/64/nodes/350) quelques challenges.
 
 [JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/) is an in-depth
 un guide pour vous éviter les faux-amis dans le JavaScript.
 
-[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/) un classique. A lire. 
+[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/) un classique. A lire.
 
-En addition aux contributeurs de cet article, du contenu provient du 
+En addition aux contributeurs de cet article, du contenu provient du
 "Python tutorial" de Louie Dinh, et de [JS
 Tutorial](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
 sur le réseau Mozilla.
-- 
cgit v1.2.3


From f2d6b50bd439e971386f775228d2b9960daa0efd Mon Sep 17 00:00:00 2001
From: Michel Antoine <michel1.antoine@epitech.eu>
Date: Wed, 18 Nov 2015 23:54:39 -0800
Subject: Remove the iterator part and add for..in and for..of

---
 fr-fr/javascript-fr.html.markdown | 43 +++++++++++++++------------------------
 1 file changed, 16 insertions(+), 27 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/javascript-fr.html.markdown b/fr-fr/javascript-fr.html.markdown
index fd1d40a3..f1977dac 100644
--- a/fr-fr/javascript-fr.html.markdown
+++ b/fr-fr/javascript-fr.html.markdown
@@ -268,33 +268,6 @@ foo // = "bar"
 var {foo} = {};
 foo // = undefined
 
-// *ES6:* ES6 ajoute les iterateurs. Pour accéder à l'iterateur de n'importe quel
-// objet il faut utiliser la clé `Symbol.iterator`.
-var iterator1 = myArr[Symbol.iterator]; // = returns iterator function
-
-// *ES6:* Si l'objet possède une valeur à la clé `Symbol.iterator` alors la
-// collection est itérable
-if (typeof myObj[Symbol.iterator] !== "undefined") {
-    console.log("You can iterate over myObj");
-}
-
-// *ES6:* En utilisant la méthode next() de l'iterateur nous recevons un objet
-// avec deux propriétés : `value` et `done`
-var iterator = myArr[Symbol.iterator]; // myArr = [1,2]
-var myArrItem = null;
-
-myArrItem = iterator.next();
-myArrItem.value; // = 1
-myArrItem.done; // = false
-
-myArrItem = iterator.next();
-myArrItem.value; // = 2
-myArrItem.done; // = false
-
-myArrItem = iterator.next();
-myArrItem.value; // = undefined
-myArrItem.done; // = true
-
 // *ES6:* Les Maps sont des objets itérables de type clé-valeur.
 // Il est possible de créer une nouvelle map en utilisant `new Map()`
 var myMap = new Map();
@@ -347,6 +320,22 @@ for (var i = 0; i < 5; i++){
     // sera exécutée 5 fois
 }
 
+// La boucle for...in permet d'itérer sur les noms des propriétés d'un objet
+var description = "";
+var person = {fname:"Paul", lname:"Ken", age:18};
+for (var x in person){
+    description += person[x] + " ";
+}
+description; // = "Paul Ken 18 "
+
+// *ES6:* La boucle for...of permet d'itérer sur les propriétés d'un objet
+var description = "";
+var person = {fname:"Paul", lname:"Ken", age:18};
+for (var x of person){
+    description += x + " ";
+}
+description; // = "Paul Ken 18 "
+
 // && est le "et" logique, || est le "ou" logique
 if (house.size === 'big' && house.colour === 'blue'){
     house.contains = 'bear';
-- 
cgit v1.2.3


From 7933ea3ce029a3418bac04210e0dd7f0f27e275d Mon Sep 17 00:00:00 2001
From: Gnomino <gnomino@gnomino.eu>
Date: Sat, 21 Nov 2015 19:08:39 +0100
Subject: Applies a1ed02d6fad2b39137f52c6a04264a59e237d747 to translations

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

(limited to 'fr-fr')

diff --git a/fr-fr/python3-fr.html.markdown b/fr-fr/python3-fr.html.markdown
index 04d0a55d..3d60157c 100644
--- a/fr-fr/python3-fr.html.markdown
+++ b/fr-fr/python3-fr.html.markdown
@@ -627,7 +627,7 @@ Human.grunt()   # => "*grunt*"
 
 # On peut importer des modules
 import math
-print(math.sqrt(16))  # => 4
+print(math.sqrt(16))  # => 4.0
 
 # On peut importer des fonctions spécifiques d'un module
 from math import ceil, floor
-- 
cgit v1.2.3


From 3d19a951926f52b7cafca301919233f4cda513ff Mon Sep 17 00:00:00 2001
From: Daniel Imms <tyriar@tyriar.com>
Date: Mon, 30 Nov 2015 12:48:13 -0800
Subject: [TypeScript/fr] Make TypeScript indentation consistently 2 spaces

fr version of #2041
---
 fr-fr/typescript-fr.html.markdown | 58 +++++++++++++++++++--------------------
 1 file changed, 29 insertions(+), 29 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/typescript-fr.html.markdown b/fr-fr/typescript-fr.html.markdown
index b8807104..52d34650 100644
--- a/fr-fr/typescript-fr.html.markdown
+++ b/fr-fr/typescript-fr.html.markdown
@@ -87,22 +87,22 @@ mySearch = function(src: string, sub: string) {
 
 // Les membres des classes sont publiques par défaut.
 class Point {
-    // Propriétés
-    x: number;
-
-    // Constructeur - Les mots clés "public" et "private" dans ce contexte
-    //  génèrent le code de la propriété et son initialisation dans le
-    // constructeur. Ici, "y" sera défini de la même façon que "x",
-    // mais avec moins de code. Les valeurs par défaut sont supportées.
-    constructor(x: number, public y: number = 0) {
-        this.x = x;
-    }
+  // Propriétés
+  x: number;
+
+  // Constructeur - Les mots clés "public" et "private" dans ce contexte
+  //  génèrent le code de la propriété et son initialisation dans le
+  // constructeur. Ici, "y" sera défini de la même façon que "x",
+  // mais avec moins de code. Les valeurs par défaut sont supportées.
+  constructor(x: number, public y: number = 0) {
+    this.x = x;
+  }
 
-    // Fonctions
-    dist() { return Math.sqrt(this.x * this.x + this.y * this.y); }
+  // Fonctions
+  dist() { return Math.sqrt(this.x * this.x + this.y * this.y); }
 
-    // Membres statiques
-    static origin = new Point(0, 0);
+  // Membres statiques
+  static origin = new Point(0, 0);
 }
 
 var p1 = new Point(10 ,20);
@@ -110,17 +110,17 @@ var p2 = new Point(25); // y sera 0
 
 // Héritage
 class Point3D extends Point {
-    constructor(x: number, y: number, public z: number = 0) {
-        // Un appel explicite au constructeur de la super classe
-        // est obligatoire.
-        super(x, y);
-    }
+  constructor(x: number, y: number, public z: number = 0) {
+    // Un appel explicite au constructeur de la super classe
+    // est obligatoire.
+    super(x, y);
+  }
 
-    // Redéfinition
-    dist() {
-        var d = super.dist();
-        return Math.sqrt(d * d + this.z * this.z);
-    }
+  // Redéfinition
+  dist() {
+    var d = super.dist();
+    return Math.sqrt(d * d + this.z * this.z);
+  }
 }
 
 // Modules, "." peut être utilisé comme un séparateur de sous modules.
@@ -144,19 +144,19 @@ var s2 = new G.Square(10);
 // Génériques
 // Classes
 class Tuple<T1, T2> {
-    constructor(public item1: T1, public item2: T2) {
-    }
+  constructor(public item1: T1, public item2: T2) {
+  }
 }
 
 // Interfaces
 interface Pair<T> {
-    item1: T;
-    item2: T;
+  item1: T;
+  item2: T;
 }
 
 // Et fonctions
 var pairToTuple = function<T>(p: Pair<T>) {
-    return new Tuple(p.item1, p.item2);
+  return new Tuple(p.item1, p.item2);
 };
 
 var tuple = pairToTuple({ item1:"hello", item2:"world"});
-- 
cgit v1.2.3


From 0fbf289e3cbce3f2b6e830d5dcf1c8d3685a88a1 Mon Sep 17 00:00:00 2001
From: Adam Bard <github@adambard.com>
Date: Wed, 6 Jan 2016 03:14:04 +0800
Subject: Update go-fr.html.markdown

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

(limited to 'fr-fr')

diff --git a/fr-fr/go-fr.html.markdown b/fr-fr/go-fr.html.markdown
index 16558e7e..9d8bef70 100644
--- a/fr-fr/go-fr.html.markdown
+++ b/fr-fr/go-fr.html.markdown
@@ -3,7 +3,7 @@ name: Go
 category: language
 language: Go
 lang: fr-fr
-filename: learngo.go
+filename: learngo-fr.go
 contributors:
     - ["Sonia Keys", "https://github.com/soniakeys"]
     - ["Christopher Bess", "https://github.com/cbess"]
-- 
cgit v1.2.3


From e91cb98abedd979f67acdc08dd7cb81b75f317cc Mon Sep 17 00:00:00 2001
From: Cedric HT <cedric_hothanh@bitbucket.org>
Date: Sun, 17 Jan 2016 19:38:14 +0100
Subject: Translated Wolfram tutorial to french

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

(limited to 'fr-fr')

diff --git a/fr-fr/wolfram-fr.html.markdown b/fr-fr/wolfram-fr.html.markdown
new file mode 100644
index 00000000..d297bd74
--- /dev/null
+++ b/fr-fr/wolfram-fr.html.markdown
@@ -0,0 +1,166 @@
+---
+language: wolfram
+contributors:
+    - ["hyphz", "http://github.com/hyphz/"]
+    - ["altaris", "http://github.com/altaris/"]
+filename: learnwolfram.nb
+---
+
+Le langage Wolfram est utilisé dans les programmes suivants :
+* La ligne de commandes interactive noyau du Raspberry Pi, mais elle ne peut pas
+gérer des éléments graphiques.
+* _Mathematica_, un éditeur de texte riche spécialisé pour les mathématiques :
+appuyer sur `Shift + Entrée` dans une cellule de code crée un nouvelle cellule 
+contenant le résultat.
+* _Wolfram Wokbench_, une variante d'Eclipse spécialisée pour le langage
+Wolfram.
+
+Ce code d'exemple peut être utilisé et modifié dans ces logiciels. Cependant, le
+copier-coller directement dans Mathematica peut causer des problèmes de
+formatage, car il ne contient aucune information de mise en page.
+
+```
+(* Ceci est un commentaire *)
+
+(* Dans Mathematica, au lieu d'utiliser ces commentaires, vous pouvez créer des
+   cellules de texte et insérer de jolies images *)
+
+(* Saisissez une opération et appuyez sur Shift + Entrée pour obtenir le
+   résultat *)
+2*2              (* 4 *)
+5+8              (* 13 *)
+
+(* Appels de fonction *)
+(* Le langage Wolfram est sensible à la casse *)
+Sin[Pi/2]        (* 1 *)
+
+(* Syntaxe alternative pour les appels de fonction à 1 paramètre *)
+Sin@(Pi/2)       (* 1 *)
+(Pi/2) // Sin    (* 1 *)
+
+(* Dans le langage Wolfram, toutes les expressions sont en réalité des appels de
+   fonction *)
+Times[2, 2]      (* 4 *)
+Plus[5, 8]       (* 13 *)
+
+(* Utiliser une variable pour la première fois la déclare globalement *)
+x = 5            (* 5 *)
+x == 5           (* True, l'assignation et le test d'égalité est écrit comme
+                    dans le C *)
+x                (* 5 *)
+x = x + 5        (* 10 *)
+x                (* 10 *)
+Set[x, 20]       (* TOUT est un appel de fonction, TOUUUUUUUUT *)
+x                (* 20 *)
+
+(* Le langage Wolfram effectue des manipulations symboliques, donc utiliser des
+   variables non déclarées n'est pas illégal *)
+cow + 5          (* 5 + cow, comme cow n'est pas déclarée, l'évaluation
+                    s'arrête là *)
+cow + 5 + 10     (* 15 + cow, on évalue ce qu'on peut... *)
+%                (* 15 + cow, % représente le dernier résultat *)
+% - cow          (* 15, les variables non déclarées peuvent quand même
+                    s'annuler *)
+moo = cow + 5    (* Attention : moo est ici une expression et non un nombre *)
+
+(* Déclaration d'une fonction *)
+Double[x_] := x * 2    (* Le symbole := empêche l'évaluation immédiate du terme
+                          à droite *)
+Double[10]             (* 20 *)
+Double[Sin[Pi/2]]      (* 2 *)
+Double @ Sin @ (Pi/2)  (* 2, Utiliser @ évite les paquets de crochets
+                            fermants si moches *)
+(Pi/2) // Sin // Double(* 2, Utiliser // permet d'écrire les fonctions dans
+                             l'ordre d'appel *)
+
+(* Pour la programmation impérative, utiliser ; pour séparer les expressions *)
+MyFirst[] := (Print@"Hello"; Print@"World")  (* Les parenthèses sont nécessaires
+                                                car ; est prioritaire sur := *)
+MyFirst[]                                    (* Hello World *)
+
+(* Boucles For à la C *)
+PrintTo[x_] := For[y=0, y<x, y++, (Print[y])]  (* L'évaluation des boucles For
+                                                  se fait comme dans le C *)
+PrintTo[5]                                     (* 0 1 2 3 4 *)
+
+(* Boucles While *)
+x = 0; While[x < 2, (Print@x; x++)]     (* De nouveau, comme dans le C *)
+
+(* Expressions conditionnelles et If *)
+x = 8; If[x==8, Print@"Yes", Print@"No"]   (* If [condition, si vrai,
+                                              si faux] *)
+Switch[x, 2, Print@"Two", 8, Print@"Yes"]  (* Switch par valeur *)
+Which[x==2, Print@"No", x==8, Print@"Yes"] (* Switch du type if, else if,
+                                              else if, ..., else *)
+
+(* Les variables autres que les paramètres de fonctions sont par défaut
+   globales, même à l'intérieur des fonctions *)
+y = 10             (* 10, y est une variable globale *)
+PrintTo[5]         (* 0 1 2 3 4 *)
+y                  (* 5, y a été modifiée par PrintTo *)
+x = 20             (* 20, x est une variable globale *)
+PrintTo[5]         (* 0 1 2 3 4 *)
+x                  (* 20, dans PrintTo, le paramètre x masque la variable
+                      globale x *)
+
+(* La fonction Module permet d'utiliser des variables locales *)
+BetterPrintTo[x_] := Module[{y}, (For[y=0, y<x, y++, (Print@y)])]
+y = 20             (* y est une variable globale *)
+BetterPrintTo[5]   (* 0 1 2 3 4 *)
+y                  (* 20, y n'a pas été modifiée car le y du Module masque le
+                          y global. C'est bien mieux comme ca ! *)
+
+(* Module permet de faire des déclarations globales aussi *)
+Module[{count}, count=0;        (* count est une variable locale *)
+  (IncCount[] := ++count);      (* Ce module déclare des fonctions, mais elles
+                                   ne sont globales. Elles ont cependant accès
+                                   aux variables locales au module. *)
+  (DecCount[] := --count)]
+count              (* count, car il n'y a pas de variable globale nommée
+                      count *)
+IncCount[]         (* 1, la fonction utilise la variable count du module *)
+IncCount[]         (* 2, le précédent appel de IncCount a modifié count *)
+DecCount[]         (* 1 *)
+count              (* count, car il n'existe toujours pas de variable globale
+                      nommé count *)
+
+(* Listes *)
+myList = {1, 2, 3, 4}     (* {1, 2, 3, 4} *)
+myList[[1]]               (* 1, les indexes commencent à 1 et non 0 !!! *)
+Map[Double, myList]       (* {2, 4, 6, 8}, appliquer une fonction à une liste de
+                             manière fonctionnelle *)
+Double /@ myList          (* {2, 4, 6, 8}, syntaxe abrégée de la ligne
+                             précédente *)
+Scan[Print, myList]       (* 1 2 3 4, boucle impérative sur une liste *)
+Fold[Plus, 0, myList]     (* 10 (0+1+2+3+4) *)
+FoldList[Plus, 0, myList] (* {0, 1, 3, 6, 10}, variante de la fonction
+                             précédente qui donne aussi les résultats
+                             intermédiaires *)
+Append[myList, 5]         (* {1, 2, 3, 4, 5}, myList n'est pas modifiée... *)
+Prepend[myList, 5]        (* {5, 1, 2, 3, 4}, ... mais elle peut l'être en 
+                             écrivant "myList = " *)
+Join[myList, {3, 4}]      (* {1, 2, 3, 4, 3, 4} *)
+myList[[2]] = 5           (* {1, 5, 3, 4}, ceci modifie bien la liste *)
+
+(* Tables associatives, ou dictionnaires *)
+myHash = <|"Green" -> 2, "Red" -> 1|>   (* Crée une table associative *)
+myHash[["Green"]]                       (* 2, l'utilise *)
+myHash[["Green"]] := 5                  (* 5, la modifie *)
+myHash[["Puce"]] := 3.5                 (* 3.5, l'étend *)
+KeyDropFrom[myHash, "Green"]            (* Supprime la clé "Green" *)
+Keys[myHash]                            (* {Red} *)
+Values[myHash]                          (* {1} *)
+
+(* Pour finir, toute bonne démonstration du langage Wolfram contient un
+   Manipulate ! *)
+Manipulate[y^2, {y, 0, 20}] (* Crée une interface graphique interactive qui
+                               affiche y^2, permettant à l'utilisateur de
+                               modifier la valeur de y grâce à un contrôle
+                               allant de 0 à 20. Ne fonctionne que si le
+                               logiciel utilisé gère les éléments graphique. *)
+```
+
+## Envie d'aller plus loin ?
+
+* [Documentation du langage Wolfram (en anglais)]
+(http://reference.wolfram.com/language/)
\ No newline at end of file
-- 
cgit v1.2.3


From c70f53aabea745d4450aa51abdc33aa1ac51bdd2 Mon Sep 17 00:00:00 2001
From: Cedric HT <cedric_hothanh@bitbucket.org>
Date: Sun, 17 Jan 2016 21:53:21 +0100
Subject: Translated make tutorial to french

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

(limited to 'fr-fr')

diff --git a/fr-fr/make-fr.html.markdown b/fr-fr/make-fr.html.markdown
new file mode 100644
index 00000000..8643ba45
--- /dev/null
+++ b/fr-fr/make-fr.html.markdown
@@ -0,0 +1,266 @@
+---
+language: make
+contributors:
+	- ["Robert Steed", "https://github.com/robochat"]
+	- ["altaris", "https://github.com/altaris"]
+filename: Makefile
+---
+
+Un makefile est un fichier qui définit un ensemble de règles liées entre elles
+pour créer une ou plusieurs cibles. L'idée est d'effectuer le moins de travail
+possible afin de mettre à jour la ou les cibles en fonction des dépendances.
+
+Écrit en un week-end par Stuart Feldman en 1976, le make et les
+makefiles sont encore très utilisés (principalement dans les systèmes Unix),
+malgré la concurrence et les critiques faites à son égard.
+
+Le programme make a plusieurs variantes. Dans ce tutoriel, nous utiliserons
+l'implémentation standard : GNU make.
+
+```make
+
+# Ceci est un commentaire.
+
+# Un makefile devrait être nommé "Makefile" (avec ou sans la
+# majuscule). Il peut alors être exécuté par `make <cible>`.
+# Ce nommage n'est toutefois pas obligatoire : utiliser
+# `make -f "fichier" <cible>`.
+
+# ATTENTION : l'indentation est quant à elle obligatoire, et se fait avec des
+# tabulations, pas avec des espaces !
+
+#-----------------------------------------------------------------------
+# Les basiques
+#-----------------------------------------------------------------------
+
+# Une règle. Elle ne sera exécutée que si fichier0.txt n'existe pas.
+file0.txt:
+	echo "truc" > fichier0.txt
+	# Même les commentaires sont transférés dans le terminal.
+
+# Cette règle ne sera exécutée que si fichier0.txt est plus récent que
+# fichier1.txt.
+file1.txt: fichier0.txt
+	cat fichier0.txt > fichier1.txt
+	# Utiliser les même guillemets que dans un terminal.
+	@cat fichier0.txt >> fichier1.txt
+	# @ empêche l'affichage de la sortie texte d'une commande.
+	-@echo 'hello'
+	# - signifie que la règle devrait continuer à être exécutée si cette
+	# commande échoue.
+
+# Un règle peut avoir plusieurs cibles et plusieurs dépendances.
+file2.txt fichier3.txt: fichier0.txt fichier1.txt
+	touch fichier2.txt
+	touch fichier3.txt
+
+# Make affichera un avertissement si le makefile comporte plusieurs règles pour
+# une même cible. Cependant les règles vides ne comptent pas, et peuvent être
+# utilisées pour ajouter des dépendances plus facilement.
+
+#-----------------------------------------------------------------------
+# Fausses règles
+#-----------------------------------------------------------------------
+
+# Une fausse règle est un règle qui ne correspond pas à un fichier.
+# Par définition, elle ne peut pas être à jour, et donc make l’exécutera à
+# chaque demande.
+all: maker process
+
+# La déclaration des règles peut être faite dans n'importe quel ordre.
+maker:
+	touch ex0.txt ex1.txt
+
+# On peut transformer une règle en fausse règle grâce à la cible spéciale
+# suivante :
+.PHONY: all maker process
+
+# Un règle dépendante d'une fausse règle sera toujours exécutée.
+ex0.txt ex1.txt: maker
+
+# Voici quelques exemples fréquents de fausses règles : all, make, clean,
+# install...
+
+#-----------------------------------------------------------------------
+# Variables automatiques et wildcards
+#-----------------------------------------------------------------------
+
+# Utilise un wildcard pour des noms de fichier
+process: fichier*.txt
+	@echo $^    # $^ est une variable contenant la liste des dépendances de la
+				# cible actuelle.
+	@echo $@    # $@ est le nom de la cible actuelle. En cas de cibles
+				# multiples, $@ est le nom de la cible ayant causé l'exécution
+				# de cette règle.
+	@echo $<    # $< contient la première dépendance.
+	@echo $?    # $? contient la liste des dépendances qui ne sont pas à jour.
+	@echo $+    # $+ contient la liste des dépendances avec d'éventuels
+				# duplicatas, contrairement à $^.
+	@echo $|    # $| contient la liste des cibles ayant préséance sur la cible
+				# actuelle.
+
+# Même si la définition de la règle est scindée en plusieurs morceaux, $^
+# listera toutes les dépendances indiquées.
+process: ex1.txt fichier0.txt
+# Ici, fichier0.txt est un duplicata dans $+.
+
+#-----------------------------------------------------------------------
+# Pattern matching
+#-----------------------------------------------------------------------
+
+# En utilisant le pattern matching, on peut par exemple créer des règles pour
+# convertir les fichiers d'un certain format dans un autre.
+%.png: %.svg
+	inkscape --export-png $^
+
+# Make exécute une règle même si le fichier correspondant est situé dans un sous
+# dossier. En cas de conflit, la règle avec la meilleure correspondance est
+# choisie.
+small/%.png: %.svg
+	inkscape --export-png --export-dpi 30 $^
+
+# Dans ce type de conflit (même cible, même dépendances), make exécutera la
+# dernière règle déclarée...
+%.png: %.svg
+	@echo cette règle est choisie
+
+# Dans ce type de conflit (même cible mais pas les mêmes dépendances), make
+# exécutera la première règle pouvant être exécutée.
+%.png: %.ps
+	@echo cette règle n\'est pas choisie si *.svg et *.ps sont présents
+
+# Make a des règles pré établies. Par exemple, il sait comment créer la cible
+# *.o à partir de *.c.
+
+# Les makefiles plus vieux utilisent un matching par extension de fichier.
+.png.ps:
+	@echo cette règle est similaire à une règle par pattern matching
+
+# Utiliser cette syntaxe pour déclarer une règle comme règle avec matching par
+# extension de fichier.
+.SUFFIXES: .png
+
+#-----------------------------------------------------------------------
+# Variables, ou macros
+#-----------------------------------------------------------------------
+
+# Les variables sont des chaînes de caractères.
+
+variable = Ted
+variable2="Sarah"
+
+echo:
+	@echo $(variable)
+	@echo ${variable2}
+	@echo $variable    # Cette syntaxe signifie $(n)ame et non pas $(variable) !
+	@echo $(variable3) # Les variables non déclarées valent "" (chaîne vide).
+
+# Les variables sont déclarées de 4 manières, de la plus grande priorité à la
+# plus faible :
+# 1 : dans la ligne de commande qui invoque make,
+# 2 : dans le makefile,
+# 3 : dans les variables d’environnement du terminal qui invoque make,
+# 4 : les variables prédéfinies.
+
+# Assigne la variable si une variable d’environnement du même nom n'existe pas
+# déjà.
+variable4 ?= Jean
+
+# Empêche cette variable d'être modifiée par la ligne de commande.
+override variable5 = David
+
+# Concatène à une variable (avec un espace avant).
+variable4 +=gris
+
+# Assignations de variable pour les règles correspondant à un pattern
+# (spécifique à GNU make).
+*.png: variable2 = Sara # Pour toutes les règles correspondant à *.png, et tous
+						# leurs descendants, la variable variable2 vaudra
+						# "Sara".
+# Si le jeux des dépendances et descendances devient vraiment trop compliqué,
+# des inconsistances peuvent survenir.
+
+# Certaines variables sont prédéfinies par make :
+affiche_predefinies:
+	echo $(CC)
+	echo ${CXX}
+	echo $(FC)
+	echo ${CFLAGS}
+	echo $(CPPFLAGS)
+	echo ${CXXFLAGS}
+	echo $(LDFLAGS)
+	echo ${LDLIBS}
+
+#-----------------------------------------------------------------------
+# Variables : le retour
+#-----------------------------------------------------------------------
+
+# Les variables sont évaluées à chaque instance, ce qui peut être coûteux en
+# calculs. Pour parer à ce problème, il existe dans GNU make une seconde
+# manière d'assigner des variables pour qu'elles ne soient évaluées qu'une seule
+# fois seulement.
+
+var := wesh
+var2 ::=  $(var) mec # := et ::= sont équivalents.
+
+# Ces variables sont évaluées procéduralement (i.e. dans leur ordre
+# d'apparition), contrairement au règles par exemple !
+
+# Ceci ne fonctionne pas.
+var3 ::= $(var4) et fais de beaux rêves
+var4 ::= bonne nuit
+
+#-----------------------------------------------------------------------
+# Fonctions
+#-----------------------------------------------------------------------
+
+# Make a une multitude de fonctions. La syntaxe générale est
+# $(fonction arg0,arg1,arg2...).
+
+# Quelques exemples :
+
+fichiers_source = $(wildcard *.c */*.c)
+fichiers_objet  = $(patsubst %.c,%.o,$(fichiers_source))
+
+ls: * src/*
+	@echo $(filter %.txt, $^)
+	@echo $(notdir $^)
+	@echo $(join $(dir $^),$(notdir $^))
+
+#-----------------------------------------------------------------------
+# Directives
+#-----------------------------------------------------------------------
+
+# Inclut d'autres makefiles.
+include meuh.mk
+
+# Branchements conditionnels.
+sport = tennis
+report:
+ifeq ($(sport),tennis)                  # Il y a aussi ifneq.
+	@echo 'jeu, set et match'
+else
+	@echo "C'est pas ici Wimbledon ?"
+endif
+
+truc = true
+ifdef $(truc)							# Il y a aussi ifndef.
+	machin = 'salut'
+endif
+```
+
+## Quelques références
+
+### En français
+
++ [Introduction à Makefile (developpez.com)]
+(http://gl.developpez.com/tutoriel/outil/makefile/),
++ [Compilez sous GNU/Linux ! (openclassrooms)]
+(https://openclassrooms.com/courses/compilez-sous-gnu-linux).
+
+### En anglais
+
++ [Documentation de GNU make](https://www.gnu.org/software/make/manual/),
++ [Software carpentry tutorial](http://swcarpentry.github.io/make-novice/),
++ Learn C the hard way [ex2](http://c.learncodethehardway.org/book/ex2.html)
+[ex28](http://c.learncodethehardway.org/book/ex28.html).
\ No newline at end of file
-- 
cgit v1.2.3


From 5c4eba5ef34593a0c6425da64f6a0d7688fca3d2 Mon Sep 17 00:00:00 2001
From: Cedric HT <cedric_hothanh@bitbucket.org>
Date: Sun, 17 Jan 2016 21:54:51 +0100
Subject: Removed tabs in header

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

(limited to 'fr-fr')

diff --git a/fr-fr/make-fr.html.markdown b/fr-fr/make-fr.html.markdown
index 8643ba45..405c47cd 100644
--- a/fr-fr/make-fr.html.markdown
+++ b/fr-fr/make-fr.html.markdown
@@ -1,8 +1,8 @@
 ---
 language: make
 contributors:
-	- ["Robert Steed", "https://github.com/robochat"]
-	- ["altaris", "https://github.com/altaris"]
+    - ["Robert Steed", "https://github.com/robochat"]
+    - ["altaris", "https://github.com/altaris"]
 filename: Makefile
 ---
 
-- 
cgit v1.2.3


From a4e4b76afdb538fa577db8823bb7349ff7872722 Mon Sep 17 00:00:00 2001
From: Cedric HT <cedric_hothanh@bitbucket.org>
Date: Mon, 18 Jan 2016 12:07:20 +0100
Subject: Corrections to make-fr

... according to pull request comments:
- completed header;
- some typos;
- finished translating target names.
---
 fr-fr/make-fr.html.markdown | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/make-fr.html.markdown b/fr-fr/make-fr.html.markdown
index 405c47cd..b8255ce7 100644
--- a/fr-fr/make-fr.html.markdown
+++ b/fr-fr/make-fr.html.markdown
@@ -3,7 +3,8 @@ language: make
 contributors:
     - ["Robert Steed", "https://github.com/robochat"]
     - ["altaris", "https://github.com/altaris"]
-filename: Makefile
+filename: Makefile-fr
+lang: fr-fr
 ---
 
 Un makefile est un fichier qui définit un ensemble de règles liées entre elles
@@ -34,23 +35,23 @@ l'implémentation standard : GNU make.
 #-----------------------------------------------------------------------
 
 # Une règle. Elle ne sera exécutée que si fichier0.txt n'existe pas.
-file0.txt:
+fichier0.txt:
 	echo "truc" > fichier0.txt
 	# Même les commentaires sont transférés dans le terminal.
 
 # Cette règle ne sera exécutée que si fichier0.txt est plus récent que
 # fichier1.txt.
-file1.txt: fichier0.txt
+fichier1.txt: fichier0.txt
 	cat fichier0.txt > fichier1.txt
-	# Utiliser les même guillemets que dans un terminal.
+	# Utiliser la même syntaxe que dans un terminal.
 	@cat fichier0.txt >> fichier1.txt
 	# @ empêche l'affichage de la sortie texte d'une commande.
 	-@echo 'hello'
-	# - signifie que la règle devrait continuer à être exécutée si cette
-	# commande échoue.
+	# - signifie que la règle devrait continuer à s'exécuter si cette commande
+	# échoue.
 
-# Un règle peut avoir plusieurs cibles et plusieurs dépendances.
-file2.txt fichier3.txt: fichier0.txt fichier1.txt
+# Une règle peut avoir plusieurs cibles et plusieurs dépendances.
+fichier2.txt fichier3.txt: fichier0.txt fichier1.txt
 	touch fichier2.txt
 	touch fichier3.txt
 
@@ -62,7 +63,7 @@ file2.txt fichier3.txt: fichier0.txt fichier1.txt
 # Fausses règles
 #-----------------------------------------------------------------------
 
-# Une fausse règle est un règle qui ne correspond pas à un fichier.
+# Une fausse règle est une règle qui ne correspond pas à un fichier.
 # Par définition, elle ne peut pas être à jour, et donc make l’exécutera à
 # chaque demande.
 all: maker process
@@ -75,7 +76,7 @@ maker:
 # suivante :
 .PHONY: all maker process
 
-# Un règle dépendante d'une fausse règle sera toujours exécutée.
+# Une règle dépendante d'une fausse règle sera toujours exécutée.
 ex0.txt ex1.txt: maker
 
 # Voici quelques exemples fréquents de fausses règles : all, make, clean,
-- 
cgit v1.2.3


From 8cff05396eeb7059904c52c3c2e62440d6c975b6 Mon Sep 17 00:00:00 2001
From: Cedric HT <cedric_hothanh@bitbucket.org>
Date: Mon, 18 Jan 2016 12:16:37 +0100
Subject: Corrected header

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

(limited to 'fr-fr')

diff --git a/fr-fr/make-fr.html.markdown b/fr-fr/make-fr.html.markdown
index b8255ce7..993eccba 100644
--- a/fr-fr/make-fr.html.markdown
+++ b/fr-fr/make-fr.html.markdown
@@ -2,6 +2,7 @@
 language: make
 contributors:
     - ["Robert Steed", "https://github.com/robochat"]
+translators:
     - ["altaris", "https://github.com/altaris"]
 filename: Makefile-fr
 lang: fr-fr
@@ -264,4 +265,4 @@ endif
 + [Documentation de GNU make](https://www.gnu.org/software/make/manual/),
 + [Software carpentry tutorial](http://swcarpentry.github.io/make-novice/),
 + Learn C the hard way [ex2](http://c.learncodethehardway.org/book/ex2.html)
-[ex28](http://c.learncodethehardway.org/book/ex28.html).
\ No newline at end of file
+[ex28](http://c.learncodethehardway.org/book/ex28.html).
-- 
cgit v1.2.3


From db99c9966ce21789dfa4d6618998ea288756d0ae Mon Sep 17 00:00:00 2001
From: Cedric HT <cedric_hothanh@bitbucket.org>
Date: Mon, 18 Jan 2016 12:17:50 +0100
Subject: Corrected header

- Added muself as translator;
- set lang field;
- corrected filename field.
---
 fr-fr/wolfram-fr.html.markdown | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/wolfram-fr.html.markdown b/fr-fr/wolfram-fr.html.markdown
index d297bd74..3a69e1d8 100644
--- a/fr-fr/wolfram-fr.html.markdown
+++ b/fr-fr/wolfram-fr.html.markdown
@@ -2,8 +2,10 @@
 language: wolfram
 contributors:
     - ["hyphz", "http://github.com/hyphz/"]
+translators:
     - ["altaris", "http://github.com/altaris/"]
-filename: learnwolfram.nb
+filename: learnwolfram-fr.nb
+lang: fr-fr
 ---
 
 Le langage Wolfram est utilisé dans les programmes suivants :
@@ -163,4 +165,4 @@ Manipulate[y^2, {y, 0, 20}] (* Crée une interface graphique interactive qui
 ## Envie d'aller plus loin ?
 
 * [Documentation du langage Wolfram (en anglais)]
-(http://reference.wolfram.com/language/)
\ No newline at end of file
+(http://reference.wolfram.com/language/)
-- 
cgit v1.2.3


From 0fe63187a9d61a0daa789ff59fc130b5dc678a34 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?C=C3=A9dric?= <altaris@users.noreply.github.com>
Date: Tue, 19 Jan 2016 11:53:13 +0100
Subject: Corrected typos in wolfram-fr

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

(limited to 'fr-fr')

diff --git a/fr-fr/wolfram-fr.html.markdown b/fr-fr/wolfram-fr.html.markdown
index 3a69e1d8..b9fe986f 100644
--- a/fr-fr/wolfram-fr.html.markdown
+++ b/fr-fr/wolfram-fr.html.markdown
@@ -110,7 +110,7 @@ BetterPrintTo[x_] := Module[{y}, (For[y=0, y<x, y++, (Print@y)])]
 y = 20             (* y est une variable globale *)
 BetterPrintTo[5]   (* 0 1 2 3 4 *)
 y                  (* 20, y n'a pas été modifiée car le y du Module masque le
-                          y global. C'est bien mieux comme ca ! *)
+                          y global. C'est bien mieux comme ça ! *)
 
 (* Module permet de faire des déclarations globales aussi *)
 Module[{count}, count=0;        (* count est une variable locale *)
@@ -159,7 +159,7 @@ Manipulate[y^2, {y, 0, 20}] (* Crée une interface graphique interactive qui
                                affiche y^2, permettant à l'utilisateur de
                                modifier la valeur de y grâce à un contrôle
                                allant de 0 à 20. Ne fonctionne que si le
-                               logiciel utilisé gère les éléments graphique. *)
+                               logiciel utilisé gère les éléments graphiques. *)
 ```
 
 ## Envie d'aller plus loin ?
-- 
cgit v1.2.3


From 5220d97320f8ac75654663c93764293d61b34ea2 Mon Sep 17 00:00:00 2001
From: Cedric HT <cedric_hothanh@bitbucket.org>
Date: Tue, 19 Jan 2016 12:36:33 +0100
Subject: More typos

---
 fr-fr/make-fr.html.markdown | 110 ++++++++++++++++++++++----------------------
 1 file changed, 55 insertions(+), 55 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/make-fr.html.markdown b/fr-fr/make-fr.html.markdown
index 993eccba..b404e1a1 100644
--- a/fr-fr/make-fr.html.markdown
+++ b/fr-fr/make-fr.html.markdown
@@ -37,24 +37,24 @@ l'implémentation standard : GNU make.
 
 # Une règle. Elle ne sera exécutée que si fichier0.txt n'existe pas.
 fichier0.txt:
-	echo "truc" > fichier0.txt
-	# Même les commentaires sont transférés dans le terminal.
+    echo "truc" > fichier0.txt
+    # Même les commentaires sont transférés dans le terminal.
 
 # Cette règle ne sera exécutée que si fichier0.txt est plus récent que
 # fichier1.txt.
 fichier1.txt: fichier0.txt
-	cat fichier0.txt > fichier1.txt
-	# Utiliser la même syntaxe que dans un terminal.
-	@cat fichier0.txt >> fichier1.txt
-	# @ empêche l'affichage de la sortie texte d'une commande.
-	-@echo 'hello'
-	# - signifie que la règle devrait continuer à s'exécuter si cette commande
-	# échoue.
+    cat fichier0.txt > fichier1.txt
+    # Utiliser la même syntaxe que dans un terminal.
+    @cat fichier0.txt >> fichier1.txt
+    # @ empêche l'affichage de la sortie texte d'une commande.
+    -@echo 'hello'
+    # - signifie que la règle devrait continuer à s'exécuter si cette commande
+    # échoue.
 
 # Une règle peut avoir plusieurs cibles et plusieurs dépendances.
 fichier2.txt fichier3.txt: fichier0.txt fichier1.txt
-	touch fichier2.txt
-	touch fichier3.txt
+    touch fichier2.txt
+    touch fichier3.txt
 
 # Make affichera un avertissement si le makefile comporte plusieurs règles pour
 # une même cible. Cependant les règles vides ne comptent pas, et peuvent être
@@ -71,7 +71,7 @@ all: maker process
 
 # La déclaration des règles peut être faite dans n'importe quel ordre.
 maker:
-	touch ex0.txt ex1.txt
+    touch ex0.txt ex1.txt
 
 # On peut transformer une règle en fausse règle grâce à la cible spéciale
 # suivante :
@@ -89,17 +89,17 @@ ex0.txt ex1.txt: maker
 
 # Utilise un wildcard pour des noms de fichier
 process: fichier*.txt
-	@echo $^    # $^ est une variable contenant la liste des dépendances de la
-				# cible actuelle.
-	@echo $@    # $@ est le nom de la cible actuelle. En cas de cibles
-				# multiples, $@ est le nom de la cible ayant causé l'exécution
-				# de cette règle.
-	@echo $<    # $< contient la première dépendance.
-	@echo $?    # $? contient la liste des dépendances qui ne sont pas à jour.
-	@echo $+    # $+ contient la liste des dépendances avec d'éventuels
-				# duplicatas, contrairement à $^.
-	@echo $|    # $| contient la liste des cibles ayant préséance sur la cible
-				# actuelle.
+    @echo $^    # $^ est une variable contenant la liste des dépendances de la
+                # cible actuelle.
+    @echo $@    # $@ est le nom de la cible actuelle. En cas de cibles
+                # multiples, $@ est le nom de la cible ayant causé l'exécution
+                # de cette règle.
+    @echo $<    # $< contient la première dépendance.
+    @echo $?    # $? contient la liste des dépendances qui ne sont pas à jour.
+    @echo $+    # $+ contient la liste des dépendances avec d'éventuels
+                # duplicatas, contrairement à $^.
+    @echo $|    # $| contient la liste des cibles ayant préséance sur la cible
+                # actuelle.
 
 # Même si la définition de la règle est scindée en plusieurs morceaux, $^
 # listera toutes les dépendances indiquées.
@@ -113,33 +113,33 @@ process: ex1.txt fichier0.txt
 # En utilisant le pattern matching, on peut par exemple créer des règles pour
 # convertir les fichiers d'un certain format dans un autre.
 %.png: %.svg
-	inkscape --export-png $^
+    inkscape --export-png $^
 
 # Make exécute une règle même si le fichier correspondant est situé dans un sous
 # dossier. En cas de conflit, la règle avec la meilleure correspondance est
 # choisie.
 small/%.png: %.svg
-	inkscape --export-png --export-dpi 30 $^
+    inkscape --export-png --export-dpi 30 $^
 
 # Dans ce type de conflit (même cible, même dépendances), make exécutera la
 # dernière règle déclarée...
 %.png: %.svg
-	@echo cette règle est choisie
+    @echo cette règle est choisie
 
 # Dans ce type de conflit (même cible mais pas les mêmes dépendances), make
 # exécutera la première règle pouvant être exécutée.
 %.png: %.ps
-	@echo cette règle n\'est pas choisie si *.svg et *.ps sont présents
+    @echo cette règle n\'est pas choisie si *.svg et *.ps sont présents
 
 # Make a des règles pré établies. Par exemple, il sait comment créer la cible
 # *.o à partir de *.c.
 
 # Les makefiles plus vieux utilisent un matching par extension de fichier.
 .png.ps:
-	@echo cette règle est similaire à une règle par pattern matching
+    @echo cette règle est similaire à une règle par pattern matching
 
-# Utiliser cette syntaxe pour déclarer une règle comme règle avec matching par
-# extension de fichier.
+# Utiliser cette règle spéciale pour déclarer une règle comme ayant un
+# matching par extension de fichier.
 .SUFFIXES: .png
 
 #-----------------------------------------------------------------------
@@ -152,10 +152,10 @@ variable = Ted
 variable2="Sarah"
 
 echo:
-	@echo $(variable)
-	@echo ${variable2}
-	@echo $variable    # Cette syntaxe signifie $(n)ame et non pas $(variable) !
-	@echo $(variable3) # Les variables non déclarées valent "" (chaîne vide).
+    @echo $(variable)
+    @echo ${variable2}
+    @echo $variable    # Cette syntaxe signifie $(n)ame et non pas $(variable) !
+    @echo $(variable3) # Les variables non déclarées valent "" (chaîne vide).
 
 # Les variables sont déclarées de 4 manières, de la plus grande priorité à la
 # plus faible :
@@ -177,21 +177,21 @@ variable4 +=gris
 # Assignations de variable pour les règles correspondant à un pattern
 # (spécifique à GNU make).
 *.png: variable2 = Sara # Pour toutes les règles correspondant à *.png, et tous
-						# leurs descendants, la variable variable2 vaudra
-						# "Sara".
+                        # leurs descendants, la variable variable2 vaudra
+                        # "Sara".
 # Si le jeux des dépendances et descendances devient vraiment trop compliqué,
-# des inconsistances peuvent survenir.
+# des incohérences peuvent survenir.
 
 # Certaines variables sont prédéfinies par make :
 affiche_predefinies:
-	echo $(CC)
-	echo ${CXX}
-	echo $(FC)
-	echo ${CFLAGS}
-	echo $(CPPFLAGS)
-	echo ${CXXFLAGS}
-	echo $(LDFLAGS)
-	echo ${LDLIBS}
+    echo $(CC)
+    echo ${CXX}
+    echo $(FC)
+    echo ${CFLAGS}
+    echo $(CPPFLAGS)
+    echo ${CXXFLAGS}
+    echo $(LDFLAGS)
+    echo ${LDLIBS}
 
 #-----------------------------------------------------------------------
 # Variables : le retour
@@ -202,11 +202,11 @@ affiche_predefinies:
 # manière d'assigner des variables pour qu'elles ne soient évaluées qu'une seule
 # fois seulement.
 
-var := wesh
-var2 ::=  $(var) mec # := et ::= sont équivalents.
+var := A B C
+var2 ::=  $(var) D E F # := et ::= sont équivalents.
 
 # Ces variables sont évaluées procéduralement (i.e. dans leur ordre
-# d'apparition), contrairement au règles par exemple !
+# d'apparition), contrairement aux règles par exemple !
 
 # Ceci ne fonctionne pas.
 var3 ::= $(var4) et fais de beaux rêves
@@ -225,9 +225,9 @@ fichiers_source = $(wildcard *.c */*.c)
 fichiers_objet  = $(patsubst %.c,%.o,$(fichiers_source))
 
 ls: * src/*
-	@echo $(filter %.txt, $^)
-	@echo $(notdir $^)
-	@echo $(join $(dir $^),$(notdir $^))
+    @echo $(filter %.txt, $^)
+    @echo $(notdir $^)
+    @echo $(join $(dir $^),$(notdir $^))
 
 #-----------------------------------------------------------------------
 # Directives
@@ -240,14 +240,14 @@ include meuh.mk
 sport = tennis
 report:
 ifeq ($(sport),tennis)                  # Il y a aussi ifneq.
-	@echo 'jeu, set et match'
+    @echo 'jeu, set et match'
 else
-	@echo "C'est pas ici Wimbledon ?"
+    @echo "C'est pas ici Wimbledon ?"
 endif
 
 truc = true
-ifdef $(truc)							# Il y a aussi ifndef.
-	machin = 'salut'
+ifdef $(truc)                           # Il y a aussi ifndef.
+    machin = 'salut'
 endif
 ```
 
-- 
cgit v1.2.3


From 43c93e3449c2b82bf71529a901034b38077cbcc1 Mon Sep 17 00:00:00 2001
From: Cedric HT <cedric_hothanh@bitbucket.org>
Date: Tue, 19 Jan 2016 12:38:39 +0100
Subject: Changed indentation to tabs

They were converted to spaces by error in previous commit. oups.
---
 fr-fr/make-fr.html.markdown | 100 ++++++++++++++++++++++----------------------
 1 file changed, 50 insertions(+), 50 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/make-fr.html.markdown b/fr-fr/make-fr.html.markdown
index b404e1a1..5a1e03e7 100644
--- a/fr-fr/make-fr.html.markdown
+++ b/fr-fr/make-fr.html.markdown
@@ -1,9 +1,9 @@
 ---
 language: make
 contributors:
-    - ["Robert Steed", "https://github.com/robochat"]
+	- ["Robert Steed", "https://github.com/robochat"]
 translators:
-    - ["altaris", "https://github.com/altaris"]
+	- ["altaris", "https://github.com/altaris"]
 filename: Makefile-fr
 lang: fr-fr
 ---
@@ -37,24 +37,24 @@ l'implémentation standard : GNU make.
 
 # Une règle. Elle ne sera exécutée que si fichier0.txt n'existe pas.
 fichier0.txt:
-    echo "truc" > fichier0.txt
-    # Même les commentaires sont transférés dans le terminal.
+	echo "truc" > fichier0.txt
+	# Même les commentaires sont transférés dans le terminal.
 
 # Cette règle ne sera exécutée que si fichier0.txt est plus récent que
 # fichier1.txt.
 fichier1.txt: fichier0.txt
-    cat fichier0.txt > fichier1.txt
-    # Utiliser la même syntaxe que dans un terminal.
-    @cat fichier0.txt >> fichier1.txt
-    # @ empêche l'affichage de la sortie texte d'une commande.
-    -@echo 'hello'
-    # - signifie que la règle devrait continuer à s'exécuter si cette commande
-    # échoue.
+	cat fichier0.txt > fichier1.txt
+	# Utiliser la même syntaxe que dans un terminal.
+	@cat fichier0.txt >> fichier1.txt
+	# @ empêche l'affichage de la sortie texte d'une commande.
+	-@echo 'hello'
+	# - signifie que la règle devrait continuer à s'exécuter si cette commande
+	# échoue.
 
 # Une règle peut avoir plusieurs cibles et plusieurs dépendances.
 fichier2.txt fichier3.txt: fichier0.txt fichier1.txt
-    touch fichier2.txt
-    touch fichier3.txt
+	touch fichier2.txt
+	touch fichier3.txt
 
 # Make affichera un avertissement si le makefile comporte plusieurs règles pour
 # une même cible. Cependant les règles vides ne comptent pas, et peuvent être
@@ -71,7 +71,7 @@ all: maker process
 
 # La déclaration des règles peut être faite dans n'importe quel ordre.
 maker:
-    touch ex0.txt ex1.txt
+	touch ex0.txt ex1.txt
 
 # On peut transformer une règle en fausse règle grâce à la cible spéciale
 # suivante :
@@ -89,17 +89,17 @@ ex0.txt ex1.txt: maker
 
 # Utilise un wildcard pour des noms de fichier
 process: fichier*.txt
-    @echo $^    # $^ est une variable contenant la liste des dépendances de la
-                # cible actuelle.
-    @echo $@    # $@ est le nom de la cible actuelle. En cas de cibles
-                # multiples, $@ est le nom de la cible ayant causé l'exécution
-                # de cette règle.
-    @echo $<    # $< contient la première dépendance.
-    @echo $?    # $? contient la liste des dépendances qui ne sont pas à jour.
-    @echo $+    # $+ contient la liste des dépendances avec d'éventuels
-                # duplicatas, contrairement à $^.
-    @echo $|    # $| contient la liste des cibles ayant préséance sur la cible
-                # actuelle.
+	@echo $^    # $^ est une variable contenant la liste des dépendances de la
+				# cible actuelle.
+	@echo $@    # $@ est le nom de la cible actuelle. En cas de cibles
+				# multiples, $@ est le nom de la cible ayant causé l'exécution
+				# de cette règle.
+	@echo $<    # $< contient la première dépendance.
+	@echo $?    # $? contient la liste des dépendances qui ne sont pas à jour.
+	@echo $+    # $+ contient la liste des dépendances avec d'éventuels
+				# duplicatas, contrairement à $^.
+	@echo $|    # $| contient la liste des cibles ayant préséance sur la cible
+				# actuelle.
 
 # Même si la définition de la règle est scindée en plusieurs morceaux, $^
 # listera toutes les dépendances indiquées.
@@ -113,30 +113,30 @@ process: ex1.txt fichier0.txt
 # En utilisant le pattern matching, on peut par exemple créer des règles pour
 # convertir les fichiers d'un certain format dans un autre.
 %.png: %.svg
-    inkscape --export-png $^
+	inkscape --export-png $^
 
 # Make exécute une règle même si le fichier correspondant est situé dans un sous
 # dossier. En cas de conflit, la règle avec la meilleure correspondance est
 # choisie.
 small/%.png: %.svg
-    inkscape --export-png --export-dpi 30 $^
+	inkscape --export-png --export-dpi 30 $^
 
 # Dans ce type de conflit (même cible, même dépendances), make exécutera la
 # dernière règle déclarée...
 %.png: %.svg
-    @echo cette règle est choisie
+	@echo cette règle est choisie
 
 # Dans ce type de conflit (même cible mais pas les mêmes dépendances), make
 # exécutera la première règle pouvant être exécutée.
 %.png: %.ps
-    @echo cette règle n\'est pas choisie si *.svg et *.ps sont présents
+	@echo cette règle n\'est pas choisie si *.svg et *.ps sont présents
 
 # Make a des règles pré établies. Par exemple, il sait comment créer la cible
 # *.o à partir de *.c.
 
 # Les makefiles plus vieux utilisent un matching par extension de fichier.
 .png.ps:
-    @echo cette règle est similaire à une règle par pattern matching
+	@echo cette règle est similaire à une règle par pattern matching
 
 # Utiliser cette règle spéciale pour déclarer une règle comme ayant un
 # matching par extension de fichier.
@@ -152,10 +152,10 @@ variable = Ted
 variable2="Sarah"
 
 echo:
-    @echo $(variable)
-    @echo ${variable2}
-    @echo $variable    # Cette syntaxe signifie $(n)ame et non pas $(variable) !
-    @echo $(variable3) # Les variables non déclarées valent "" (chaîne vide).
+	@echo $(variable)
+	@echo ${variable2}
+	@echo $variable    # Cette syntaxe signifie $(n)ame et non pas $(variable) !
+	@echo $(variable3) # Les variables non déclarées valent "" (chaîne vide).
 
 # Les variables sont déclarées de 4 manières, de la plus grande priorité à la
 # plus faible :
@@ -177,21 +177,21 @@ variable4 +=gris
 # Assignations de variable pour les règles correspondant à un pattern
 # (spécifique à GNU make).
 *.png: variable2 = Sara # Pour toutes les règles correspondant à *.png, et tous
-                        # leurs descendants, la variable variable2 vaudra
-                        # "Sara".
+						# leurs descendants, la variable variable2 vaudra
+						# "Sara".
 # Si le jeux des dépendances et descendances devient vraiment trop compliqué,
 # des incohérences peuvent survenir.
 
 # Certaines variables sont prédéfinies par make :
 affiche_predefinies:
-    echo $(CC)
-    echo ${CXX}
-    echo $(FC)
-    echo ${CFLAGS}
-    echo $(CPPFLAGS)
-    echo ${CXXFLAGS}
-    echo $(LDFLAGS)
-    echo ${LDLIBS}
+	echo $(CC)
+	echo ${CXX}
+	echo $(FC)
+	echo ${CFLAGS}
+	echo $(CPPFLAGS)
+	echo ${CXXFLAGS}
+	echo $(LDFLAGS)
+	echo ${LDLIBS}
 
 #-----------------------------------------------------------------------
 # Variables : le retour
@@ -225,9 +225,9 @@ fichiers_source = $(wildcard *.c */*.c)
 fichiers_objet  = $(patsubst %.c,%.o,$(fichiers_source))
 
 ls: * src/*
-    @echo $(filter %.txt, $^)
-    @echo $(notdir $^)
-    @echo $(join $(dir $^),$(notdir $^))
+	@echo $(filter %.txt, $^)
+	@echo $(notdir $^)
+	@echo $(join $(dir $^),$(notdir $^))
 
 #-----------------------------------------------------------------------
 # Directives
@@ -240,14 +240,14 @@ include meuh.mk
 sport = tennis
 report:
 ifeq ($(sport),tennis)                  # Il y a aussi ifneq.
-    @echo 'jeu, set et match'
+	@echo 'jeu, set et match'
 else
-    @echo "C'est pas ici Wimbledon ?"
+	@echo "C'est pas ici Wimbledon ?"
 endif
 
 truc = true
 ifdef $(truc)                           # Il y a aussi ifndef.
-    machin = 'salut'
+	machin = 'salut'
 endif
 ```
 
-- 
cgit v1.2.3


From a3e68ea324716f1f018888782b357812be3865a2 Mon Sep 17 00:00:00 2001
From: Cedric HT <cedric_hothanh@bitbucket.org>
Date: Sat, 23 Jan 2016 11:31:17 +0100
Subject: Transleted code variables and strings to french

---
 fr-fr/wolfram-fr.html.markdown | 116 ++++++++++++++++++++---------------------
 1 file changed, 58 insertions(+), 58 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/wolfram-fr.html.markdown b/fr-fr/wolfram-fr.html.markdown
index b9fe986f..ea07aae5 100644
--- a/fr-fr/wolfram-fr.html.markdown
+++ b/fr-fr/wolfram-fr.html.markdown
@@ -57,101 +57,101 @@ x                (* 20 *)
 
 (* Le langage Wolfram effectue des manipulations symboliques, donc utiliser des
    variables non déclarées n'est pas illégal *)
-cow + 5          (* 5 + cow, comme cow n'est pas déclarée, l'évaluation
+truc + 5         (* 5 + truc, comme truc n'est pas déclarée, l'évaluation
                     s'arrête là *)
-cow + 5 + 10     (* 15 + cow, on évalue ce qu'on peut... *)
-%                (* 15 + cow, % représente le dernier résultat *)
-% - cow          (* 15, les variables non déclarées peuvent quand même
+truc + 5 + 10    (* 15 + truc, on évalue ce qu'on peut... *)
+%                (* 15 + truc, % représente le dernier résultat *)
+% - truc         (* 15, les variables non déclarées peuvent quand même
                     s'annuler *)
-moo = cow + 5    (* Attention : moo est ici une expression et non un nombre *)
+chose = truc + 5 (* Attention : chose est ici une expression et non un nombre *)
 
 (* Déclaration d'une fonction *)
-Double[x_] := x * 2    (* Le symbole := empêche l'évaluation immédiate du terme
-                          à droite *)
-Double[10]             (* 20 *)
-Double[Sin[Pi/2]]      (* 2 *)
-Double @ Sin @ (Pi/2)  (* 2, Utiliser @ évite les paquets de crochets
-                            fermants si moches *)
-(Pi/2) // Sin // Double(* 2, Utiliser // permet d'écrire les fonctions dans
-                             l'ordre d'appel *)
+Double[x_] := x * 2     (* Le symbole := empêche l'évaluation immédiate du terme
+                           à droite *)
+Double[10]              (* 20 *)
+Double[Sin[Pi/2]]       (* 2 *)
+Double @ Sin @ (Pi/2)   (* 2, Utiliser @ évite les paquets de crochets
+                           fermants si moches *)
+(Pi/2) // Sin // Double (* 2, Utiliser // permet d'écrire les fonctions dans
+                           l'ordre d'appel *)
 
 (* Pour la programmation impérative, utiliser ; pour séparer les expressions *)
-MyFirst[] := (Print@"Hello"; Print@"World")  (* Les parenthèses sont nécessaires
-                                                car ; est prioritaire sur := *)
-MyFirst[]                                    (* Hello World *)
+Salut[] := (Print@"Hello"; Print@"World")  (* Les parenthèses sont nécessaires
+                                              car ; est prioritaire sur := *)
+Salut[]                                    (* Hello World *)
 
 (* Boucles For à la C *)
-PrintTo[x_] := For[y=0, y<x, y++, (Print[y])]  (* L'évaluation des boucles For
+Compter[x_] := For[y=0, y<x, y++, (Print[y])]  (* L'évaluation des boucles For
                                                   se fait comme dans le C *)
-PrintTo[5]                                     (* 0 1 2 3 4 *)
+Compter[5]                                     (* 0 1 2 3 4 *)
 
 (* Boucles While *)
 x = 0; While[x < 2, (Print@x; x++)]     (* De nouveau, comme dans le C *)
 
 (* Expressions conditionnelles et If *)
-x = 8; If[x==8, Print@"Yes", Print@"No"]   (* If [condition, si vrai,
-                                              si faux] *)
-Switch[x, 2, Print@"Two", 8, Print@"Yes"]  (* Switch par valeur *)
-Which[x==2, Print@"No", x==8, Print@"Yes"] (* Switch du type if, else if,
-                                              else if, ..., else *)
+x = 8; If[x==8, Print@"Huit", Print@"Pas huit"] (* If [condition, si vrai,
+                                                   si faux] *)
+Switch[x, 2, Print@"Deux", 8, Print@"Huit"]     (* Switch par valeur *)
+Which[x==2, Print@"Deux", x==8, Print@"Huit"]   (* Switch du type if, else if,
+                                                   else if, ..., else *)
 
 (* Les variables autres que les paramètres de fonctions sont par défaut
    globales, même à l'intérieur des fonctions *)
 y = 10             (* 10, y est une variable globale *)
-PrintTo[5]         (* 0 1 2 3 4 *)
-y                  (* 5, y a été modifiée par PrintTo *)
+Compter[5]         (* 0 1 2 3 4 *)
+y                  (* 5, y a été modifiée par Compter *)
 x = 20             (* 20, x est une variable globale *)
-PrintTo[5]         (* 0 1 2 3 4 *)
-x                  (* 20, dans PrintTo, le paramètre x masque la variable
+Compter[5]         (* 0 1 2 3 4 *)
+x                  (* 20, dans Compter, le paramètre x masque la variable
                       globale x *)
 
 (* La fonction Module permet d'utiliser des variables locales *)
-BetterPrintTo[x_] := Module[{y}, (For[y=0, y<x, y++, (Print@y)])]
+MieuxCompter[x_] := Module[{y}, (For[y=0, y<x, y++, (Print@y)])]
 y = 20             (* y est une variable globale *)
-BetterPrintTo[5]   (* 0 1 2 3 4 *)
+MieuxCompter[5]    (* 0 1 2 3 4 *)
 y                  (* 20, y n'a pas été modifiée car le y du Module masque le
                           y global. C'est bien mieux comme ça ! *)
 
 (* Module permet de faire des déclarations globales aussi *)
-Module[{count}, count=0;        (* count est une variable locale *)
-  (IncCount[] := ++count);      (* Ce module déclare des fonctions, mais elles
+Module[{compte}, compte=0;      (* compte est une variable locale *)
+  (Incrementer[] := ++compte);  (* Ce module déclare des fonctions, mais elles
                                    ne sont globales. Elles ont cependant accès
                                    aux variables locales au module. *)
-  (DecCount[] := --count)]
-count              (* count, car il n'y a pas de variable globale nommée
-                      count *)
-IncCount[]         (* 1, la fonction utilise la variable count du module *)
-IncCount[]         (* 2, le précédent appel de IncCount a modifié count *)
-DecCount[]         (* 1 *)
-count              (* count, car il n'existe toujours pas de variable globale
-                      nommé count *)
+  (Decrementer[] := --compte)]
+compte             (* compte, car il n'y a pas de variable globale nommée
+                      compte *)
+Incrementer[]      (* 1, la fonction utilise la variable compte du module *)
+Incrementer[]      (* 2, le précédent appel de Incrementer a modifié compte *)
+Decrementer[]      (* 1 *)
+compte             (* compte, car il n'existe toujours pas de variable globale
+                      nommé compte *)
 
 (* Listes *)
-myList = {1, 2, 3, 4}     (* {1, 2, 3, 4} *)
-myList[[1]]               (* 1, les indexes commencent à 1 et non 0 !!! *)
-Map[Double, myList]       (* {2, 4, 6, 8}, appliquer une fonction à une liste de
+liste = {1, 2, 3, 4}     (* {1, 2, 3, 4} *)
+liste[[1]]               (* 1, les indexes commencent à 1 et non 0 !!! *)
+Map[Double, liste]       (* {2, 4, 6, 8}, appliquer une fonction à une liste de
                              manière fonctionnelle *)
-Double /@ myList          (* {2, 4, 6, 8}, syntaxe abrégée de la ligne
+Double /@ liste          (* {2, 4, 6, 8}, syntaxe abrégée de la ligne
                              précédente *)
-Scan[Print, myList]       (* 1 2 3 4, boucle impérative sur une liste *)
-Fold[Plus, 0, myList]     (* 10 (0+1+2+3+4) *)
-FoldList[Plus, 0, myList] (* {0, 1, 3, 6, 10}, variante de la fonction
+Scan[Print, liste]       (* 1 2 3 4, boucle impérative sur une liste *)
+Fold[Plus, 0, liste]     (* 10 (0+1+2+3+4) *)
+FoldList[Plus, 0, liste] (* {0, 1, 3, 6, 10}, variante de la fonction
                              précédente qui donne aussi les résultats
                              intermédiaires *)
-Append[myList, 5]         (* {1, 2, 3, 4, 5}, myList n'est pas modifiée... *)
-Prepend[myList, 5]        (* {5, 1, 2, 3, 4}, ... mais elle peut l'être en 
-                             écrivant "myList = " *)
-Join[myList, {3, 4}]      (* {1, 2, 3, 4, 3, 4} *)
-myList[[2]] = 5           (* {1, 5, 3, 4}, ceci modifie bien la liste *)
+Append[liste, 5]         (* {1, 2, 3, 4, 5}, liste n'est pas modifiée... *)
+Prepend[liste, 5]        (* {5, 1, 2, 3, 4}, ... mais elle peut l'être en 
+                             écrivant "liste = " *)
+Join[liste, {3, 4}]      (* {1, 2, 3, 4, 3, 4} *)
+liste[[2]] = 5           (* {1, 5, 3, 4}, ceci modifie bien la liste *)
 
 (* Tables associatives, ou dictionnaires *)
-myHash = <|"Green" -> 2, "Red" -> 1|>   (* Crée une table associative *)
-myHash[["Green"]]                       (* 2, l'utilise *)
-myHash[["Green"]] := 5                  (* 5, la modifie *)
-myHash[["Puce"]] := 3.5                 (* 3.5, l'étend *)
-KeyDropFrom[myHash, "Green"]            (* Supprime la clé "Green" *)
-Keys[myHash]                            (* {Red} *)
-Values[myHash]                          (* {1} *)
+table = <|"Vert" -> 2, "Rouge" -> 1|> (* Crée une table associative *)
+table[["Vert"]]                       (* 2, l'utilise *)
+table[["Vert"]] := 5                  (* 5, la modifie *)
+table[["Bleu"]] := 3.5                (* 3.5, l'étend *)
+KeyDropFrom[table, "Vert"]            (* Supprime la clé "Vert" *)
+Keys[table]                           (* {Rouge} *)
+Values[table]                         (* {1} *)
 
 (* Pour finir, toute bonne démonstration du langage Wolfram contient un
    Manipulate ! *)
-- 
cgit v1.2.3


From 3ea060e936b4260ab57abfee6de9dabc3232d6fd Mon Sep 17 00:00:00 2001
From: Cedric HT <cedric_hothanh@bitbucket.org>
Date: Sat, 23 Jan 2016 11:32:02 +0100
Subject: Corrected code results in comments

In subsection on hash tables.
---
 fr-fr/wolfram-fr.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/wolfram-fr.html.markdown b/fr-fr/wolfram-fr.html.markdown
index ea07aae5..9cdbabcc 100644
--- a/fr-fr/wolfram-fr.html.markdown
+++ b/fr-fr/wolfram-fr.html.markdown
@@ -150,8 +150,8 @@ table[["Vert"]]                       (* 2, l'utilise *)
 table[["Vert"]] := 5                  (* 5, la modifie *)
 table[["Bleu"]] := 3.5                (* 3.5, l'étend *)
 KeyDropFrom[table, "Vert"]            (* Supprime la clé "Vert" *)
-Keys[table]                           (* {Rouge} *)
-Values[table]                         (* {1} *)
+Keys[table]                           (* {Rouge, Bleu} *)
+Values[table]                         (* {1, 3.5} *)
 
 (* Pour finir, toute bonne démonstration du langage Wolfram contient un
    Manipulate ! *)
-- 
cgit v1.2.3


From 2b3d1e524d483e647fd6a193d6b17808d67af5ab Mon Sep 17 00:00:00 2001
From: Cedric HT <cedric_hothanh@bitbucket.org>
Date: Sat, 23 Jan 2016 11:37:15 +0100
Subject: Some improvments in comments

---
 fr-fr/wolfram-fr.html.markdown | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/wolfram-fr.html.markdown b/fr-fr/wolfram-fr.html.markdown
index 9cdbabcc..7b446259 100644
--- a/fr-fr/wolfram-fr.html.markdown
+++ b/fr-fr/wolfram-fr.html.markdown
@@ -33,22 +33,21 @@ formatage, car il ne contient aucune information de mise en page.
 5+8              (* 13 *)
 
 (* Appels de fonction *)
-(* Le langage Wolfram est sensible à la casse *)
 Sin[Pi/2]        (* 1 *)
-
 (* Syntaxe alternative pour les appels de fonction à 1 paramètre *)
 Sin@(Pi/2)       (* 1 *)
 (Pi/2) // Sin    (* 1 *)
 
-(* Dans le langage Wolfram, toutes les expressions sont en réalité des appels de
-   fonction *)
+(* Attention : le langage est sensible à la casse ! *)
+
+(* Toutes les expressions sont en réalité des appels de fonction *)
 Times[2, 2]      (* 4 *)
 Plus[5, 8]       (* 13 *)
 
 (* Utiliser une variable pour la première fois la déclare globalement *)
 x = 5            (* 5 *)
 x == 5           (* True, l'assignation et le test d'égalité est écrit comme
-                    dans le C *)
+                    en C *)
 x                (* 5 *)
 x = x + 5        (* 10 *)
 x                (* 10 *)
@@ -56,7 +55,7 @@ Set[x, 20]       (* TOUT est un appel de fonction, TOUUUUUUUUT *)
 x                (* 20 *)
 
 (* Le langage Wolfram effectue des manipulations symboliques, donc utiliser des
-   variables non déclarées n'est pas illégal *)
+   variables non déclarées est légal *)
 truc + 5         (* 5 + truc, comme truc n'est pas déclarée, l'évaluation
                     s'arrête là *)
 truc + 5 + 10    (* 15 + truc, on évalue ce qu'on peut... *)
@@ -75,18 +74,18 @@ Double @ Sin @ (Pi/2)   (* 2, Utiliser @ évite les paquets de crochets
 (Pi/2) // Sin // Double (* 2, Utiliser // permet d'écrire les fonctions dans
                            l'ordre d'appel *)
 
-(* Pour la programmation impérative, utiliser ; pour séparer les expressions *)
+(* En programmation impérative, utiliser ; pour séparer les expressions *)
 Salut[] := (Print@"Hello"; Print@"World")  (* Les parenthèses sont nécessaires
                                               car ; est prioritaire sur := *)
 Salut[]                                    (* Hello World *)
 
 (* Boucles For à la C *)
 Compter[x_] := For[y=0, y<x, y++, (Print[y])]  (* L'évaluation des boucles For
-                                                  se fait comme dans le C *)
+                                                  se fait comme en C *)
 Compter[5]                                     (* 0 1 2 3 4 *)
 
 (* Boucles While *)
-x = 0; While[x < 2, (Print@x; x++)]     (* De nouveau, comme dans le C *)
+x = 0; While[x < 2, (Print@x; x++)]     (* De nouveau, comme en C *)
 
 (* Expressions conditionnelles et If *)
 x = 8; If[x==8, Print@"Huit", Print@"Pas huit"] (* If [condition, si vrai,
-- 
cgit v1.2.3


From 5aa692f5f3bbfa7b79224748dcfd8ca5fba7a8bc Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Fri, 12 Feb 2016 11:42:25 -0800
Subject: brainfuck->bf

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

(limited to 'fr-fr')

diff --git a/fr-fr/bf-fr.html.markdown b/fr-fr/bf-fr.html.markdown
new file mode 100644
index 00000000..0fae6032
--- /dev/null
+++ b/fr-fr/bf-fr.html.markdown
@@ -0,0 +1,87 @@
+---
+language: bf
+filename: learnbrainfuck-fr.bf
+contributors:
+    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+    - ["Mathias Bynens", "http://mathiasbynens.be/"]
+translators:
+    - ["Baptiste Fontaine", "http://bfontaine.net"]
+lang: fr-fr
+---
+
+Brainfuck (sans majuscule à part au début d’une phrase) est un langage
+Turing-complet extrêmement simple avec seulement 8 commandes.
+
+```
+Tout caractère en dehors de "><+-.,[]" (en dehors des guillemets) est ignoré.
+
+Brainfuck est représenté par un tableau de 30 000 cellules initialisées à 0 et
+un pointeur de données pointant sur la cellule courante.
+
+Il y a huit commandes :
++ : Incrémente la valeur de la cellule courante de un.
+- : Décrémente la valeur de la cellule courante de un.
+> : Déplace le pointeur de données sur la cellule suivante (à droite).
+< : Déplace le pointeur de données sur la cellule précédente (à gauche).
+. : Affiche la valeur ASCII de la cellule courante (par ex. 65 = 'A').
+, : Lit un caractère et le place dans la cellule courante.
+[ : Si la valeur dans la cellule courante vaut 0, saute au ] correspondant.
+    Sinon, continue avec la commande suivante.
+] : Si la valeur dans la cellule courante vaut 0, continue avec la commande
+    suivante. Sinon, retourne au [ correspondant.
+
+[ et ] forment une boucle « tant que » (« while »). Ils doivent évidemment
+aller par paires.
+
+Regardons quelques programmes simples en brainfuck.
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+Ce programme affiche la lettre 'A'. Il commence par incrémenter la première
+cellule à 6. Il entre ensuite dans une boucle et se déplace sur la seconde
+cellule. Il l’incrémente 10 fois, retourne sur la première cellule, et la
+décrémente. Cette boucle est exécutée 6 fois (ce qui correspond aux 6
+décrémentations de la première cellule pour la faire atteindre 0, ce qui fait
+sortir de la boucle).
+
+À ce moment-là, nous sommes sur la première cellule, qui a une valeur de 0,
+tandis que la seconde cellule a une valeur de 60. Nous nous déplaçons sur
+celle-ci, l’incrémentons 5 fois, pour une valeur de 65, et affichons sa valeur.
+En ASCII, 65 correspond à 'A' donc le programme affiche 'A' dans le terminal.
+
+, [ > + < - ] > .
+
+Ce programme lit un caractère sur l’entrée standard et le copie dans la
+première cellule. Il commence ensuite une boucle : il bouge sur la seconde
+cellule, incrémente sa valeur, retourne sur la première et décrémente sa
+valeur. Il continue jusqu’à ce que la valeur de la première cellule soit à 0,
+et que la seconde cellule contienne l’ancienne valeur de la première. Comme
+nous sommes sur la première cellule à la fin de la boucle, il bouge sur la
+seconde et affiche sa valeur en ASCII.
+
+Souvenez-vous que les espaces sont uniquement là pour favoriser la lisibilité,
+vous pourriez tout aussi aisément écrire le programme comme ceci :
+
+,[>+<-]>.
+
+Essayez et devinez ce que ce programme fait :
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+Ce programme prend deux nombres en entrée, et les multiplie.
+
+Il commence par lire deux entrées, puis commence une boucle externe, qui a une
+condition sur la première cellule. Il bouge ensuite sur la seconde, et commence
+une boucle interne sur celle-ci, en incrémentant la troisième cellule. Il y a
+cependant un problème : à la fin de la boucle interne, la valeur de la seconde
+cellule est à zéro. Dans ce cas, la boucle interne ne fonctionnera pas une
+seconde fois. Pour régler le problème, nous incrémentons aussi la quatrième
+cellule, puis recopions sa valeur dans la seconde cellule.
+À la fin, la troisième cellule contient le résultat de la multiplication.
+```
+
+Et voilà ce qu’est le brainfuck. Pas très dur, hein ? Pour le fun, vous pouvez
+écrire vos propres programmes en brainfuck, ou écrire un interpréteur brainfuck
+dans un autre langage. L’interpréteur est relativement simple à implémenter,
+mais si vous êtes un masochiste, essayez d’écrire un interpréteur brainfuck en…
+brainfuck.
diff --git a/fr-fr/brainfuck-fr.html.markdown b/fr-fr/brainfuck-fr.html.markdown
deleted file mode 100644
index 545e407e..00000000
--- a/fr-fr/brainfuck-fr.html.markdown
+++ /dev/null
@@ -1,87 +0,0 @@
----
-language: brainfuck
-filename: learnbrainfuck-fr.bf
-contributors:
-    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
-    - ["Mathias Bynens", "http://mathiasbynens.be/"]
-translators:
-    - ["Baptiste Fontaine", "http://bfontaine.net"]
-lang: fr-fr
----
-
-Brainfuck (sans majuscule à part au début d’une phrase) est un langage
-Turing-complet extrêmement simple avec seulement 8 commandes.
-
-```
-Tout caractère en dehors de "><+-.,[]" (en dehors des guillemets) est ignoré.
-
-Brainfuck est représenté par un tableau de 30 000 cellules initialisées à 0 et
-un pointeur de données pointant sur la cellule courante.
-
-Il y a huit commandes :
-+ : Incrémente la valeur de la cellule courante de un.
-- : Décrémente la valeur de la cellule courante de un.
-> : Déplace le pointeur de données sur la cellule suivante (à droite).
-< : Déplace le pointeur de données sur la cellule précédente (à gauche).
-. : Affiche la valeur ASCII de la cellule courante (par ex. 65 = 'A').
-, : Lit un caractère et le place dans la cellule courante.
-[ : Si la valeur dans la cellule courante vaut 0, saute au ] correspondant.
-    Sinon, continue avec la commande suivante.
-] : Si la valeur dans la cellule courante vaut 0, continue avec la commande
-    suivante. Sinon, retourne au [ correspondant.
-
-[ et ] forment une boucle « tant que » (« while »). Ils doivent évidemment
-aller par paires.
-
-Regardons quelques programmes simples en brainfuck.
-
-++++++ [ > ++++++++++ < - ] > +++++ .
-
-Ce programme affiche la lettre 'A'. Il commence par incrémenter la première
-cellule à 6. Il entre ensuite dans une boucle et se déplace sur la seconde
-cellule. Il l’incrémente 10 fois, retourne sur la première cellule, et la
-décrémente. Cette boucle est exécutée 6 fois (ce qui correspond aux 6
-décrémentations de la première cellule pour la faire atteindre 0, ce qui fait
-sortir de la boucle).
-
-À ce moment-là, nous sommes sur la première cellule, qui a une valeur de 0,
-tandis que la seconde cellule a une valeur de 60. Nous nous déplaçons sur
-celle-ci, l’incrémentons 5 fois, pour une valeur de 65, et affichons sa valeur.
-En ASCII, 65 correspond à 'A' donc le programme affiche 'A' dans le terminal.
-
-, [ > + < - ] > .
-
-Ce programme lit un caractère sur l’entrée standard et le copie dans la
-première cellule. Il commence ensuite une boucle : il bouge sur la seconde
-cellule, incrémente sa valeur, retourne sur la première et décrémente sa
-valeur. Il continue jusqu’à ce que la valeur de la première cellule soit à 0,
-et que la seconde cellule contienne l’ancienne valeur de la première. Comme
-nous sommes sur la première cellule à la fin de la boucle, il bouge sur la
-seconde et affiche sa valeur en ASCII.
-
-Souvenez-vous que les espaces sont uniquement là pour favoriser la lisibilité,
-vous pourriez tout aussi aisément écrire le programme comme ceci :
-
-,[>+<-]>.
-
-Essayez et devinez ce que ce programme fait :
-
-,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
-
-Ce programme prend deux nombres en entrée, et les multiplie.
-
-Il commence par lire deux entrées, puis commence une boucle externe, qui a une
-condition sur la première cellule. Il bouge ensuite sur la seconde, et commence
-une boucle interne sur celle-ci, en incrémentant la troisième cellule. Il y a
-cependant un problème : à la fin de la boucle interne, la valeur de la seconde
-cellule est à zéro. Dans ce cas, la boucle interne ne fonctionnera pas une
-seconde fois. Pour régler le problème, nous incrémentons aussi la quatrième
-cellule, puis recopions sa valeur dans la seconde cellule.
-À la fin, la troisième cellule contient le résultat de la multiplication.
-```
-
-Et voilà ce qu’est le brainfuck. Pas très dur, hein ? Pour le fun, vous pouvez
-écrire vos propres programmes en brainfuck, ou écrire un interpréteur brainfuck
-dans un autre langage. L’interpréteur est relativement simple à implémenter,
-mais si vous êtes un masochiste, essayez d’écrire un interpréteur brainfuck en…
-brainfuck.
-- 
cgit v1.2.3


From f3b10beb01795bf7513ec8d06c9e90ab98df7a83 Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Fri, 12 Feb 2016 23:04:31 -0800
Subject: Clean up various errors

---
 fr-fr/HTML-fr.html.markdown        |  3 ++-
 fr-fr/d.html.markdown              | 12 ++++++------
 fr-fr/make-fr.html.markdown        |  4 ++--
 fr-fr/objective-c-fr.html.markdown |  3 +--
 4 files changed, 11 insertions(+), 11 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/HTML-fr.html.markdown b/fr-fr/HTML-fr.html.markdown
index fdde9107..4d2da921 100644
--- a/fr-fr/HTML-fr.html.markdown
+++ b/fr-fr/HTML-fr.html.markdown
@@ -5,6 +5,7 @@ contributors:
     - ["Christophe THOMAS", "https://github.com/WinChris"]
 lang: fr-fr
 ---
+
 HTML signifie HyperText Markup Language. 
 C'est un langage (format de fichiers) qui permet d'écrire des pages internet.
 C’est un langage de balisage, il nous permet d'écrire des pages HTML au moyen de balises (Markup, en anglais).
@@ -17,7 +18,7 @@ Comme tous les autres langages, HTML a plusieurs versions. Ici, nous allons parl
 Cet article porte principalement sur la syntaxe et quelques astuces.
 
 
-```HTML
+```html
 <!-- Les commentaires sont entouré comme cette ligne! -->
 
 <!-- #################### Les balises #################### -->
diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown
index d9bd9b48..bfb9f2ce 100644
--- a/fr-fr/d.html.markdown
+++ b/fr-fr/d.html.markdown
@@ -8,7 +8,7 @@ translators:
 lang: fr-fr
 ---
 
-```d
+```c
 // Commençons par un classique
 module hello;
 
@@ -30,7 +30,7 @@ D est activement développé par de nombreuses personnes très intelligents, gui
 [Andrei Alexandrescu](https://fr.wikipedia.org/wiki/Andrei_Alexandrescu).
 Après cette petite introduction, jetons un coup d'oeil à quelques exemples.
 
-```d
+```c
 import std.stdio;
 
 void main() {
@@ -75,7 +75,7 @@ On peut définir de nouveaux types avec les mots-clés `struct`, `class`,
 `union` et `enum`. Ces types sont passés au fonction par valeur (ils sont copiés)
 De plus, on peut utiliser les templates pour rendre toutes ces abstractions génériques.
 
-```d
+```c
 // Ici, 'T' est un paramètre de type. Il est similaire au <T> de C++/C#/Java.
 struct LinkedList(T) {
     T data = null;
@@ -140,7 +140,7 @@ 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.
 
-```d
+```c
 // Considérons une classe paramétrée avec les types 'T' et 'U'
 class MyClass(T, U) {
     T _data;
@@ -212,7 +212,7 @@ de premier ordre, les fonctions `pure` et les données immuables.
 De plus, tout vos algorithmes fonctionelles favoris (map, reduce, filter)
 sont disponibles dans le module `std.algorithm`.
 
-```d
+```c
 import std.algorithm : map, filter, reduce;
 import std.range : iota; // construit un intervalle excluant la dernière valeur.
 
@@ -242,7 +242,7 @@ est de type A, comme si c'était une méthode de A.
 J'aime le parallélisme. Vous aimez les parallélisme ? Bien sur que vous aimez ça
 Voyons comment on le fait en D !
 
-```d
+```c
 import std.stdio;
 import std.parallelism : parallel;
 import std.math : sqrt;
diff --git a/fr-fr/make-fr.html.markdown b/fr-fr/make-fr.html.markdown
index 5a1e03e7..48d24549 100644
--- a/fr-fr/make-fr.html.markdown
+++ b/fr-fr/make-fr.html.markdown
@@ -1,9 +1,9 @@
 ---
 language: make
 contributors:
-	- ["Robert Steed", "https://github.com/robochat"]
+    - ["Robert Steed", "https://github.com/robochat"]
 translators:
-	- ["altaris", "https://github.com/altaris"]
+    - ["altaris", "https://github.com/altaris"]
 filename: Makefile-fr
 lang: fr-fr
 ---
diff --git a/fr-fr/objective-c-fr.html.markdown b/fr-fr/objective-c-fr.html.markdown
index 4e31c4bf..fbe1741e 100644
--- a/fr-fr/objective-c-fr.html.markdown
+++ b/fr-fr/objective-c-fr.html.markdown
@@ -1,5 +1,4 @@
 ---
-
 language: Objective-C
 contributors:
     - ["Eugene Yagrushkin", "www.about.me/yagrushkin"]
@@ -9,7 +8,6 @@ translators:
     - ["Yannick Loriot", "https://github.com/YannickL"]
 filename: LearnObjectiveC-fr.m
 lang: fr-fr
-
 ---
 
 L'Objective-C est un langage de programmation orienté objet réflexif principalement utilisé par Apple pour les systèmes d'exploitations Mac OS X et iOS et leurs frameworks respectifs, Cocoa et Cocoa Touch.
@@ -519,6 +517,7 @@ __unsafe_unretained NSArray *unsafeArray; // Comme __weak, mais la variable n'es
 // l'objet est supprimé
 
 ```
+
 ##  Lectures Complémentaires
 
 [La Page Wikipedia de l'Objective-C](http://fr.wikipedia.org/wiki/Objective-C)
-- 
cgit v1.2.3