From ae73dd671f521527f6e58a877026c35d58173671 Mon Sep 17 00:00:00 2001
From: Geoffrey Roguelon <geoffrey.roguelon@gmail.com>
Date: Wed, 14 Aug 2013 19:12:21 +0200
Subject: Add the French translation of the Ruby language.

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

(limited to 'fr-fr')

diff --git a/fr-fr/ruby-fr.html.markdown b/fr-fr/ruby-fr.html.markdown
new file mode 100644
index 00000000..f6bfe42a
--- /dev/null
+++ b/fr-fr/ruby-fr.html.markdown
@@ -0,0 +1,406 @@
+---
+language: ruby
+filename: learnruby-fr.rb
+contributors:
+  - ["David Underwood", "http://theflyingdeveloper.com"]
+  - ["Joel Walden", "http://joelwalden.net"]
+  - ["Luke Holder", "http://twitter.com/lukeholder"]
+  - ["Tristan Hume", "http://thume.ca/"]
+  - ["Nick LaMuro", "https://github.com/NickLaMuro"]
+translators:
+  - ["Geoffrey Roguelon", "https://github.com/GRoguelon"]
+lang: fr-fr
+---
+
+```ruby
+# Ceci est un commentaire
+
+=begin
+Ceci est un commentaire multiligne
+Personne ne les utilise
+Vous devriez en faire de même
+=end
+
+# Tout d'abord : Tout est un objet.
+
+# Les nombres sont des objets
+
+3.class #=> Fixnum
+
+3.to_s #=> "3"
+
+# Arithmétique de base
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+
+# L'arithmétique est juste un raccourci
+# pour appeler la méthode d'un objet
+1.+(3) #=> 4
+10.* 5 #=> 50
+
+# Les valeurs spéciales sont des objets
+nil # Nothing to see here
+true # truth
+false # falsehood
+
+nil.class #=> NilClass
+true.class #=> TrueClass
+false.class #=> FalseClass
+
+# Égalité
+1 == 1 #=> true
+2 == 1 #=> false
+
+# Inégalité
+1 != 1 #=> false
+2 != 1 #=> true
+!true  #=> false
+!false #=> true
+
+# à part false lui-même, nil est la seule autre valeur 'false'
+
+!nil   #=> true
+!false #=> true
+!0     #=> false
+
+# Plus de comparaisons
+1 < 10 #=> true
+1 > 10 #=> false
+2 <= 2 #=> true
+2 >= 2 #=> true
+
+# Les chaînes de caractères sont des objets
+
+'Je suis une chaîne de caractères'.class #=> String
+"Je suis également une chaîne de caractères".class #=> String
+
+placeholder = "utiliser l'interpolation de chaîne de caractères"
+"Je peux #{placeholder} quand j'utilise les guillemets"
+#=> "Je peux utiliser l'interpolation de chaîne de caractères quand j'utilise les guillemets"
+
+# Afficher sur la sortie standard
+puts "J'affiche à l'écran!"
+
+# Variables
+x = 25 #=> 25
+x #=> 25
+
+# Notez que l'affectation retourne la valeur affectée.
+# Cela signifie que vous pouvez affecter plusieurs fois de suite :
+
+x = y = 10 #=> 10
+x #=> 10
+y #=> 10
+
+# Par convention, utiliser snake_case (à base d'underscore)
+# comme nom de variable
+snake_case = true
+
+# Utiliser des noms de variable explicites
+path_to_project_root = '/nom/correct/'
+path = '/mauvais/nom/'
+
+# Symboles (sont des objets)
+# Les symboles sont immuables, constants,
+# réutilisables et représentés en interne
+# par une valeur entière. Ils sont souvent
+# utilisés à la place des chaînes de caractères
+# pour transmettre efficacement des valeurs
+# spécifiques ou significatives
+
+:pending.class #=> Symbol
+
+status = :pending
+
+status == :pending #=> true
+
+status == 'pending' #=> false
+
+status == :approved #=> false
+
+# Tableaux
+
+# Ceci est un tableau
+array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
+
+# Les tableaux contiennent différents types d'élément.
+
+[1, "hello", false] #=> [1, "hello", false]
+
+# Les tableaux peuvent être indéxés
+# Du début
+array[0] #=> 1
+array[12] #=> nil
+
+# Comme l'arithmétique, la syntaxe [var] est juste un raccourci
+# pour appeler la méthode [] d'un objet
+array.[] 0 #=> 1
+array.[] 12 #=> nil
+
+# À la fin
+array[-1] #=> 5
+
+# Avec un index de début et de fin
+array[2, 4] #=> [3, 4, 5]
+
+# Ou avec un interval
+array[1..3] #=> [2, 3, 4]
+
+# Ajouter un élément au tableau comme ceci
+array << 6 #=> [1, 2, 3, 4, 5, 6]
+
+# Les Hashes sont des dictionnaires Ruby contenant des paires de clé/valeur.
+# Les Hashes sont délimitées par des accolades :
+hash = {'color' => 'green', 'number' => 5}
+
+hash.keys #=> ['color', 'number']
+
+# Les Hashes peuvent retourner rapidement
+# la valeur en utilisant la clé :
+hash['color'] #=> 'green'
+hash['number'] #=> 5
+
+# Rechercher une clé inexistante dans une Hash retourne nil:
+hash['nothing here'] #=> nil
+
+# Depuis Ruby 1.9, Une syntaxe spécifique est apparue en utilisant les symboles comme clés :
+
+new_hash = { defcon: 3, action: true}
+
+new_hash.keys #=> [:defcon, :action]
+
+# Astuce : Les tableaux et les Hashes sont dénombrables
+# Ils partagent un certain nombre de méthodes pratiques
+# telle que each, map, count, etc...
+
+# Structures de contrôle
+
+if true
+  "si instruction"
+elsif false
+  "autrement si, facultatif"
+else
+  "autrement, également facultatif"
+end
+
+for compteur in 1..5
+  puts "itération #{compteur}"
+end
+#=> itération 1
+#=> itération 2
+#=> itération 3
+#=> itération 4
+#=> itération 5
+
+# CEPENDANT, Personne n'utilise la boucle for.
+# À la place, vous devrez utiliser la méthode "each"
+# et lui passer un bloc de code.
+# Un bloc de code est un ensemble d'instructions que vous pouvez passer à une methode comme "each".
+# Les blocs sont similaires aux lambdas, les fonctions anonymes ou les closures dans d'autres langages.
+#
+# La méthode "each" exécute le bloc de code pour chaque élément de l'interval d'éléments.
+# Le bloc de code passe un paramètre compteur.
+# Appeler la méthode "each" avec un bloc de code comme ceci :
+
+(1..5).each do |compteur|
+  puts "itération #{compteur}"
+end
+#=> itération 1
+#=> itération 2
+#=> itération 3
+#=> itération 4
+#=> itération 5
+
+# Vous pouvez également mettre un bloc de code entre accolades :
+(1..5).each {|compteur| puts "itération #{compteur}"}
+
+# Le contenu des structures de données peut être parcouru
+# en utilisant la méthode each.
+array.each do |element|
+  puts "#{element} est une partie du tableau"
+end
+hash.each do |cle, valeur|
+  puts "#{cle} est #{valeur}"
+end
+
+compteur = 1
+while compteur <= 5 do
+  puts "itération #{compteur}"
+  compteur += 1
+end
+#=> itération 1
+#=> itération 2
+#=> itération 3
+#=> itération 4
+#=> itération 5
+
+grade = 'B'
+
+case grade
+when 'A'
+  puts "Excellence"
+when 'B'
+  puts "Plus de chance la première fois"
+when 'C'
+  puts "Vous pouvez faire mieux"
+when 'D'
+  puts "C'est pas terrible"
+when 'F'
+  puts "Vous avez échoué!"
+else
+  puts "Sytème de notation alternatif"
+end
+
+# Fonctions
+
+def double(x)
+  x * 2
+end
+
+# Les fonctions (et tous les blocs de code) retournent
+# implicitement la valeur de la dernière instruction évaluée
+double(2) #=> 4
+
+# Les paranthèses sont facultative
+# où il n'y a pas d'ambiguïté sur le résultat
+double 3 #=> 6
+
+double double 3 #=> 12
+
+def sum(x,y)
+  x + y
+end
+
+# Les paramètres de méthode sont séparés par des virgules
+sum 3, 4 #=> 7
+
+sum sum(3,4), 5 #=> 12
+
+# yield
+# Toutes les méthodes ont un argument de type bloc de code
+# facultatif et implicite
+# il peut être appelé avec le mot clé 'yield'
+
+def surround
+  puts "{"
+  yield
+  puts "}"
+end
+
+surround { puts 'Bonjour tout le monde' }
+
+# {
+# Bonjour tout le monde
+# }
+
+
+# Définir une classe avec le mot clé 'class'
+class Humain
+
+  # Une variable de classe,
+  # elle est partagée par toutes les instances de cette classe.
+  @@espece = "H. sapiens"
+
+  # Constructeur de classe
+  def initialize(nom, age = 0)
+    # Affecter l'argument à la variable d'instance 'nom'
+    # pour la durée de vie de l'instance de cette classe
+    @nom = nom
+    # Si le paramètre 'age' est absent,
+    # la valeur par défaut définie dans la liste des arguments sera utilisée.
+    @age = age
+  end
+
+  # Une simple méthode setter
+  def nom=(nom)
+    @nom = nom
+  end
+
+  # Une simple méthode getter
+  def nom
+    @nom
+  end
+
+  # Une méthode de classe utilise le mot clé 'self'
+  # pour se distinguer de la méthode d'instance.
+  # La méthode sera alors accessible à partir de la classe
+  # et non pas de l'instance.
+  def self.say(msg)
+    puts "#{msg}"
+  end
+
+  def species
+    @@species
+  end
+
+end
+
+
+# Instancier une classe
+jim = Humain.new("Jim Halpert")
+
+dwight = Humain.new("Dwight K. Schrute")
+
+# Appelons quelques méthodes
+jim.espece #=> "H. sapiens"
+jim.nom #=> "Jim Halpert"
+jim.nom = "Jim Halpert II" #=> "Jim Halpert II"
+jim.nom #=> "Jim Halpert II"
+dwight.espece #=> "H. sapiens"
+dwight.nom #=> "Dwight K. Schrute"
+
+# Appelons la méthode de classe
+Humain.say("Hi") #=> "Hi"
+
+# Les classes sont également des objets en Ruby.
+# Par conséquent, les classes peuvent avoir des variables d'instance.
+# Les variables de classe sont partagées parmi
+# la classe et ses descendants.
+
+# Classe de base
+class Humain
+  @@foo = 0
+
+  def self.foo
+    @@foo
+  end
+
+  def self.foo=(valeur)
+    @@foo = valeur
+  end
+end
+
+# Héritage de classe
+class Travailleur < Humain
+end
+
+Humain.foo # 0
+Travailleur.foo # 0
+
+Humain.foo = 2 # 2
+Travailleur.foo # 2
+
+# Les variables d'instance de classe ne sont pas partagées
+# avec les classes héritées.
+
+class Humain
+  @bar = 0
+
+  def self.bar
+    @bar
+  end
+
+  def self.bar=(valeur)
+    @bar = valeur
+  end
+end
+
+class Docteur < Humain
+end
+
+Humain.bar # 0
+Docteur.bar # nil
+
+```
-- 
cgit v1.2.3


From ba34fa65ec582f9fc91180eebb77c57cf41a98ff Mon Sep 17 00:00:00 2001
From: Geoffrey Roguelon <geoffrey.roguelon@gmail.com>
Date: Thu, 15 Aug 2013 10:45:06 +0200
Subject: Fix the comments of French Ruby file from the Nami-Doc's comments
 (adambard/learnxinyminutes-docs#223).

Thanks to him.
---
 fr-fr/ruby-fr.html.markdown | 81 +++++++++++++++++++++++----------------------
 1 file changed, 41 insertions(+), 40 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/ruby-fr.html.markdown b/fr-fr/ruby-fr.html.markdown
index f6bfe42a..f5212787 100644
--- a/fr-fr/ruby-fr.html.markdown
+++ b/fr-fr/ruby-fr.html.markdown
@@ -9,6 +9,7 @@ contributors:
   - ["Nick LaMuro", "https://github.com/NickLaMuro"]
 translators:
   - ["Geoffrey Roguelon", "https://github.com/GRoguelon"]
+  - ["Nami-Doc", "https://github.com/Nami-Doc"]
 lang: fr-fr
 ---
 
@@ -29,21 +30,21 @@ Vous devriez en faire de même
 
 3.to_s #=> "3"
 
-# Arithmétique de base
+# Les opérateurs de base
 1 + 1 #=> 2
 8 - 1 #=> 7
 10 * 2 #=> 20
 35 / 5 #=> 7
 
-# L'arithmétique est juste un raccourci
-# pour appeler la méthode d'un objet
+# Les opérateurs sont juste des raccourcis
+# pour appeler une méthode sur un objet
 1.+(3) #=> 4
 10.* 5 #=> 50
 
 # Les valeurs spéciales sont des objets
-nil # Nothing to see here
-true # truth
-false # falsehood
+nil # Nul
+true # Vrai
+false # Faux
 
 nil.class #=> NilClass
 true.class #=> TrueClass
@@ -80,7 +81,7 @@ placeholder = "utiliser l'interpolation de chaîne de caractères"
 "Je peux #{placeholder} quand j'utilise les guillemets"
 #=> "Je peux utiliser l'interpolation de chaîne de caractères quand j'utilise les guillemets"
 
-# Afficher sur la sortie standard
+# Affichez un message
 puts "J'affiche à l'écran!"
 
 # Variables
@@ -94,15 +95,15 @@ x = y = 10 #=> 10
 x #=> 10
 y #=> 10
 
-# Par convention, utiliser snake_case (à base d'underscore)
-# comme nom de variable
+# Par convention, utilisez la notation underscore
+# pour nommer les variables
 snake_case = true
 
-# Utiliser des noms de variable explicites
+# Utilisez des noms de variable explicites
 path_to_project_root = '/nom/correct/'
 path = '/mauvais/nom/'
 
-# Symboles (sont des objets)
+# Symboles (aussi des objets)
 # Les symboles sont immuables, constants,
 # réutilisables et représentés en interne
 # par une valeur entière. Ils sont souvent
@@ -129,40 +130,40 @@ array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
 
 [1, "hello", false] #=> [1, "hello", false]
 
-# Les tableaux peuvent être indéxés
+# Les tableaux peuvent être indexés
 # Du début
 array[0] #=> 1
 array[12] #=> nil
 
-# Comme l'arithmétique, la syntaxe [var] est juste un raccourci
+# Comme les opérateurs, la syntaxe [var] est juste un raccourci
 # pour appeler la méthode [] d'un objet
 array.[] 0 #=> 1
 array.[] 12 #=> nil
 
-# À la fin
+# Depuis la fin
 array[-1] #=> 5
 
 # Avec un index de début et de fin
 array[2, 4] #=> [3, 4, 5]
 
-# Ou avec un interval
+# Ou avec un intervalle
 array[1..3] #=> [2, 3, 4]
 
-# Ajouter un élément au tableau comme ceci
+# Ajoutez un élément au tableau comme ceci
 array << 6 #=> [1, 2, 3, 4, 5, 6]
 
-# Les Hashes sont des dictionnaires Ruby contenant des paires de clé/valeur.
-# Les Hashes sont délimitées par des accolades :
+# Les Hash sont des dictionnaires Ruby contenant des paires de clé/valeur.
+# Les Hash sont délimitées par des accolades :
 hash = {'color' => 'green', 'number' => 5}
 
 hash.keys #=> ['color', 'number']
 
-# Les Hashes peuvent retourner rapidement
-# la valeur en utilisant la clé :
+# Les Hash retournent la valeur
+# en utilisant la clé associée à la valeur :
 hash['color'] #=> 'green'
 hash['number'] #=> 5
 
-# Rechercher une clé inexistante dans une Hash retourne nil:
+# Recherchez une clé inexistante dans une Hash retourne nil :
 hash['nothing here'] #=> nil
 
 # Depuis Ruby 1.9, Une syntaxe spécifique est apparue en utilisant les symboles comme clés :
@@ -171,7 +172,7 @@ new_hash = { defcon: 3, action: true}
 
 new_hash.keys #=> [:defcon, :action]
 
-# Astuce : Les tableaux et les Hashes sont dénombrables
+# Astuce : Les tableaux et les Hash sont dénombrables
 # Ils partagent un certain nombre de méthodes pratiques
 # telle que each, map, count, etc...
 
@@ -194,15 +195,15 @@ end
 #=> itération 4
 #=> itération 5
 
-# CEPENDANT, Personne n'utilise la boucle for.
-# À la place, vous devrez utiliser la méthode "each"
-# et lui passer un bloc de code.
+# CEPENDANT, l'usage de la boucle for est très rare.
+# À la place, utilisez la méthode "each"
+# et passez lui un bloc de code.
 # Un bloc de code est un ensemble d'instructions que vous pouvez passer à une methode comme "each".
 # Les blocs sont similaires aux lambdas, les fonctions anonymes ou les closures dans d'autres langages.
 #
-# La méthode "each" exécute le bloc de code pour chaque élément de l'interval d'éléments.
+# La méthode "each" exécute le bloc de code pour chaque élément de l'intervalle d'éléments.
 # Le bloc de code passe un paramètre compteur.
-# Appeler la méthode "each" avec un bloc de code comme ceci :
+# Appelez la méthode "each" avec un bloc de code comme ceci :
 
 (1..5).each do |compteur|
   puts "itération #{compteur}"
@@ -240,7 +241,7 @@ grade = 'B'
 
 case grade
 when 'A'
-  puts "Excellence"
+  puts "Excellent"
 when 'B'
   puts "Plus de chance la première fois"
 when 'C'
@@ -264,7 +265,7 @@ end
 double(2) #=> 4
 
 # Les paranthèses sont facultative
-# où il n'y a pas d'ambiguïté sur le résultat
+# lorsqu'il n'y a pas d'ambiguïté sur le résultat
 double 3 #=> 6
 
 double double 3 #=> 12
@@ -279,8 +280,8 @@ sum 3, 4 #=> 7
 sum sum(3,4), 5 #=> 12
 
 # yield
-# Toutes les méthodes ont un argument de type bloc de code
-# facultatif et implicite
+# Toutes les méthodes ont un argument facultatif et implicite
+# de type bloc de code
 # il peut être appelé avec le mot clé 'yield'
 
 def surround
@@ -296,16 +297,16 @@ surround { puts 'Bonjour tout le monde' }
 # }
 
 
-# Définir une classe avec le mot clé 'class'
+# Définissez une classe avec le mot clé 'class'
 class Humain
 
-  # Une variable de classe,
-  # elle est partagée par toutes les instances de cette classe.
+  # Une variable de classe
+  # est partagée par toutes les instances de cette classe.
   @@espece = "H. sapiens"
 
   # Constructeur de classe
   def initialize(nom, age = 0)
-    # Affecter l'argument à la variable d'instance 'nom'
+    # Affectez l'argument à la variable d'instance 'nom'
     # pour la durée de vie de l'instance de cette classe
     @nom = nom
     # Si le paramètre 'age' est absent,
@@ -338,12 +339,12 @@ class Humain
 end
 
 
-# Instancier une classe
+# Instanciez une classe
 jim = Humain.new("Jim Halpert")
 
 dwight = Humain.new("Dwight K. Schrute")
 
-# Appelons quelques méthodes
+# Appelez quelques méthodes
 jim.espece #=> "H. sapiens"
 jim.nom #=> "Jim Halpert"
 jim.nom = "Jim Halpert II" #=> "Jim Halpert II"
@@ -351,7 +352,7 @@ jim.nom #=> "Jim Halpert II"
 dwight.espece #=> "H. sapiens"
 dwight.nom #=> "Dwight K. Schrute"
 
-# Appelons la méthode de classe
+# Appelez la méthode de classe
 Humain.say("Hi") #=> "Hi"
 
 # Les classes sont également des objets en Ruby.
@@ -359,7 +360,7 @@ Humain.say("Hi") #=> "Hi"
 # Les variables de classe sont partagées parmi
 # la classe et ses descendants.
 
-# Classe de base
+# Classe parente
 class Humain
   @@foo = 0
 
@@ -372,7 +373,7 @@ class Humain
   end
 end
 
-# Héritage de classe
+# Classe fille
 class Travailleur < Humain
 end
 
-- 
cgit v1.2.3


From 7f8e5deba129c4b9fb34b89077a63829546b0bd3 Mon Sep 17 00:00:00 2001
From: Geoffrey Roguelon <geoffrey.roguelon@gmail.com>
Date: Thu, 15 Aug 2013 12:22:36 +0200
Subject: Fix a word of French Ruby language.

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

(limited to 'fr-fr')

diff --git a/fr-fr/ruby-fr.html.markdown b/fr-fr/ruby-fr.html.markdown
index f5212787..5efb2f3c 100644
--- a/fr-fr/ruby-fr.html.markdown
+++ b/fr-fr/ruby-fr.html.markdown
@@ -243,7 +243,7 @@ case grade
 when 'A'
   puts "Excellent"
 when 'B'
-  puts "Plus de chance la première fois"
+  puts "Plus de chance la prochaine fois"
 when 'C'
   puts "Vous pouvez faire mieux"
 when 'D'
-- 
cgit v1.2.3


From ed2884ca3c60571169bb93f853d307808f319522 Mon Sep 17 00:00:00 2001
From: Geoffrey Roguelon <geoffrey.roguelon@gmail.com>
Date: Sat, 17 Aug 2013 10:29:45 +0200
Subject: Split the comment lines to avoid the exceeding of the block of code.

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

(limited to 'fr-fr')

diff --git a/fr-fr/ruby-fr.html.markdown b/fr-fr/ruby-fr.html.markdown
index 5efb2f3c..ab3ce0ac 100644
--- a/fr-fr/ruby-fr.html.markdown
+++ b/fr-fr/ruby-fr.html.markdown
@@ -166,7 +166,8 @@ hash['number'] #=> 5
 # Recherchez une clé inexistante dans une Hash retourne nil :
 hash['nothing here'] #=> nil
 
-# Depuis Ruby 1.9, Une syntaxe spécifique est apparue en utilisant les symboles comme clés :
+# Depuis Ruby 1.9, Une syntaxe spécifique est apparue
+# en utilisant les symboles comme clés :
 
 new_hash = { defcon: 3, action: true}
 
@@ -198,10 +199,13 @@ end
 # CEPENDANT, l'usage de la boucle for est très rare.
 # À la place, utilisez la méthode "each"
 # et passez lui un bloc de code.
-# Un bloc de code est un ensemble d'instructions que vous pouvez passer à une methode comme "each".
-# Les blocs sont similaires aux lambdas, les fonctions anonymes ou les closures dans d'autres langages.
+# Un bloc de code est un ensemble d'instructions
+# que vous pouvez passer à une methode comme "each".
+# Les blocs sont similaires aux lambdas, les fonctions anonymes
+# ou les closures dans d'autres langages.
 #
-# La méthode "each" exécute le bloc de code pour chaque élément de l'intervalle d'éléments.
+# La méthode "each" exécute le bloc de code
+# pour chaque élément de l'intervalle d'éléments.
 # Le bloc de code passe un paramètre compteur.
 # Appelez la méthode "each" avec un bloc de code comme ceci :
 
-- 
cgit v1.2.3


From 6280f879b1395d61f07f223a9e4a4f0973414fdd Mon Sep 17 00:00:00 2001
From: Geoffrey Roguelon <geoffrey.roguelon@gmail.com>
Date: Sat, 17 Aug 2013 10:31:54 +0200
Subject: Fix French syntax.

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

(limited to 'fr-fr')

diff --git a/fr-fr/ruby-fr.html.markdown b/fr-fr/ruby-fr.html.markdown
index ab3ce0ac..3060bd75 100644
--- a/fr-fr/ruby-fr.html.markdown
+++ b/fr-fr/ruby-fr.html.markdown
@@ -201,8 +201,8 @@ end
 # et passez lui un bloc de code.
 # Un bloc de code est un ensemble d'instructions
 # que vous pouvez passer à une methode comme "each".
-# Les blocs sont similaires aux lambdas, les fonctions anonymes
-# ou les closures dans d'autres langages.
+# Les blocs sont similaires aux lambdas, aux fonctions anonymes
+# ou encore aux closures dans d'autres langages.
 #
 # La méthode "each" exécute le bloc de code
 # pour chaque élément de l'intervalle d'éléments.
-- 
cgit v1.2.3


From f07376a26830eb9c2ade7933ca45191776e965da Mon Sep 17 00:00:00 2001
From: Geoffrey Roguelon <geoffrey.roguelon@gmail.com>
Date: Sat, 17 Aug 2013 18:33:18 +0200
Subject: Add french coffeescript translation.

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

(limited to 'fr-fr')

diff --git a/fr-fr/coffeescript-fr.html.markdown b/fr-fr/coffeescript-fr.html.markdown
new file mode 100644
index 00000000..c66b7be0
--- /dev/null
+++ b/fr-fr/coffeescript-fr.html.markdown
@@ -0,0 +1,58 @@
+---
+language: coffeescript
+contributors:
+  - ["Tenor Biel", "http://github.com/L8D"]
+translators:
+  - ["Geoffrey Roguelon", "https://github.com/GRoguelon"]
+lang: fr-fr
+filename: coffeescript-fr.coffee
+---
+
+``` coffeescript
+# CoffeeScript est un langage préprocesseur, il permet de générer du Javascript.
+# Il suit les tendances de certains langages récents.
+# Par exemple, les commentaires se définissent comme en Ruby ou en Python.
+
+###
+Ceci est un bloc de commentaires
+il est converti directement avec '/ *' et '* /'
+pour correspondre aux commentaires Javascript
+
+Vous devez comprendre la syntaxe du langage JavaScript pour continuer.
+###
+
+# Affectation :
+number   = 42 #=> var number = 42;
+opposite = true #=> var opposite = true;
+
+# Structures de contrôle :
+number = -42 if opposite #=> if(opposite) { number = -42; }
+
+# Fonctions :
+square = (x) -> x * x #=> var square = function(x) { return x * x; }
+
+# Intervals :
+list = [1..5] #=> var list = [1, 2, 3, 4, 5];
+
+# Objets :
+math =
+  root:   Math.sqrt
+  square: square
+  cube:   (x) -> x * square x
+#=> var math = {
+#  "root": Math.sqrt,
+#  "square": square,
+#  "cube": function(x) { return x * square(x); }
+#}
+
+# Liste d'arguments variables :
+race = (winner, runners...) ->
+  print winner, runners
+
+# Existance :
+alert "I knew it!" if elvis?
+#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("I knew it!"); }
+
+# Lecture d'un tableau :
+cubes = (math.cube num for num in list) #=> ...
+```
-- 
cgit v1.2.3


From d22029e0d0e300c5fb4538748e5ed696eeb0241f Mon Sep 17 00:00:00 2001
From: Syl Zys <sylzys@gmail.com>
Date: Sun, 8 Sep 2013 14:53:33 +0200
Subject: Added Python French translation

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

(limited to 'fr-fr')

diff --git a/fr-fr/python-fr.html.markdown b/fr-fr/python-fr.html.markdown
new file mode 100644
index 00000000..84831772
--- /dev/null
+++ b/fr-fr/python-fr.html.markdown
@@ -0,0 +1,491 @@
+---
+langage: python
+
+contributeurs:
+    - ["Louie Dinh", "http://ldinh.ca"]
+    
+traducteurs:
+  - ["Sylvain Zyssman", "https://github.com/sylzys"]
+
+fichier: learnpython.py
+
+---
+
+Python a été créé par Guido Van Rossum au début des années 90. C'est maintenant un des langages de promgrammation les plus populaires.
+Je suis tombé amoureux de Python de par la clarité de sa syntaxe. C'est pratiquement du pseudo-code exécutable.
+
+Vos retours sont grandement appréciés. Vous pouvez me contacter sur Twitter [@louiedinh](http://twitter.com/louiedinh) ou par e-mail: louiedinh [at] [google's email service]
+
+NB: Cet artice s'applique spécifiquement à Python 2.7, mais devrait s'appliquer pour toute version Python 2.x
+Vous pourrez bientôt trouver un article pour Python 3!
+
+```python
+# Une ligne simple de commentaire commence par un dièse
+""" Les lignes de commenatires multipes peut être écrite
+    en utilisant 3 '"', et sont souvent utilisées
+    pour commenter
+"""
+
+####################################################
+## 1. Types Primaires et Opérateurs
+####################################################
+
+# Les nombres
+3 #=> 3
+
+# Les calculs produisent les résultats mathématiques escomptés
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+
+# La division est un peu spéciale. C'est une division d' "int", et Python arrondi le résultat par défaut automatiquement.
+5 / 2 #=> 2
+
+# Pour corriger ce problème, on utilise les float.
+2.0     # Voici un float
+11.0 / 4.0 #=> 2.75 ahhh...beaucoup mieux
+
+# Forcer la priorité avec les parenthèses
+(1 + 3) * 2 #=> 8
+
+# Les valeurs booléenes sont de type primitif
+True
+False
+
+# Pour la négation, on utilise "not"
+not True #=> False
+not False #=> True
+
+# Pour l'égalité, ==
+1 == 1 #=> True
+2 == 1 #=> False
+
+# L'inégalité est symbolisée par !=
+1 != 1 #=> False
+2 != 1 #=> True
+
+# D'autres comparateurs
+1 < 10 #=> True
+1 > 10 #=> False
+2 <= 2 #=> True
+2 >= 2 #=> True
+
+# On peut enchaîner les comparateurs !
+1 < 2 < 3 #=> True
+2 < 3 < 2 #=> False
+
+# Les chaînes de caractères sont créées avec " ou '
+"C'est une chaîne."
+'C'est aussi une chaîne.'
+
+# On peut aussi les "additioner" !
+"Hello " + "world!" #=> "Hello world!"
+
+# Une chaîne peut être traiter comme une liste de caractères
+"C'est une chaîne"[0] #=> 'C'
+
+# % peut être utilisé pour formatter des chaîne, comme ceci:
+"%s can be %s" % ("strings", "interpolated")
+
+# Une nouvelle manière de formatter les chaînes de caractères est d'utiliser la méthode 'format'
+# C'est la méthode à privilégier
+"{0} peut être {1}".format("La chaîne", "formattée")
+# On peut utiliser des mot-clés au lieu des chiffres.
+"{name} veut manger des {food}".format(name="Bob", food="lasagnes")
+
+# None est un objet
+None #=> None
+
+# Ne pas utiliser le symbole d'inégalité "==" pour comparer des objet à None
+# Il faut utiliser "is"
+"etc" is None #=> False
+None is None  #=> True
+
+# L'opérateur 'is' test l'identité de l'objet.
+# Ce n'est pas très utilse avec les types primitifs, mais cela peut être très util
+# lorsque l'on utilise des objets.
+
+# None, 0, et les chaînes de caractères vides valent False.
+# Toutes les autres valeurs valent True
+0 == False  #=> True
+"" == False #=> True
+
+
+####################################################
+## 2. Variables et Collections
+####################################################
+
+# Afficher, c'est facile
+print "Je suis Python. Enchanté!"
+
+
+# Il n'y a pas besoin de déclarer les variables avant de les assigner.
+some_var = 5    # La convention veut que l'on utilise des minuscules_avec_underscores
+some_var #=> 5
+
+# Accéder à une variable non assignée lève une exception
+# Voyez les structures de contrôle pour en apprendre plus sur la gestion des exceptions.
+some_other_var  # Lève une exception
+
+# 'if' peut être utilisé comme expression
+"yahoo!" if 3 > 2 else 2 #=> "yahoo!"
+
+# Listes
+li = []
+# On peut utiliser une liste pré-remplie.
+other_li = [4, 5, 6]
+
+# On ajoute des éléments avec 'append'
+li.append(1)    #li contient [1]
+li.append(2)    #li contient [1, 2]
+li.append(4)    #li contient [1, 2, 4]
+li.append(3)    #li contient [1, 2, 4, 3]
+
+# Et on les supprime avec 'pop'
+li.pop()        #=> 3 et li contient [1, 2, 4]
+# Remettons-le dans la liste
+li.append(3)    # li contient [1, 2, 4, 3] de nouveau.
+
+# On accède aux éléments d'une liste comme pour un tableau.
+li[0] #=> 1
+# Le dernier élément
+li[-1] #=> 3
+
+# Accèder aux indes hors limite lève une exception
+li[4] # Lève un 'IndexError'
+
+# On peut accèder à des rangs de valeurs avec la syntaxe "slice"
+# (C'est un rang de type 'fermé/ouvert' pour les plus matheux)
+li[1:3] #=> [2, 4]
+# Ne pas spécifier de début de rang
+li[2:] #=> [4, 3]
+# Ne pas spécifier de fin de rang
+li[:3] #=> [1, 2, 4]
+
+# Retirer un élément spécifique dee la lsite avec "del"
+del li[2] # li contient [1, 2, 3]
+
+# On peut additionner des listes entre elles
+li + other_li #=> [1, 2, 3, 4, 5, 6] - Note: li et other_li existent toujours à part entière
+
+# Concatener des listes avec "extend()"
+li.extend(other_li) # li vaut maintenant [1, 2, 3, 4, 5, 6]
+
+# Vérifier l'existence d'un élément dans une liste avec "in"
+1 in li #=> True
+
+# Récupérer la longueur avec "len()"
+len(li) #=> 6
+
+
+# Les "tuples", sont comme des listes, mais sont immuables.
+tup = (1, 2, 3)
+tup[0] #=> 1
+tup[0] = 3  # Lève un 'TypeError'
+
+# Mais vous pouvez faire tout ceci sur les tuples:
+len(tup) #=> 3
+tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6)
+tup[:2] #=> (1, 2)
+2 in tup #=> True
+
+# Vous pouvez "dé-packager" les tupels (ou les listes) dans des variables
+a, b, c = (1, 2, 3)     # a vaut maintenant 1, b vaut maintenant 2 and c vaut maintenant 3
+# Sans parenthèses, un tuple est créé par défaut
+d, e, f = 4, 5, 6
+# Voyez maintenant comme il est facile d'inverse 2 valeurs
+e, d = d, e     # d is now 5 and e is now 4
+
+
+# Dictionaires
+empty_dict = {}
+# Un dictionnaire pré-rempli
+filled_dict = {"one": 1, "two": 2, "three": 3}
+
+# Trouver des valeurs avec []
+filled_dict["one"] #=> 1
+
+# Récupérer toutes les clés sous forme de liste avec "keys()"
+filled_dict.keys() #=> ["three", "two", "one"]
+# Note - l'odre des clés du dictionnaire n'est pas garanti.
+# Vos résultats peuvent différer de ceux ci-dessous.
+
+# Récupérer toutes les valeurs sous forme de liste avec "values()"
+filled_dict.values() #=> [3, 2, 1]
+# Note - Même remarque qu'au-dessus concernant l'ordre des valeurs.
+
+# Vérifier l'existence d'une clé dans le dictionnaire avec "in"
+"one" in filled_dict #=> True
+1 in filled_dict #=> False
+
+# Chercher une clé non existence lève une 'KeyError'
+filled_dict["four"] # KeyError
+
+# Utiliser la méthode "get()" pour éviter 'KeyError'
+filled_dict.get("one") #=> 1
+filled_dict.get("four") #=> None
+# La méthode get() prend un argument par défaut quand la valeur est inexistante
+filled_dict.get("one", 4) #=> 1
+filled_dict.get("four", 4) #=> 4
+
+# La méthode "setdefault()" permet d'ajouter de manière sécuris une paire clé-valeur dans le dictionnnaire
+filled_dict.setdefault("five", 5) #filled_dict["five"] vaut 5
+filled_dict.setdefault("five", 6) #filled_dict["five"] is toujours 5
+
+
+# Les sets stockent ... des sets
+empty_set = set()
+# On initialise un "set()" avec tout un tas de valeurs
+some_set = set([1,2,2,3,4]) # some_set vaut maintenant set([1, 2, 3, 4])
+
+# Depuis Python 2.7, {} peut être utilisé pour déclarer un 'set'
+filled_set = {1, 2, 2, 3, 4} # => {1 2 3 4}
+
+# Ajouter plus d'éléments au set
+filled_set.add(5) # filled_set contient maintenant {1, 2, 3, 4, 5}
+
+# Intersection de sets avec &
+other_set = {3, 4, 5, 6}
+filled_set & other_set #=> {3, 4, 5}
+
+# Union de sets avec |
+filled_set | other_set #=> {1, 2, 3, 4, 5, 6}
+
+# Différence de sets avec -
+{1,2,3,4} - {2,3,5} #=> {1, 4}
+
+# Vérifier l'existene d'une valeur dans un set avec "in"
+2 in filled_set #=> True
+10 in filled_set #=> False
+
+
+####################################################
+## 3. Structure de contrôle
+####################################################
+
+# Initialisons une variable
+some_var = 5
+
+# Voici une condition 'if'. L'indentation est significative en Python !
+# Affiche "some_var est inférieur à 10"
+if some_var > 10:
+    print "some_var est supérieur à 10."
+elif some_var < 10:    # La clause elif est optionnelle
+    print "some_var iinférieur à 10."
+else:           # Optionnel également
+    print "some_var vaut 10."
+
+
+"""
+Les boucles "for" font des itérations sur les listes
+Affiche:
+    chien : mammifère
+    chat : mammifère
+    souris : mammifère
+"""
+for animal in ["chien", "chat", "souris"]:
+    # On peut utiliser % pour l'interpolation des chaînes formattées
+    print "%s : mammifère" % animal
+
+"""
+"range(number)" retourne une liste de nombres
+de 0 au nombre donné
+Affiche:
+    0
+    1
+    2
+    3
+"""
+for i in range(4):
+    print i
+
+"""
+Les boucles "while" boucle jusqu'à ce qu'une condition ne soit plus vraie
+Affiche:
+    0
+    1
+    2
+    3
+"""
+x = 0
+while x < 4:
+    print x
+    x += 1  # Raccourci pour x = x + 1
+
+# Gérer les exceptions avec un bloc try/except
+
+# Fonctionne pour Python 2.6 et ultérieur:
+try:
+    # Utiliser "raise" pour lever une exception
+    raise IndexError("This is an index error")
+except IndexError as e:
+    pass    # Pass ne prend pas d'arguments. Généralement, on gère l'erreur ici.
+
+
+####################################################
+## 4. Fonctions
+####################################################
+
+# Utiliser "def" pour créer une nouvelle fonction
+def add(x, y):
+    print "x vaut %s et y vaur %s" % (x, y)
+    return x + y    # Renvoi de valeur avec 'return'
+
+# Appeller une fonction avec des paramètres
+add(5, 6) #=> Affichet "x is 5 et y vaut 6" et renvoie 11
+
+# Une autre manière d'appeller une fonction, avec les arguments
+add(y=6, x=5)   # Les arguments peuvent venir dans n'importe quel ordre.
+
+# On peut définir une foncion qui prend un nombre variable de paramètres
+def varargs(*args):
+    return args
+
+varargs(1, 2, 3) #=> (1,2,3)
+
+
+# Ont peut également définir une fonction qui prend un nombrenumber of
+# variable d'arguments
+def keyword_args(**kwargs):
+    return kwargs
+
+# Appelons-là et voyons ce qu'il se passe
+keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"}
+
+# On peut faire les deux à la fois si on le souhaite
+def all_the_args(*args, **kwargs):
+    print args
+    print kwargs
+"""
+all_the_args(1, 2, a=3, b=4) affiche:
+    (1, 2)
+    {"a": 3, "b": 4}
+"""
+
+# En appellant les fonctions, on peut faire l'inverse des paramètres / arguments !
+# Utiliser * pour développer les paramètres, et ** pour développer les arguments
+params = (1, 2, 3, 4)
+args = {"a": 3, "b": 4}
+all_the_args(*args) # equivaut à foo(1, 2, 3, 4)
+all_the_args(**kwargs) # equivaut à foo(a=3, b=4)
+all_the_args(*args, **kwargs) # equivaut à foo(1, 2, 3, 4, a=3, b=4)
+
+# Python a des fonctions de première classe
+def create_adder(x):
+    def adder(y):
+        return x + y
+    return adder
+
+add_10 = create_adder(10)
+add_10(3) #=> 13
+
+# Mais également des fonctions anonymes
+(lambda x: x > 2)(3) #=> True
+
+# On trouve aussi des fonctions intégrées plus évoluées
+map(add_10, [1,2,3]) #=> [11, 12, 13]
+filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
+
+# On peut utiliser la syntaxe des liste pour construire les "maps" et les "filters"
+[add_10(i) for i in [1, 2, 3]]  #=> [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]
+
+####################################################
+## 5. Classes
+####################################################
+
+# Une classe hérite d'un objet
+class Human(object):
+
+    # L'attribut d'une classe. Il est partagé par toutes les instances de cette classe.
+    species = "H. sapiens"
+
+    # Initialiseur basique
+    def __init__(self, name):
+        # Assigne le paramètre à l'attribut de l'instance de classe.
+        self.name = name
+
+    # Une méthode de l'instance. Toutes les méthodes prennent "self" comme 1er paramètre.
+    def say(self, msg):
+       return "%s: %s" % (self.name, msg)
+
+    # Une méthode de classe est partagée par toutes les instances.
+    # On les appelle avec le nom de la classe en premier paramètre
+    @classmethod
+    def get_species(cls):
+        return cls.species
+
+    # Une méthode statique est appellée sans référence à une classe ou à une instance 
+    @staticmethod
+    def grunt():
+        return "*grunt*"
+
+
+# Instancier une classe
+i = Human(name="Ian")
+print i.say("hi")     # Affiche "Ian: hi"
+
+j = Human("Joel")
+print j.say("hello")  #Affiche "Joel: hello"
+
+# Appeller notre méthode de classe
+i.get_species() #=> "H. sapiens"
+
+# Changer les attributs partagés
+Human.species = "H. neanderthalensis"
+i.get_species() #=> "H. neanderthalensis"
+j.get_species() #=> "H. neanderthalensis"
+
+# Appeller la méthode statique
+Human.grunt() #=> "*grunt*"
+
+
+####################################################
+## 6. Modules
+####################################################
+
+# On peut importer des modules
+import math
+print math.sqrt(16) #=> 4
+
+# Et récupérer des fonctions spécifiques d'un module
+from math import ceil, floor
+print ceil(3.7)  #=> 4.0
+print floor(3.7) #=> 3.0
+
+# Récuperer toutes les fonctions d'un module
+# Attention, ce n'est pas recommandé.
+from math import *
+
+# On peut raccourcir le nom d'un module
+import math as m
+math.sqrt(16) == m.sqrt(16) #=> True
+
+# Les modules Python sont juste des fichiers Python ordinaires.
+# On peut écrire ses propres modules et les importer.
+# Le nom du module doit être le même que le nom du fichier.
+
+# On peut trouver quelle fonction et attributs déterminent un module
+import math
+dir(math)
+
+
+```
+
+## Prêt à aller plus loin?
+
+### En ligne gratuitement
+
+* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+* [Dive Into Python](http://www.diveintopython.net/)
+* [The Official Docs](http://docs.python.org/2.6/)
+* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
+* [Python Module of the Week](http://pymotw.com/2/)
+
+### Format papier
+
+* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
+* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
+* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
+
-- 
cgit v1.2.3


From b466a86d9d293c0ddab7db089c31158a065b4cf1 Mon Sep 17 00:00:00 2001
From: Syl Zys <sylzys@gmail.com>
Date: Sun, 8 Sep 2013 16:27:38 +0200
Subject: typo corrections, thanks to Nami-Doc for re-reading

---
 fr-fr/python-fr.html.markdown | 66 +++++++++++++++++++++----------------------
 1 file changed, 33 insertions(+), 33 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/python-fr.html.markdown b/fr-fr/python-fr.html.markdown
index 84831772..2f10e410 100644
--- a/fr-fr/python-fr.html.markdown
+++ b/fr-fr/python-fr.html.markdown
@@ -11,8 +11,8 @@ fichier: learnpython.py
 
 ---
 
-Python a été créé par Guido Van Rossum au début des années 90. C'est maintenant un des langages de promgrammation les plus populaires.
-Je suis tombé amoureux de Python de par la clarité de sa syntaxe. C'est pratiquement du pseudo-code exécutable.
+Python a été créé par Guido Van Rossum au début des années 90. C'est maintenant un des langages de programmation les plus populaires.
+Je suis tombé amoureux de Python de par la clarté de sa syntaxe. C'est pratiquement du pseudo-code exécutable.
 
 Vos retours sont grandement appréciés. Vous pouvez me contacter sur Twitter [@louiedinh](http://twitter.com/louiedinh) ou par e-mail: louiedinh [at] [google's email service]
 
@@ -21,9 +21,9 @@ Vous pourrez bientôt trouver un article pour Python 3!
 
 ```python
 # Une ligne simple de commentaire commence par un dièse
-""" Les lignes de commenatires multipes peut être écrite
-    en utilisant 3 '"', et sont souvent utilisées
-    pour commenter
+""" Les lignes de commenatires multipes peuvent être écrites
+    en utilisant 3 guillemets ("), et sont souvent utilisées
+    pour les commentaires
 """
 
 ####################################################
@@ -39,12 +39,12 @@ Vous pourrez bientôt trouver un article pour Python 3!
 10 * 2 #=> 20
 35 / 5 #=> 7
 
-# La division est un peu spéciale. C'est une division d' "int", et Python arrondi le résultat par défaut automatiquement.
+# La division est un peu spéciale. C'est une division d'entiers, et Python arrondi le résultat par défaut automatiquement.
 5 / 2 #=> 2
 
 # Pour corriger ce problème, on utilise les float.
 2.0     # Voici un float
-11.0 / 4.0 #=> 2.75 ahhh...beaucoup mieux
+11.0 / 4.0 #=> 2.75 ahhh... beaucoup mieux
 
 # Forcer la priorité avec les parenthèses
 (1 + 3) * 2 #=> 8
@@ -82,13 +82,13 @@ not False #=> True
 # On peut aussi les "additioner" !
 "Hello " + "world!" #=> "Hello world!"
 
-# Une chaîne peut être traiter comme une liste de caractères
+# Une chaîne peut être traitée comme une liste de caractères
 "C'est une chaîne"[0] #=> 'C'
 
 # % peut être utilisé pour formatter des chaîne, comme ceci:
 "%s can be %s" % ("strings", "interpolated")
 
-# Une nouvelle manière de formatter les chaînes de caractères est d'utiliser la méthode 'format'
+# Une autre manière de formatter les chaînes de caractères est d'utiliser la méthode 'format'
 # C'est la méthode à privilégier
 "{0} peut être {1}".format("La chaîne", "formattée")
 # On peut utiliser des mot-clés au lieu des chiffres.
@@ -102,8 +102,8 @@ None #=> None
 "etc" is None #=> False
 None is None  #=> True
 
-# L'opérateur 'is' test l'identité de l'objet.
-# Ce n'est pas très utilse avec les types primitifs, mais cela peut être très util
+# L'opérateur 'is' teste l'identité de l'objet.
+# Ce n'est pas très utilisé avec les types primitifs, mais cela peut être très utile
 # lorsque l'on utilise des objets.
 
 # None, 0, et les chaînes de caractères vides valent False.
@@ -116,7 +116,7 @@ None is None  #=> True
 ## 2. Variables et Collections
 ####################################################
 
-# Afficher, c'est facile
+# Afficher du texte, c'est facile
 print "Je suis Python. Enchanté!"
 
 
@@ -133,7 +133,7 @@ some_other_var  # Lève une exception
 
 # Listes
 li = []
-# On peut utiliser une liste pré-remplie.
+# On peut remplir liste dès l'instanciation
 other_li = [4, 5, 6]
 
 # On ajoute des éléments avec 'append'
@@ -147,29 +147,29 @@ li.pop()        #=> 3 et li contient [1, 2, 4]
 # Remettons-le dans la liste
 li.append(3)    # li contient [1, 2, 4, 3] de nouveau.
 
-# On accède aux éléments d'une liste comme pour un tableau.
+# On accède aux éléments d'une liste comme à ceux un tableau.
 li[0] #=> 1
 # Le dernier élément
 li[-1] #=> 3
 
-# Accèder aux indes hors limite lève une exception
+# Accèder aux indices hors limite lève une exception
 li[4] # Lève un 'IndexError'
 
 # On peut accèder à des rangs de valeurs avec la syntaxe "slice"
 # (C'est un rang de type 'fermé/ouvert' pour les plus matheux)
 li[1:3] #=> [2, 4]
-# Ne pas spécifier de début de rang
+# Sans spécifier de début de rang
 li[2:] #=> [4, 3]
-# Ne pas spécifier de fin de rang
+# Sans spécifier de fin de rang
 li[:3] #=> [1, 2, 4]
 
-# Retirer un élément spécifique dee la lsite avec "del"
+# Retirer un élément spécifique dee la liste avec "del"
 del li[2] # li contient [1, 2, 3]
 
 # On peut additionner des listes entre elles
 li + other_li #=> [1, 2, 3, 4, 5, 6] - Note: li et other_li existent toujours à part entière
 
-# Concatener des listes avec "extend()"
+# Concaténer des listes avec "extend()"
 li.extend(other_li) # li vaut maintenant [1, 2, 3, 4, 5, 6]
 
 # Vérifier l'existence d'un élément dans une liste avec "in"
@@ -179,7 +179,7 @@ li.extend(other_li) # li vaut maintenant [1, 2, 3, 4, 5, 6]
 len(li) #=> 6
 
 
-# Les "tuples", sont comme des listes, mais sont immuables.
+# Les "tuples" sont comme des listes, mais sont immuables.
 tup = (1, 2, 3)
 tup[0] #=> 1
 tup[0] = 3  # Lève un 'TypeError'
@@ -190,15 +190,15 @@ tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6)
 tup[:2] #=> (1, 2)
 2 in tup #=> True
 
-# Vous pouvez "dé-packager" les tupels (ou les listes) dans des variables
+# Vous pouvez "dé-packager" les tuples (ou les listes) dans des variables
 a, b, c = (1, 2, 3)     # a vaut maintenant 1, b vaut maintenant 2 and c vaut maintenant 3
 # Sans parenthèses, un tuple est créé par défaut
 d, e, f = 4, 5, 6
-# Voyez maintenant comme il est facile d'inverse 2 valeurs
+# Voyez maintenant comme il est facile d'inverser 2 valeurs
 e, d = d, e     # d is now 5 and e is now 4
 
 
-# Dictionaires
+# Dictionnaires
 empty_dict = {}
 # Un dictionnaire pré-rempli
 filled_dict = {"one": 1, "two": 2, "three": 3}
@@ -208,8 +208,8 @@ filled_dict["one"] #=> 1
 
 # Récupérer toutes les clés sous forme de liste avec "keys()"
 filled_dict.keys() #=> ["three", "two", "one"]
-# Note - l'odre des clés du dictionnaire n'est pas garanti.
-# Vos résultats peuvent différer de ceux ci-dessous.
+# Note - l'ordre des clés du dictionnaire n'est pas garanti.
+# Vos résultats peuvent différer de ceux ci-dessus.
 
 # Récupérer toutes les valeurs sous forme de liste avec "values()"
 filled_dict.values() #=> [3, 2, 1]
@@ -219,7 +219,7 @@ filled_dict.values() #=> [3, 2, 1]
 "one" in filled_dict #=> True
 1 in filled_dict #=> False
 
-# Chercher une clé non existence lève une 'KeyError'
+# Chercher une clé non existante lève une 'KeyError'
 filled_dict["four"] # KeyError
 
 # Utiliser la méthode "get()" pour éviter 'KeyError'
@@ -255,7 +255,7 @@ filled_set | other_set #=> {1, 2, 3, 4, 5, 6}
 # Différence de sets avec -
 {1,2,3,4} - {2,3,5} #=> {1, 4}
 
-# Vérifier l'existene d'une valeur dans un set avec "in"
+# Vérifier l'existence d'une valeur dans un set avec "in"
 2 in filled_set #=> True
 10 in filled_set #=> False
 
@@ -273,12 +273,12 @@ if some_var > 10:
     print "some_var est supérieur à 10."
 elif some_var < 10:    # La clause elif est optionnelle
     print "some_var iinférieur à 10."
-else:           # Optionnel également
+else:           # La clause else également
     print "some_var vaut 10."
 
 
 """
-Les boucles "for" font des itérations sur les listes
+Les boucles "for" permettent d'itérer sur les listes
 Affiche:
     chien : mammifère
     chat : mammifère
@@ -301,7 +301,7 @@ for i in range(4):
     print i
 
 """
-Les boucles "while" boucle jusqu'à ce qu'une condition ne soit plus vraie
+Les boucles "while" boucle jusqu'à ce que leur condition ne soit plus vraie
 Affiche:
     0
     1
@@ -345,7 +345,7 @@ def varargs(*args):
 varargs(1, 2, 3) #=> (1,2,3)
 
 
-# Ont peut également définir une fonction qui prend un nombrenumber of
+# On peut également définir une fonction qui prend un nombre
 # variable d'arguments
 def keyword_args(**kwargs):
     return kwargs
@@ -395,10 +395,10 @@ filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
 ## 5. Classes
 ####################################################
 
-# Une classe hérite d'un objet
+# Une classe est un objet
 class Human(object):
 
-    # L'attribut d'une classe. Il est partagé par toutes les instances de cette classe.
+    # Un attribut de classe. Il est partagé par toutes les instances de cette classe.
     species = "H. sapiens"
 
     # Initialiseur basique
-- 
cgit v1.2.3


From 3cf89d514689ca8610c30171424b2ce1908c0465 Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Sun, 8 Sep 2013 22:05:15 -0700
Subject: Updated new contributions

---
 fr-fr/python-fr.html.markdown | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/python-fr.html.markdown b/fr-fr/python-fr.html.markdown
index 2f10e410..f9b98d41 100644
--- a/fr-fr/python-fr.html.markdown
+++ b/fr-fr/python-fr.html.markdown
@@ -1,14 +1,10 @@
 ---
 langage: python
-
-contributeurs:
+contributors:
     - ["Louie Dinh", "http://ldinh.ca"]
-    
-traducteurs:
+translators:
   - ["Sylvain Zyssman", "https://github.com/sylzys"]
-
-fichier: learnpython.py
-
+filename: learnpython-fr.py
 ---
 
 Python a été créé par Guido Van Rossum au début des années 90. C'est maintenant un des langages de programmation les plus populaires.
-- 
cgit v1.2.3


From b28900b889c27f8500a44d9f9bcad5244f1f79bd Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Sun, 8 Sep 2013 22:52:09 -0700
Subject: Fixed up so it builds

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

(limited to 'fr-fr')

diff --git a/fr-fr/python-fr.html.markdown b/fr-fr/python-fr.html.markdown
index f9b98d41..2bf0afd0 100644
--- a/fr-fr/python-fr.html.markdown
+++ b/fr-fr/python-fr.html.markdown
@@ -1,10 +1,12 @@
 ---
-langage: python
+language: python
+filename: learnpython-fr.py
 contributors:
-    - ["Louie Dinh", "http://ldinh.ca"]
+  - ["Louie Dinh", "http://ldinh.ca"]
 translators:
   - ["Sylvain Zyssman", "https://github.com/sylzys"]
-filename: learnpython-fr.py
+  - ["Nami-Doc", "https://github.com/Nami-Doc"]
+lang: fr-fr
 ---
 
 Python a été créé par Guido Van Rossum au début des années 90. C'est maintenant un des langages de programmation les plus populaires.
-- 
cgit v1.2.3


From 626e963aa9edca53302562c5593a99fd8a002141 Mon Sep 17 00:00:00 2001
From: Bastien Guerry <bzg@altern.org>
Date: Fri, 4 Oct 2013 11:18:47 +0200
Subject: Addfrench translation for the Clojure tutorial

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

(limited to 'fr-fr')

diff --git a/fr-fr/clojure-fr.html.markdown b/fr-fr/clojure-fr.html.markdown
new file mode 100644
index 00000000..d3c5a67b
--- /dev/null
+++ b/fr-fr/clojure-fr.html.markdown
@@ -0,0 +1,398 @@
+---
+language: clojure
+filename: learnclojure-fr.clj
+contributors:
+    - ["Adam Bard", "http://adambard.com/"]
+translators:
+    - ["Bastien Guerry", "https://github.com/bzg"]
+lang: fr-fr
+---
+
+Clojure est un langage de la famille des Lisp développé pour la machine
+virtuelle Java.  Ce langage insiste beaucoup plus sur la [programmation
+fonctionnelle](https://fr.wikipedia.org/wiki/Programmation_fonctionnelle) pure
+que Common Lisp, mais comprend plusieurs outils de gestion de la mémoire
+transactionnelle
+[STM](https://en.wikipedia.org/wiki/Software_transactional_memory) pour gérer
+les changements d'états si besoin.
+
+Cette combinaison permet de gérer le parallélisme très simplement, et
+souvent de façon automatique.
+
+(Vous avez besoin de Clojure 1.2 ou plus récent pour ce tutoriel.)
+
+```clojure
+; Les commentaires commencent avec un point-virgule.
+
+; Clojure est composé de « formes », qui sont simplement des listes
+; d'expressions entre parenthèses, séparées par une ou des espaces.
+;
+; L'interpréteur Clojure suppose que le premier élément est une fonction
+; ou une macro, et que le reste contient des arguments.
+
+; Le premier appel dans un fichier doit être ns, pour définir
+; l'espace de nom
+(ns learnclojure)
+
+; D'autres d'exemples basiques:
+
+; str va créer une chaîne de caractères à partir de tous ses arguments
+(str "Hello" " " "World") ; => "Hello World"
+
+; Les opérations mathématiques sont simples
+(+ 1 1) ; => 2
+(- 2 1) ; => 1
+(* 1 2) ; => 2
+(/ 2 1) ; => 2
+
+; L'égalité est =
+(= 1 1) ; => true
+(= 2 1) ; => false
+
+; Vous avez aussi besoin de not pour la négation logique
+(not true) ; => false
+
+; Les formes imbriquées fonctionnent comme on s'y attend
+(+ 1 (- 3 2)) ; = 1 + (3 - 2) => 2
+
+; Types
+;;;;;;;;;;;;;
+
+; Clojure utilise les types d'objets Java pour les booléens, les chaînes de
+; caractères et les nombres.
+; Utilisez `class` pour inspecter les types.
+(class 1) ; Les nombres entiers littéraux sont java.lang.Long par défaut
+(class 1.); Les flottants littéraux sont java.lang.Double
+(class ""); Les chaînes sont toujours entourées de guillemets doubles, et sont java.lang.String
+(class false) ; Les booléens sont java.lang.Boolean
+(class nil); La valeur "null" est appelée nil
+
+; Si vous voulez créer une liste littérale de données, utilisez ' pour en
+; empêcher son évaluation
+'(+ 1 2) ; => (+ 1 2)
+; (qui est un raccourci pour (quote (+ 1 2)))
+
+; Vous pouvez évaluer une liste "quotée":
+(eval '(+ 1 2)) ; => 3
+
+; Collections & séquences
+;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; Les listes sont des structures de données en listes chaînées, alors que les
+; vecteurs reposent sur des tableaux.
+; Les vecteurs et les listes sont des classes Java aussi !
+(class [1 2 3]); => clojure.lang.PersistentVector
+(class '(1 2 3)); => clojure.lang.PersistentList
+
+; Une liste serait écrite comme (1 2 3), mais nous devons la quoter
+; pour empêcher l'interpréteur de penser que c'est une fonction.
+; Et (list 1 2 3) est la même chose que '(1 2 3)
+
+; Les "Collections" sont juste des groupes de données
+; Les listes et les vecteurs sont tous deux des collections:
+(coll? '(1 2 3)) ; => true
+(coll? [1 2 3]) ; => true
+
+; Les "séquences" (seqs) sont des abstractions à partir de listes de données.
+; Seules les listes sont elles-mêmes des séquences.
+(seq? '(1 2 3)) ; => true
+(seq? [1 2 3]) ; => false
+
+; Une séquence n'a besoin de fournir une entrée que lorsqu'on y accède.
+; Donc, les séquences peuvent être "lazy" -- et définir une série infinie:
+(range 4) ; => (0 1 2 3)
+(range) ; => (0 1 2 3 4 ...) (une série infinie)
+(take 4 (range)) ;  (0 1 2 3)
+
+; Utilisez cons pour ajouter un item au début d'une liste ou d'un vecteur
+(cons 4 [1 2 3]) ; => (4 1 2 3)
+(cons 4 '(1 2 3)) ; => (4 1 2 3)
+
+; Conj ajoutera un item à une collection de la manière la plus efficace
+; Pour les listes, conj ajoute l'item au début; pour les vecteurs, à la fin.
+(conj [1 2 3] 4) ; => [1 2 3 4]
+(conj '(1 2 3) 4) ; => (4 1 2 3)
+
+; Utilisez concat pour ajouter des listes ou vecteurs:
+(concat [1 2] '(3 4)) ; => (1 2 3 4)
+
+; Utilisez filter, map pour interagir avec des collections
+(map inc [1 2 3]) ; => (2 3 4)
+(filter even? [1 2 3]) ; => (2)
+
+; Utilisez reduce pour les réduire
+(reduce + [1 2 3 4])
+; = (+ (+ (+ 1 2) 3) 4)
+; => 10
+
+; Reduce peut aussi prendre un argument pour la valeur initiale
+(reduce conj [] '(3 2 1))
+; = (conj (conj (conj [] 3) 2) 1)
+; => [3 2 1]
+
+; Fonctions
+;;;;;;;;;;;;;;;;;;;;;
+
+; Utilisez fn pour créer de nouvelles fonctions.
+; Une fonction renvoie toujours sa dernière expression.
+(fn [] "Hello World") ; => fn
+
+; (Vous devez ajouter des parenthèses pour l'appeler)
+((fn [] "Hello World")) ; => "Hello World"
+
+; Vous pouvez créer une variable en utilisant def
+(def x 1)
+x ; => 1
+
+; Assignez une fonction à une variable
+(def hello-world (fn [] "Hello World"))
+(hello-world) ; => "Hello World"
+
+; Vous pouvez raccourcir le procédé en utilisant defn
+(defn hello-world [] "Hello World")
+
+; [] contient la liste des arguments de la fonction
+(defn hello [name]
+  (str "Hello " name))
+(hello "Steve") ; => "Hello Steve"
+
+; Vous pouvez aussi utiliser ce raccourci pour créer des fonctions
+(def hello2 #(str "Hello " %1))
+(hello2 "Fanny") ; => "Hello Fanny"
+
+; Vous pouvez avoir des fonctions multi-variadiques
+(defn hello3
+  ([] "Hello World")
+  ([name] (str "Hello " name)))
+(hello3 "Jake") ; => "Hello Jake"
+(hello3) ; => "Hello World"
+
+; Les fonctions peuvent inclure des arguments supplémentaires dans une séquence
+(defn count-args [& args]
+  (str "You passed " (count args) " args: " args))
+(count-args 1 2 3) ; => "Vous avez passé 3 args: (1 2 3)"
+
+; Vous pouvez combiner les arguments normaux et supplémentaires
+(defn hello-count [name & args]
+  (str "Hello " name ", vous avez passé " (count args) " args supplémentaires"))
+(hello-count "Finn" 1 2 3)
+; => "Hello Finn, vous avez passé 3 args supplémentaires"
+
+
+; Maps
+;;;;;;;;;;;;;;;
+
+; Les hashmaps et les arraymaps partagent une interface. Les hashmaps
+; sont interrogés plus rapidement mais ne retiennent pas l'ordre des clefs.
+(class {:a 1 :b 2 :c 3}) ; => clojure.lang.PersistentArrayMap
+(class (hash-map :a 1 :b 2 :c 3)) ; => clojure.lang.PersistentHashMap
+
+; Les array maps deviennent automatiquement des hashmaps pour la
+; plupart des opérations si elles deviennent assez larges, donc vous
+; n'avez pas à vous en faire.
+
+; Tous les types "hashables" sont acceptés comme clefs, mais en
+; général on utilise des mots-clefs ("keywords")
+; Les mots-clefs sont comme les chaînes de caractères mais en plus efficaces
+(class :a) ; => clojure.lang.Keyword
+
+(def stringmap {"a" 1, "b" 2, "c" 3})
+stringmap  ; => {"a" 1, "b" 2, "c" 3}
+
+(def keymap {:a 1, :b 2, :c 3})
+keymap ; => {:a 1, :c 3, :b 2}
+
+; Au passage, les virgules sont toujours traitées comme des espaces et
+; ne font rien.
+
+; Sélectionnez une valeur dans une map en l'appelant comme fonction
+(stringmap "a") ; => 1
+(keymap :a) ; => 1
+
+; Les mots-clefs peuvent aussi être utilisés pour sélectionner leur
+; valeur dans une map !
+(:b keymap) ; => 2
+
+; N'essayez pas ça avec les chaînes de caractères
+;("a" stringmap)
+; => Exception: java.lang.String cannot be cast to clojure.lang.IFn
+
+; Sélectionner une clef absente renvoie nil
+(stringmap "d") ; => nil
+
+; Use assoc to add new keys to hash-maps
+(def newkeymap (assoc keymap :d 4))
+newkeymap ; => {:a 1, :b 2, :c 3, :d 4}
+
+; Mais souvenez-vous, les types en Clojure sont immuables !
+keymap ; => {:a 1, :b 2, :c 3}
+
+; Utilisez dissoc pour retirer des clefs
+(dissoc keymap :a :b) ; => {:c 3}
+
+; Ensembles
+;;;;;;;;;;;;;;;
+
+(class #{1 2 3}) ; => clojure.lang.PersistentHashSet
+(set [1 2 3 1 2 3 3 2 1 3 2 1]) ; => #{1 2 3}
+
+; Ajoutez un élément avec conj
+(conj #{1 2 3} 4) ; => #{1 2 3 4}
+
+; Retirez-en un avec disj
+(disj #{1 2 3} 1) ; => #{2 3}
+
+; Testez la présence en utilisant l'ensemble comme une fonction
+(#{1 2 3} 1) ; => 1
+(#{1 2 3} 4) ; => nil
+
+; Il y a encore d'autres fonctions dans l'espace de nom clojure.sets.
+
+; Formes utiles
+;;;;;;;;;;;;;;;
+
+; Les constructions logiques en Clojure sont juste des macros, et
+ressemblent à toutes les autres formes:
+(if false "a" "b") ; => "b"
+(if false "a") ; => nil
+
+; Utilisez let pour créer des assignations temporaires
+(let [a 1 b 2]
+  (> a b)) ; => false
+
+; Groupez les énoncés ensemble avec do
+(do
+  (print "Hello")
+  "World") ; => "World" (prints "Hello")
+
+; Les fonctions ont un do implicit
+(defn print-and-say-hello [name]
+  (print "Saying hello to " name)
+  (str "Hello " name))
+(print-and-say-hello "Jeff") ;=> "Hello Jeff" (prints "Saying hello to Jeff")
+
+; De même pour let
+(let [name "Urkel"]
+  (print "Saying hello to " name)
+  (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel")
+
+; Modules
+;;;;;;;;;;;;;;;
+
+; Utilisez "use" pour obtenir toutes les fonctions d'un module
+(use 'clojure.set)
+
+; Maintenant nous pouvons utiliser les opération de set
+(intersection #{1 2 3} #{2 3 4}) ; => #{2 3}
+(difference #{1 2 3} #{2 3 4}) ; => #{1}
+
+; Vous pouvez aussi choisir un sous-ensemble de fonctions à importer
+(use '[clojure.set :only [intersection]])
+
+; Utilisez require pour importer un module
+(require 'clojure.string)
+
+; Utilisez / pour appeler les fonctions d'un module
+; Ici, le module est clojure.string et la fonction est blank?
+(clojure.string/blank? "") ; => true
+
+; Vous pouvez associer un nom plus court au module au moment de l'importer
+(require '[clojure.string :as str])
+(str/replace "This is a test." #"[a-o]" str/upper-case) ; => "THIs Is A tEst."
+; (#"" dénote une expression régulière)
+
+; Vous pouvez utiliser require (et use, mais ne le faites pas) en
+; appelant :require depuis un espace de noms.
+; Dans ce cas-là, vous n'avez pas besoin de "quoter" vos modules:
+(ns test
+  (:require
+    [clojure.string :as str]
+    [clojure.set :as set]))
+
+; Java
+;;;;;;;;;;;;;;;;;
+
+; Java a une librairie standard énorme, donc vous voudrez apprendre à
+; vous familiariser avec.
+
+; Utilisez import pour charger un module java
+(import java.util.Date)
+
+; Vous pouvez importer depuis un ns aussi.
+(ns test
+  (:import java.util.Date
+           java.util.Calendar))
+
+; Utilisez les noms de classes avec "." à la fin pour créer une instance
+(Date.) ; <un objet date>
+
+; Utilisez . pour invoquer des méthodes. Ou utilisez le raccourci ".method"
+(. (Date.) getTime) ; <un timestamp>
+(.getTime (Date.)) ; exactement la même chose
+
+; Utilisez / pour appeler des méthodes statiques
+(System/currentTimeMillis) ; <un timestamp> (system est toujours présent)
+
+; Utilisez doto to rendre plus tolérable l'interaction avec des
+; classes (mutables)
+(import java.util.Calendar)
+(doto (Calendar/getInstance)
+  (.set 2000 1 1 0 0 0)
+  .getTime) ; => Une classe Date. définie comme 2000-01-01 00:00:00
+
+; STM
+;;;;;;;;;;;;;;;;;
+
+; La mémoire logiciel transactionnelle ("Software Transactional Memory") 
+; est le mécanisme que Clojure utilise pour gérer les états persistents.
+; Il y a plusieurs formes en Clojure qui utilisent cela.
+
+; L'atome est la plus simple. Passez-lui une valeur initiale
+(def my-atom (atom {}))
+
+; Mettez à jour un atome avec swap!.
+; swap! prend une fonction en argument et l'appelle avec la valeur
+; actuelle de l'atome comme premier argument, et les autres arguments
+; comme second argument.
+(swap! my-atom assoc :a 1) ; Définit my-atom comme le résultat de (assoc {} :a 1)
+(swap! my-atom assoc :b 2) ; Définit my-atom comme le résultat de (assoc {:a 1} :b 2)
+
+; Use '@' to dereference the atom and get the value 
+my-atom  ;=> Atom<#...> (Renvoie l'objet Atom)
+@my-atom ; => {:a 1 :b 2}
+
+; Voici un simple compteur utilisant un atome
+(def counter (atom 0))
+(defn inc-counter []
+  (swap! counter inc))
+
+(inc-counter)
+(inc-counter)
+(inc-counter)
+(inc-counter)
+(inc-counter)
+
+@counter ; => 5
+
+; Les autres formes STM sont les refs et les agents.
+; Refs: http://clojure.org/refs
+; Agents: http://clojure.org/agents
+```
+
+### Lectures complémentaires
+
+C'est loin d'être exhaustif, mais assez pour vous permettre de continuer.
+
+Clojure.org propose de nombreux articles:
+[http://clojure.org/](http://clojure.org/)
+
+Clojuredocs.org a de la documentation avec des exemples pour la
+plupart des fonctions principales :
+[http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core)
+
+4Clojure est une super manière d'augmenter vos compétences en Clojure et
+en programmation fonctionnelle :
+[http://www.4clojure.com/](http://www.4clojure.com/)
+
+Clojure-doc.org a pas mal d'article pour débuter :
+[http://clojure-doc.org/](http://clojure-doc.org/)
-- 
cgit v1.2.3


From f400089013d99030e520c20735198273aed17b8e Mon Sep 17 00:00:00 2001
From: David Baumgartner <_davidbaumgartner@bluewin.ch>
Date: Sun, 6 Oct 2013 21:44:48 +0200
Subject: Adding french translation of Haskell

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

(limited to 'fr-fr')

diff --git a/fr-fr/haskell.html.markdown b/fr-fr/haskell.html.markdown
new file mode 100644
index 00000000..16c40554
--- /dev/null
+++ b/fr-fr/haskell.html.markdown
@@ -0,0 +1,428 @@
+---
+language: haskell
+contributors:
+    - ["Adit Bhargava", "http://adit.io"]
+    - ["David Baumgartner", "http://davidbaumgartner.ch"]
+---
+
+Haskell a été conçu pour être un langage fonctionnel pur et maniable. Il est connu pour ses monades et son système de types, mais je continue d'y revenir pour son élégance. Pour moi, Haskell fait de la programmation une joie.
+
+```haskell
+-- Un commentaire en une ligne commence avec deux tirets.
+{- Un commentaire sur plusieurs lignes peut être contenu dans
+un bloc de cette façon.
+-}
+
+----------------------------------------------------
+-- 1. Types de données primitifs et opérateurs
+----------------------------------------------------
+
+-- Vous avez les nombres
+3 -- 3
+
+-- Les maths sont telles que vous vous y attendez
+1 + 1 -- 2
+8 - 1 -- 7
+10 * 2 -- 20
+35 / 5 -- 7.0
+
+-- La division n'est pas entière par défaut
+35 / 4 -- 8.75
+
+-- division entière
+35 `div` 4 -- 8
+
+-- Les booléens sont primitifs
+True
+False
+
+-- Opérations avec les booléens
+not True -- False
+not False -- True
+1 == 1 -- True
+1 /= 1 -- False
+1 < 10 -- True
+
+-- Dans les exemples plus hauts, `not`est une fonction qui prend une valeur
+-- Haskell n'a pas besoin de parenthèses pour appeler une fonction... tous
+-- les arguments sont juste listés après la fonction. Le schéma général est
+-- donc:
+-- func arg1 arg2 arg3...
+-- Voyez la section sur les fonctions pour savoir comment écrire les vôtres.
+
+-- Caractères et chaînes de caractère
+"Ceci est une chaîne de caractère."
+'a' -- caractère
+'Vous pouvez utiliser des apostrophes pour les chaînes de caractère.' -- erreur !
+
+-- Les chaînes peuvent être concaténées
+"Hello " ++ "world!" -- "Hello world!"
+
+-- Une chaîne de caractère est *réellement* une liste
+"Ceci est une chaîne." !! 0 -- 'C'
+
+
+----------------------------------------------------
+-- Lists and Tuples
+----------------------------------------------------
+
+-- Chaque élément d'une liste doit avoir le même type
+-- les deux lignes suivantes sont semblables
+[1, 2, 3, 4, 5]
+[1..5]
+
+-- Il y a aussi des listes infinies en Haskell!
+[1..] -- une liste de tous les nombres naturels
+
+-- Les listes infinies fonctionnent parce que Haskell a « l'évaluation 
+-- paresseuse ». Ça veut dire que Haskell n'évalue que ce qui a besoin
+-- de l'être. Vous pouvez donc vous demander le 1000e élément de votre liste:
+
+[1..] !! 999 -- 1000
+
+-- Et là, Haskell a évalué les éléments 1 à 1000 de la liste... mais le reste
+-- de cette liste "infinie" n'existe pas encore! En fait, Haskell ne va jamais 
+-- le faire à moins qu'il en ait besoin.
+
+-- Adjoindre deux listes 
+[1..5] ++ [6..10]
+
+-- ajouter au début de la liste
+0:[1..5] -- [0, 1, 2, 3, 4, 5]
+
+-- l'indice d'une liste
+[0..] !! 5 -- 5
+
+-- d'autres opérations sur les listes
+head [1..5] -- 1
+tail [1..5] -- [2, 3, 4, 5]
+init [1..5] -- [1, 2, 3, 4]
+last [1..5] -- 5
+
+--liste en compréhension
+[x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10]
+
+--avec un conditionnel
+[x*2 | x <- [1..5], x*2 > 4] -- [6, 8, 10]
+
+-- Chaque élément d'un tuple peut être d'un type différent, mais une
+-- tuple a une longueur fixée.
+-- Un tuple:
+("haskell", 1)
+
+-- accéder aux éléments d'un tuple
+fst ("haskell", 1) -- "haskell"
+snd ("haskell", 1) -- 1
+
+----------------------------------------------------
+-- 3. Functions
+----------------------------------------------------
+-- Une simple fonction qui prend deux paramètres
+add a b = a + b
+
+-- Notez que si vous utilisez ghci (l'interpréteur Haskell)
+-- vous devrez utiliser `let`. Par exemple:
+-- let add a b = a + b
+
+-- Utiliser une fonction
+add 1 2 -- 3
+
+-- Vous pouvez également mettre le nom de la fonction entre les
+-- deux arguments avec des accents graves:
+1 `add` 2 -- 3
+
+-- Vous pouvez également définir des fonctions qui n'ont pas de
+-- lettres! Ça vous laisse créer vos propres opérateurs! Voilà 
+-- un opérateur qui fait une division entière:
+(//) a b = a `div` b
+35 // 4 -- 8
+
+-- Gardes: une façon pour créer des bifurcations de fonction
+fib x
+  | x < 2 = x
+  | otherwise = fib (x - 1) + fib (x - 2)
+
+-- Le filtrage par motif est similaire. Là on a donné trois 
+-- définitions différents de `fib`. Haskell appellera automatiquement
+-- la première fonction qui correspondra au motif de la valeur.
+fib 1 = 1
+fib 2 = 2
+fib x = fib (x - 1) + fib (x - 2)
+
+-- Filtrage par motif sur un tuple.
+foo (x, y) = (x + 1, y + 2)
+
+-- Filtrage par motif sur des listes. Ici, `x` est le premier
+-- élément de la liste, et `xs` le reste. On peut écrire notre
+-- propre fonction `map`:
+myMap func [] = []
+myMap func (x:xs) = func x:(myMap func xs)
+
+-- Les fonctions anonymes sont créées avec des barres obliques 
+-- inverses, suivies de tous les arguments.
+myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7]
+
+-- Une utilisation de fold (appelée `inject` dans quelques autres
+-- langages) avec comme paramètre une fonction anonyme.
+-- `foldl1` veut dire fold left -- soit littéralement pli gauche. --
+-- et utilise la première valeur de la liste comme accumulateur.
+foldl1 (\acc x -> acc + x) [1..5] -- 15
+
+----------------------------------------------------
+-- 4. Plus de fonctions
+----------------------------------------------------
+
+-- curryfaction: si vous n'appliquez pas tous les arguments à une
+-- fonction, elle devient « curryfiée ». Ça veut dire qu'elle retourne
+-- une fonction qui prend le reste des arguments.
+
+add a b = a + b
+foo = add 10 -- foo est une fonction qui prend un nombre et y ajoute 10
+foo 5 -- 15
+
+-- Une autre façon de l'écrire
+foo = (+10)
+foo 5 -- 15
+
+-- Composition de fonctions
+-- la fonction (.) enchaîne deux fonctions.
+-- Par exemple, on a foo qui est une fonction qui prend une valeur, y ajoute
+-- 10 et multiplie ce résultat par 5, et ensuite retourne la valeur finale.
+foo = (*5) . (+10)
+
+-- (5 + 10) * 5 = 75
+foo 5 -- 75
+
+-- fixation de priorité
+-- Haskell a une autre fonction appelée `$`. Elle peut changer la priorité
+-- de façon à ce que tout ce qu'il y a à sa gauche est calculé d'abord
+-- et ensuite appliqué à tout ce qu'il y a à droite. Vous pouvez utiliser
+-- `.` et `$` pour vous débarrasser de beaucoup de parenthèses:
+
+-- avant
+(even (fib 7)) -- False
+
+-- ensuite
+even . fib $ 7 -- False
+
+----------------------------------------------------
+-- 5. Signature de type
+----------------------------------------------------
+
+-- Haskell a un système de types très strict, et tout a un type.
+
+-- Quelques types simples:
+5 :: Integer
+"hello" :: String
+True :: Bool
+
+-- Les fonctions ont des types également.
+-- `not` prend un booléen et retourne un booléen.
+-- not :: Bool -> Bool
+
+-- Voilà une fonction qui prend deux paramètres.
+-- add :: Integer -> Integer -> Integer
+
+-- Quand vous définissez une valeur, une bonne pratique est d'écrire 
+-- son type explicitement
+double :: Integer -> Integer
+double x = x * 2
+
+----------------------------------------------------
+-- 6. Flux de contrôle et structures conditionnelles
+----------------------------------------------------
+
+-- structure conditionnelle if
+haskell = if 1 == 1 then "awesome" else "awful" -- haskell = "awesome"
+
+-- les structures if peuvent être écrites sur plusieurs lignes
+haskell = if 1 == 1
+            then "awesome"
+            else "awful"
+
+-- les structures case: Voilà comment vous pouvez analyser les arguments de 
+-- ligne de commande
+case args of
+  "help" -> printHelp
+  "start" -> startProgram
+  _ -> putStrLn "bad args"
+
+
+-- Haskell n'a pas de boucles parce qu'il utilise la récursion.
+-- `map` applique une fonction sur chaque élément d'une liste
+
+map (*2) [1..5] -- [2, 4, 6, 8, 10]
+
+-- vous pouvez créer une fonction `for` en utilisant `map`
+for array func = map func array
+
+-- et l'utiliser
+for [0..5] $ \i -> show i
+
+-- nous aurions pu l'écrire également ainsi
+for [0..5] show
+
+-- vous pouvez utiliser foldl et foldr pour 
+-- réduire une liste
+-- foldl <fonction> <valeur initiale> <liste>
+foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43
+
+-- C'est donc la même chose que 
+(2 * (2 * (2 * 4 + 1) + 2) + 3)
+
+-- foldl évalue de gauche à droite, foldr
+-- de droite à gauche
+foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16
+
+-- Et c'est équivalent à
+(2 * 3 + (2 * 2 + (2 * 1 + 4)))
+
+----------------------------------------------------
+-- 7. Types de données
+----------------------------------------------------
+
+-- Vous pouvez écrire vos propres types de données en Haskell
+
+data Couleur = Rouge | Bleu | Vert
+
+-- Et maintenant l'utiliser dans une fonction
+
+
+say :: Couleur -> String
+say Rouge = "Vous êtes Rouge!"
+say Bleu = "Vous êtes Bleu!"
+say Vert =  "Vous êtes Vert!"
+
+-- Vos types peuvent également avoir des paramètres
+
+data Maybe a = Nothing | Just a
+
+-- Tous les exemples ci-dessous sont issus du type Maybe
+Just "hello"    -- of type `Maybe String`
+Just 1          -- of type `Maybe Int`
+Nothing         -- of type `Maybe a` for any `a`
+
+----------------------------------------------------
+-- 8. Haskell IO
+----------------------------------------------------
+
+-- Tandis que l'IO ne peut pas être totalement expliqué pleinement
+-- sans que les monades ne le soient, il n'est pas difficile
+-- d'expliquer suffisamment pour commencer.
+
+-- Quand un programme en Haskell est exécuté, la fonction `main`
+-- est appelée. Il doit retourner une valeur de type `IO ()`.
+-- Par exemple:
+
+main :: IO ()
+main = putStrLn $ "Bonjour, le ciel! " ++ (say Blue) 
+-- putStrLn a comme type String -> IO ()
+
+-- Il est plus facile de faire IO si vous pouvez faire
+-- votre programme en fonction String à String. La fonction
+--    interact :: (String -> String) -> IO ()
+-- prend un texte, applique une fonction et affiche le résultat.
+
+countLines :: String -> String
+countLines = show . length . lines
+
+main' = interact countLines
+
+-- Vous pouvez considérer qu'une valeur de type `IO ()` représente
+-- une séquence d'actions que l'ordinateur exécute, un peu comme 
+-- dans un langage impératif. On peut utiliser la structure `do` 
+-- pour enchaîner des actions. Par exemple:
+
+sayHello :: IO ()
+sayHello = do 
+   putStrLn "Quel est ton nom ?"
+   name <- getLine -- prend une ligne et assigne sa valeur à `name`
+   putStrLn $ "Salut, " ++ name
+   
+-- Exercice: écrire votre propre version d'`interact` qui ne fait 
+--           que de lire une ligne d'entrée.
+   
+-- Le code de `sayHello` ne sera jamais exécuté, cependant. La seule
+-- action qui sera exécutée est la valeur de `main`.
+-- Pour lancer `sayHello`, commentez l'ancienne définition de `main`
+-- et remplacez-le par:
+--   main = sayHello
+
+-- Essaions de mieux comprendre comment la fonction `getLine` que 
+-- nous venons d'utiliser. Son type est:
+--    getLine :: IO String
+-- vous pouvez considérer le type `IO a` comme un programme que
+-- le programme va générer comme une valeur de type `a` quand
+-- il sera exécuté. On peut l'enregistrer et la réutiliser en
+-- utilisant `<-`. On peut aussi faire nos propres actions
+-- de type `IO String`:
+
+action :: IO String
+action = do
+   putStrLn "C'est une ligne. Heu"
+   input1 <- getLine 
+   input2 <- getLine
+   -- Le type de la structure `do` est celui de sa dernière ligne.
+   -- `return` n'est pas un mot clef, mais simplement une fonction.
+   return (input1 ++ "\n" ++ input2) -- return :: String -> IO String
+
+-- On peut maintenant l'utiliser comme on a utilisé `getLine`
+-- tout à l'heure
+
+main'' = do
+    putStrLn "Je vais afficher deux lignes!"
+    result <- action 
+    putStrLn result
+    putStrLn "C'était tout!"
+
+-- Le type `IO` est un exemple de « monade ». La façon dont Haskell une monade
+-- pour faire de l'IO lui permet d'être purement fonctionnel. N'importe quelle
+-- fonction qui interagit avec le « monde extérieur » (c'est à dire fait de l'IO)
+-- devient marqué comme `IO` dans la signature de son type. Ça nous montre
+-- quelles fonctions sont « pures » (n'interagissent pas avec le monde extérieur
+-- ou ne changent pas d'état) et quelles fonctions ne le sont pas.
+
+-- C'est une fonctionnalité très puissante, car il est facile d'exécuter 
+-- des fonctions pures simultanément, donc, la concurrence en Haskell
+-- est très facile.
+
+
+----------------------------------------------------
+-- 9. Le REPL de Haskell
+----------------------------------------------------
+
+-- Lancer le REPL en tapant `ghci`.
+-- Vous pouvez maintenant taper de code Haskell.
+-- Toutes les nouvelles valeurs peuvent être crées 
+-- avec `let`:
+
+let foo = 5
+
+-- Vous pouvez voir le type de n'importe quelle valeur avec `:t`:
+
+>:t foo
+foo :: Integer
+
+-- Vous pouvez également des actions de type `IO ()`
+
+> sayHello
+Quel est ton nom ?
+Ami!
+Salut, Ami!
+
+```
+
+Et Haskell ne se limite pas à ça, on trouve encore par exemple les classes de types et les monades. Il y a beaucoup de raisons qui font que coder en Haskell est si *fun*. Je vous laisse avec un dernier exemple: une implémentation de quicksort:
+
+```haskell
+qsort [] = []
+qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater
+    where lesser  = filter (< p) xs
+          greater = filter (>= p) xs
+```
+
+Haskell facile à installer. Téléchargez-le [ici](http://www.haskell.org/platform/).
+
+Vous pouvez trouver une approche beaucoup plus douce avec les excellents
+[Learn you a Haskell](http://lyah.haskell.fr/) ou
+[Real World Haskell (en)](http://book.realworldhaskell.org/).
-- 
cgit v1.2.3


From fea0557241dd7d6c270ec05ba89d3c898676ac3e Mon Sep 17 00:00:00 2001
From: David Baumgartner <_davidbaumgartner@bluewin.ch>
Date: Sun, 6 Oct 2013 22:25:47 +0200
Subject: Revert "Adding french translation of Haskell"

This reverts commit f400089013d99030e520c20735198273aed17b8e.
---
 fr-fr/haskell.html.markdown | 428 --------------------------------------------
 1 file changed, 428 deletions(-)
 delete mode 100644 fr-fr/haskell.html.markdown

(limited to 'fr-fr')

diff --git a/fr-fr/haskell.html.markdown b/fr-fr/haskell.html.markdown
deleted file mode 100644
index 16c40554..00000000
--- a/fr-fr/haskell.html.markdown
+++ /dev/null
@@ -1,428 +0,0 @@
----
-language: haskell
-contributors:
-    - ["Adit Bhargava", "http://adit.io"]
-    - ["David Baumgartner", "http://davidbaumgartner.ch"]
----
-
-Haskell a été conçu pour être un langage fonctionnel pur et maniable. Il est connu pour ses monades et son système de types, mais je continue d'y revenir pour son élégance. Pour moi, Haskell fait de la programmation une joie.
-
-```haskell
--- Un commentaire en une ligne commence avec deux tirets.
-{- Un commentaire sur plusieurs lignes peut être contenu dans
-un bloc de cette façon.
--}
-
-----------------------------------------------------
--- 1. Types de données primitifs et opérateurs
-----------------------------------------------------
-
--- Vous avez les nombres
-3 -- 3
-
--- Les maths sont telles que vous vous y attendez
-1 + 1 -- 2
-8 - 1 -- 7
-10 * 2 -- 20
-35 / 5 -- 7.0
-
--- La division n'est pas entière par défaut
-35 / 4 -- 8.75
-
--- division entière
-35 `div` 4 -- 8
-
--- Les booléens sont primitifs
-True
-False
-
--- Opérations avec les booléens
-not True -- False
-not False -- True
-1 == 1 -- True
-1 /= 1 -- False
-1 < 10 -- True
-
--- Dans les exemples plus hauts, `not`est une fonction qui prend une valeur
--- Haskell n'a pas besoin de parenthèses pour appeler une fonction... tous
--- les arguments sont juste listés après la fonction. Le schéma général est
--- donc:
--- func arg1 arg2 arg3...
--- Voyez la section sur les fonctions pour savoir comment écrire les vôtres.
-
--- Caractères et chaînes de caractère
-"Ceci est une chaîne de caractère."
-'a' -- caractère
-'Vous pouvez utiliser des apostrophes pour les chaînes de caractère.' -- erreur !
-
--- Les chaînes peuvent être concaténées
-"Hello " ++ "world!" -- "Hello world!"
-
--- Une chaîne de caractère est *réellement* une liste
-"Ceci est une chaîne." !! 0 -- 'C'
-
-
-----------------------------------------------------
--- Lists and Tuples
-----------------------------------------------------
-
--- Chaque élément d'une liste doit avoir le même type
--- les deux lignes suivantes sont semblables
-[1, 2, 3, 4, 5]
-[1..5]
-
--- Il y a aussi des listes infinies en Haskell!
-[1..] -- une liste de tous les nombres naturels
-
--- Les listes infinies fonctionnent parce que Haskell a « l'évaluation 
--- paresseuse ». Ça veut dire que Haskell n'évalue que ce qui a besoin
--- de l'être. Vous pouvez donc vous demander le 1000e élément de votre liste:
-
-[1..] !! 999 -- 1000
-
--- Et là, Haskell a évalué les éléments 1 à 1000 de la liste... mais le reste
--- de cette liste "infinie" n'existe pas encore! En fait, Haskell ne va jamais 
--- le faire à moins qu'il en ait besoin.
-
--- Adjoindre deux listes 
-[1..5] ++ [6..10]
-
--- ajouter au début de la liste
-0:[1..5] -- [0, 1, 2, 3, 4, 5]
-
--- l'indice d'une liste
-[0..] !! 5 -- 5
-
--- d'autres opérations sur les listes
-head [1..5] -- 1
-tail [1..5] -- [2, 3, 4, 5]
-init [1..5] -- [1, 2, 3, 4]
-last [1..5] -- 5
-
---liste en compréhension
-[x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10]
-
---avec un conditionnel
-[x*2 | x <- [1..5], x*2 > 4] -- [6, 8, 10]
-
--- Chaque élément d'un tuple peut être d'un type différent, mais une
--- tuple a une longueur fixée.
--- Un tuple:
-("haskell", 1)
-
--- accéder aux éléments d'un tuple
-fst ("haskell", 1) -- "haskell"
-snd ("haskell", 1) -- 1
-
-----------------------------------------------------
--- 3. Functions
-----------------------------------------------------
--- Une simple fonction qui prend deux paramètres
-add a b = a + b
-
--- Notez que si vous utilisez ghci (l'interpréteur Haskell)
--- vous devrez utiliser `let`. Par exemple:
--- let add a b = a + b
-
--- Utiliser une fonction
-add 1 2 -- 3
-
--- Vous pouvez également mettre le nom de la fonction entre les
--- deux arguments avec des accents graves:
-1 `add` 2 -- 3
-
--- Vous pouvez également définir des fonctions qui n'ont pas de
--- lettres! Ça vous laisse créer vos propres opérateurs! Voilà 
--- un opérateur qui fait une division entière:
-(//) a b = a `div` b
-35 // 4 -- 8
-
--- Gardes: une façon pour créer des bifurcations de fonction
-fib x
-  | x < 2 = x
-  | otherwise = fib (x - 1) + fib (x - 2)
-
--- Le filtrage par motif est similaire. Là on a donné trois 
--- définitions différents de `fib`. Haskell appellera automatiquement
--- la première fonction qui correspondra au motif de la valeur.
-fib 1 = 1
-fib 2 = 2
-fib x = fib (x - 1) + fib (x - 2)
-
--- Filtrage par motif sur un tuple.
-foo (x, y) = (x + 1, y + 2)
-
--- Filtrage par motif sur des listes. Ici, `x` est le premier
--- élément de la liste, et `xs` le reste. On peut écrire notre
--- propre fonction `map`:
-myMap func [] = []
-myMap func (x:xs) = func x:(myMap func xs)
-
--- Les fonctions anonymes sont créées avec des barres obliques 
--- inverses, suivies de tous les arguments.
-myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7]
-
--- Une utilisation de fold (appelée `inject` dans quelques autres
--- langages) avec comme paramètre une fonction anonyme.
--- `foldl1` veut dire fold left -- soit littéralement pli gauche. --
--- et utilise la première valeur de la liste comme accumulateur.
-foldl1 (\acc x -> acc + x) [1..5] -- 15
-
-----------------------------------------------------
--- 4. Plus de fonctions
-----------------------------------------------------
-
--- curryfaction: si vous n'appliquez pas tous les arguments à une
--- fonction, elle devient « curryfiée ». Ça veut dire qu'elle retourne
--- une fonction qui prend le reste des arguments.
-
-add a b = a + b
-foo = add 10 -- foo est une fonction qui prend un nombre et y ajoute 10
-foo 5 -- 15
-
--- Une autre façon de l'écrire
-foo = (+10)
-foo 5 -- 15
-
--- Composition de fonctions
--- la fonction (.) enchaîne deux fonctions.
--- Par exemple, on a foo qui est une fonction qui prend une valeur, y ajoute
--- 10 et multiplie ce résultat par 5, et ensuite retourne la valeur finale.
-foo = (*5) . (+10)
-
--- (5 + 10) * 5 = 75
-foo 5 -- 75
-
--- fixation de priorité
--- Haskell a une autre fonction appelée `$`. Elle peut changer la priorité
--- de façon à ce que tout ce qu'il y a à sa gauche est calculé d'abord
--- et ensuite appliqué à tout ce qu'il y a à droite. Vous pouvez utiliser
--- `.` et `$` pour vous débarrasser de beaucoup de parenthèses:
-
--- avant
-(even (fib 7)) -- False
-
--- ensuite
-even . fib $ 7 -- False
-
-----------------------------------------------------
--- 5. Signature de type
-----------------------------------------------------
-
--- Haskell a un système de types très strict, et tout a un type.
-
--- Quelques types simples:
-5 :: Integer
-"hello" :: String
-True :: Bool
-
--- Les fonctions ont des types également.
--- `not` prend un booléen et retourne un booléen.
--- not :: Bool -> Bool
-
--- Voilà une fonction qui prend deux paramètres.
--- add :: Integer -> Integer -> Integer
-
--- Quand vous définissez une valeur, une bonne pratique est d'écrire 
--- son type explicitement
-double :: Integer -> Integer
-double x = x * 2
-
-----------------------------------------------------
--- 6. Flux de contrôle et structures conditionnelles
-----------------------------------------------------
-
--- structure conditionnelle if
-haskell = if 1 == 1 then "awesome" else "awful" -- haskell = "awesome"
-
--- les structures if peuvent être écrites sur plusieurs lignes
-haskell = if 1 == 1
-            then "awesome"
-            else "awful"
-
--- les structures case: Voilà comment vous pouvez analyser les arguments de 
--- ligne de commande
-case args of
-  "help" -> printHelp
-  "start" -> startProgram
-  _ -> putStrLn "bad args"
-
-
--- Haskell n'a pas de boucles parce qu'il utilise la récursion.
--- `map` applique une fonction sur chaque élément d'une liste
-
-map (*2) [1..5] -- [2, 4, 6, 8, 10]
-
--- vous pouvez créer une fonction `for` en utilisant `map`
-for array func = map func array
-
--- et l'utiliser
-for [0..5] $ \i -> show i
-
--- nous aurions pu l'écrire également ainsi
-for [0..5] show
-
--- vous pouvez utiliser foldl et foldr pour 
--- réduire une liste
--- foldl <fonction> <valeur initiale> <liste>
-foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43
-
--- C'est donc la même chose que 
-(2 * (2 * (2 * 4 + 1) + 2) + 3)
-
--- foldl évalue de gauche à droite, foldr
--- de droite à gauche
-foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16
-
--- Et c'est équivalent à
-(2 * 3 + (2 * 2 + (2 * 1 + 4)))
-
-----------------------------------------------------
--- 7. Types de données
-----------------------------------------------------
-
--- Vous pouvez écrire vos propres types de données en Haskell
-
-data Couleur = Rouge | Bleu | Vert
-
--- Et maintenant l'utiliser dans une fonction
-
-
-say :: Couleur -> String
-say Rouge = "Vous êtes Rouge!"
-say Bleu = "Vous êtes Bleu!"
-say Vert =  "Vous êtes Vert!"
-
--- Vos types peuvent également avoir des paramètres
-
-data Maybe a = Nothing | Just a
-
--- Tous les exemples ci-dessous sont issus du type Maybe
-Just "hello"    -- of type `Maybe String`
-Just 1          -- of type `Maybe Int`
-Nothing         -- of type `Maybe a` for any `a`
-
-----------------------------------------------------
--- 8. Haskell IO
-----------------------------------------------------
-
--- Tandis que l'IO ne peut pas être totalement expliqué pleinement
--- sans que les monades ne le soient, il n'est pas difficile
--- d'expliquer suffisamment pour commencer.
-
--- Quand un programme en Haskell est exécuté, la fonction `main`
--- est appelée. Il doit retourner une valeur de type `IO ()`.
--- Par exemple:
-
-main :: IO ()
-main = putStrLn $ "Bonjour, le ciel! " ++ (say Blue) 
--- putStrLn a comme type String -> IO ()
-
--- Il est plus facile de faire IO si vous pouvez faire
--- votre programme en fonction String à String. La fonction
---    interact :: (String -> String) -> IO ()
--- prend un texte, applique une fonction et affiche le résultat.
-
-countLines :: String -> String
-countLines = show . length . lines
-
-main' = interact countLines
-
--- Vous pouvez considérer qu'une valeur de type `IO ()` représente
--- une séquence d'actions que l'ordinateur exécute, un peu comme 
--- dans un langage impératif. On peut utiliser la structure `do` 
--- pour enchaîner des actions. Par exemple:
-
-sayHello :: IO ()
-sayHello = do 
-   putStrLn "Quel est ton nom ?"
-   name <- getLine -- prend une ligne et assigne sa valeur à `name`
-   putStrLn $ "Salut, " ++ name
-   
--- Exercice: écrire votre propre version d'`interact` qui ne fait 
---           que de lire une ligne d'entrée.
-   
--- Le code de `sayHello` ne sera jamais exécuté, cependant. La seule
--- action qui sera exécutée est la valeur de `main`.
--- Pour lancer `sayHello`, commentez l'ancienne définition de `main`
--- et remplacez-le par:
---   main = sayHello
-
--- Essaions de mieux comprendre comment la fonction `getLine` que 
--- nous venons d'utiliser. Son type est:
---    getLine :: IO String
--- vous pouvez considérer le type `IO a` comme un programme que
--- le programme va générer comme une valeur de type `a` quand
--- il sera exécuté. On peut l'enregistrer et la réutiliser en
--- utilisant `<-`. On peut aussi faire nos propres actions
--- de type `IO String`:
-
-action :: IO String
-action = do
-   putStrLn "C'est une ligne. Heu"
-   input1 <- getLine 
-   input2 <- getLine
-   -- Le type de la structure `do` est celui de sa dernière ligne.
-   -- `return` n'est pas un mot clef, mais simplement une fonction.
-   return (input1 ++ "\n" ++ input2) -- return :: String -> IO String
-
--- On peut maintenant l'utiliser comme on a utilisé `getLine`
--- tout à l'heure
-
-main'' = do
-    putStrLn "Je vais afficher deux lignes!"
-    result <- action 
-    putStrLn result
-    putStrLn "C'était tout!"
-
--- Le type `IO` est un exemple de « monade ». La façon dont Haskell une monade
--- pour faire de l'IO lui permet d'être purement fonctionnel. N'importe quelle
--- fonction qui interagit avec le « monde extérieur » (c'est à dire fait de l'IO)
--- devient marqué comme `IO` dans la signature de son type. Ça nous montre
--- quelles fonctions sont « pures » (n'interagissent pas avec le monde extérieur
--- ou ne changent pas d'état) et quelles fonctions ne le sont pas.
-
--- C'est une fonctionnalité très puissante, car il est facile d'exécuter 
--- des fonctions pures simultanément, donc, la concurrence en Haskell
--- est très facile.
-
-
-----------------------------------------------------
--- 9. Le REPL de Haskell
-----------------------------------------------------
-
--- Lancer le REPL en tapant `ghci`.
--- Vous pouvez maintenant taper de code Haskell.
--- Toutes les nouvelles valeurs peuvent être crées 
--- avec `let`:
-
-let foo = 5
-
--- Vous pouvez voir le type de n'importe quelle valeur avec `:t`:
-
->:t foo
-foo :: Integer
-
--- Vous pouvez également des actions de type `IO ()`
-
-> sayHello
-Quel est ton nom ?
-Ami!
-Salut, Ami!
-
-```
-
-Et Haskell ne se limite pas à ça, on trouve encore par exemple les classes de types et les monades. Il y a beaucoup de raisons qui font que coder en Haskell est si *fun*. Je vous laisse avec un dernier exemple: une implémentation de quicksort:
-
-```haskell
-qsort [] = []
-qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater
-    where lesser  = filter (< p) xs
-          greater = filter (>= p) xs
-```
-
-Haskell facile à installer. Téléchargez-le [ici](http://www.haskell.org/platform/).
-
-Vous pouvez trouver une approche beaucoup plus douce avec les excellents
-[Learn you a Haskell](http://lyah.haskell.fr/) ou
-[Real World Haskell (en)](http://book.realworldhaskell.org/).
-- 
cgit v1.2.3


From cc1c704b8aea62e50c596e54a88357820b1110c2 Mon Sep 17 00:00:00 2001
From: David Baumgartner <_davidbaumgartner@bluewin.ch>
Date: Sun, 6 Oct 2013 22:28:53 +0200
Subject: Adding french translation of Haskell

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

(limited to 'fr-fr')

diff --git a/fr-fr/haskell.html.markdown b/fr-fr/haskell.html.markdown
new file mode 100644
index 00000000..519bffd6
--- /dev/null
+++ b/fr-fr/haskell.html.markdown
@@ -0,0 +1,429 @@
+---
+language: haskell
+contributors:
+    - ["Adit Bhargava", "http://adit.io"]
+    - ["David Baumgartner", "http://davidbaumgartner.ch"]
+---
+
+Haskell a été conçu pour être un langage fonctionnel pur et maniable. Il est connu pour ses monades et son système de types, mais je n'ai cesse d'y revenir pour son élégance. Pour moi, Haskell fait de la programmation une joie.
+
+```haskell
+-- Un commentaire en une ligne commence avec deux tirets.
+{- Un commentaire sur plusieurs lignes peut être contenu dans
+un bloc de cette façon.
+-}
+
+----------------------------------------------------
+-- 1. Types de données primitifs et opérateurs
+----------------------------------------------------
+
+-- Vous avez les nombres
+3 -- 3
+
+-- Les maths sont telles que vous vous y attendez
+1 + 1 -- 2
+8 - 1 -- 7
+10 * 2 -- 20
+35 / 5 -- 7.0
+
+-- La division n'est pas entière par défaut
+35 / 4 -- 8.75
+
+-- division entière
+35 `div` 4 -- 8
+
+-- Les booléens sont primitifs
+True
+False
+
+-- Opérations avec les booléens
+not True -- False
+not False -- True
+1 == 1 -- True
+1 /= 1 -- False
+1 < 10 -- True
+
+-- Dans les exemples plus hauts, `not` est une fonction qui prend une valeur.
+-- Haskell n'a pas besoin de parenthèses pour appeler une fonction... tous
+-- les arguments sont juste listés après la fonction. Le schéma général est
+-- donc:
+-- func arg1 arg2 arg3...
+-- Voyez la section sur les fonctions pour savoir comment écrire les vôtres.
+
+-- Caractères et chaînes de caractère
+"Ceci est une chaîne de caractère."
+'a' -- caractère
+'Vous pouvez utiliser des apostrophes pour les chaînes de caractère.' -- erreur !
+
+-- Les chaînes peuvent être concaténées
+"Hello " ++ "world!" -- "Hello world!"
+
+-- Une chaîne de caractère est *réellement* une liste
+"Ceci est une chaîne." !! 0 -- 'C'
+
+
+----------------------------------------------------
+-- Lists and Tuples
+----------------------------------------------------
+
+-- Chaque élément d'une liste doit avoir le même type.
+-- les deux lignes suivantes sont semblables
+[1, 2, 3, 4, 5]
+[1..5]
+
+-- Il y a aussi des listes infinies en Haskell!
+[1..] -- une liste de tous les nombres naturels
+
+-- Les listes infinies fonctionnent parce que Haskell a « l'évaluation 
+-- paresseuse ». Ça veut dire qu'il n'évalue que ce qui a besoin
+-- de l'être. Vous pouvez donc vous demander le 1000e élément de votre liste
+-- et il vous le donnera:
+
+[1..] !! 999 -- 1000
+
+-- Et là, Haskell a évalué les éléments 1 à 1000 de la liste... mais le reste
+-- de cette liste « infinie » n'existe pas encore! En fait, Haskell ne va jamais 
+-- le faire à moins qu'il le doive.
+
+-- Adjoindre deux listes 
+[1..5] ++ [6..10]
+
+-- ajouter au début de la liste
+0:[1..5] -- [0, 1, 2, 3, 4, 5]
+
+-- l'indice d'une liste
+[0..] !! 5 -- 5
+
+-- d'autres opérations sur les listes
+head [1..5] -- 1
+tail [1..5] -- [2, 3, 4, 5]
+init [1..5] -- [1, 2, 3, 4]
+last [1..5] -- 5
+
+--liste en compréhension
+[x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10]
+
+--avec un conditionnel
+[x*2 | x <- [1..5], x*2 > 4] -- [6, 8, 10]
+
+-- Chaque élément d'un tuple peut être d'un type différent, mais un
+-- tuple a une longueur fixée.
+-- Un tuple:
+("haskell", 1)
+
+-- accéder aux éléments d'un tuple
+fst ("haskell", 1) -- "haskell"
+snd ("haskell", 1) -- 1
+
+----------------------------------------------------
+-- 3. Functions
+----------------------------------------------------
+-- Une simple fonction qui prend deux paramètres
+add a b = a + b
+
+-- Notez que si vous utilisez ghci (l'interpréteur Haskell)
+-- vous devrez utiliser `let`. Par exemple:
+-- let add a b = a + b
+
+-- Utiliser une fonction
+add 1 2 -- 3
+
+-- Vous pouvez également mettre le nom de la fonction entre les
+-- deux arguments avec des accents graves:
+1 `add` 2 -- 3
+
+-- Vous pouvez également définir des fonctions qui n'ont pas de
+-- lettres! Ça vous laisse créer vos propres opérateurs! Voilà 
+-- un opérateur qui fait une division entière:
+(//) a b = a `div` b
+35 // 4 -- 8
+
+-- Gardes: une façon pour créer des bifurcations de fonction
+fib x
+  | x < 2 = x
+  | otherwise = fib (x - 1) + fib (x - 2)
+
+-- Le filtrage par motif est similaire. Là on a donné trois 
+-- définitions différentes de `fib`. Haskell appellera automatiquement
+-- la première fonction qui correspondra au motif de la valeur.
+fib 1 = 1
+fib 2 = 2
+fib x = fib (x - 1) + fib (x - 2)
+
+-- Filtrage par motif sur un tuple.
+foo (x, y) = (x + 1, y + 2)
+
+-- Filtrage par motif sur des listes. Ici, `x` est le premier
+-- élément de la liste, et `xs` le reste. On peut écrire notre
+-- propre fonction `map`:
+myMap func [] = []
+myMap func (x:xs) = func x:(myMap func xs)
+
+-- Les fonctions anonymes sont créées avec des barres obliques 
+-- inverses, suivies de tous les arguments.
+myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7]
+
+-- Une utilisation de fold (appelée `inject` dans quelques autres
+-- langages) avec comme paramètre une fonction anonyme.
+-- `foldl1` veut dire fold left -- soit littéralement pli gauche --
+-- et utilise la première valeur de la liste comme accumulateur.
+foldl1 (\acc x -> acc + x) [1..5] -- 15
+
+----------------------------------------------------
+-- 4. Plus de fonctions
+----------------------------------------------------
+
+-- curryfaction: si vous n'appliquez pas tous les arguments à une
+-- fonction, elle devient « curryfiée ». Ça veut dire qu'elle retourne
+-- une fonction qui prend le reste des arguments.
+
+add a b = a + b
+foo = add 10 -- foo est une fonction qui prend un nombre et y ajoute 10
+foo 5 -- 15
+
+-- Une autre façon de l'écrire
+foo = (+10)
+foo 5 -- 15
+
+-- Composition de fonctions
+-- la fonction (.) enchaîne deux fonctions.
+-- Par exemple, on a foo qui est une fonction qui prend une valeur, y ajoute
+-- 10 et multiplie ce résultat par 5, et ensuite retourne la valeur finale.
+foo = (*5) . (+10)
+
+-- (5 + 10) * 5 = 75
+foo 5 -- 75
+
+-- fixation de priorité
+-- Haskell a une autre fonction appelée `$`. Elle peut changer la priorité
+-- de sorte que tout ce qu'il y a à sa gauche est calculé d'abord et ensuite 
+-- appliqué à tout ce qu'il y a à droite. Vous pouvez utiliser `.` et `$` 
+-- pour vous débarrasser de beaucoup de parenthèses:
+
+-- avant
+(even (fib 7)) -- False
+
+-- ensuite
+even . fib $ 7 -- False
+
+----------------------------------------------------
+-- 5. Signature de type
+----------------------------------------------------
+
+-- Haskell a un système de types très strict; et en Haskell, tout a un type.
+
+-- Quelques types simples:
+5 :: Integer
+"hello" :: String
+True :: Bool
+
+-- Les fonctions ont des types également.
+-- `not` prend un booléen et retourne un booléen.
+-- not :: Bool -> Bool
+
+-- Voilà une fonction qui prend deux paramètres.
+-- add :: Integer -> Integer -> Integer
+
+-- Quand vous définissez une valeur, une bonne pratique est d'écrire 
+-- son type explicitement
+double :: Integer -> Integer
+double x = x * 2
+
+----------------------------------------------------
+-- 6. Flux de contrôle et structures conditionnelles
+----------------------------------------------------
+
+-- structure conditionnelle if
+haskell = if 1 == 1 then "awesome" else "awful" -- haskell = "awesome"
+
+-- les structures if peuvent être écrites sur plusieurs lignes
+haskell = if 1 == 1
+            then "awesome"
+            else "awful"
+
+-- les structures case: voilà comment vous pouvez analyser les arguments de 
+-- ligne de commande
+case args of
+  "help" -> printHelp
+  "start" -> startProgram
+  _ -> putStrLn "bad args"
+
+
+-- Haskell n'a pas de boucles parce qu'il utilise la récursion.
+-- `map` applique une fonction sur chaque élément d'une liste
+
+map (*2) [1..5] -- [2, 4, 6, 8, 10]
+
+-- vous pouvez créer une fonction `for` en utilisant `map`
+for array func = map func array
+
+-- et l'utiliser
+for [0..5] $ \i -> show i
+
+-- nous aurions pu l'écrire également ainsi
+for [0..5] show
+
+-- vous pouvez utiliser foldl et foldr pour 
+-- réduire une liste
+-- foldl <fonction> <valeur initiale> <liste>
+foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43
+
+-- C'est donc la même chose que 
+(2 * (2 * (2 * 4 + 1) + 2) + 3)
+
+-- foldl évalue de gauche à droite, foldr
+-- de droite à gauche
+foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16
+
+-- Et c'est équivalent à
+(2 * 3 + (2 * 2 + (2 * 1 + 4)))
+
+----------------------------------------------------
+-- 7. Types de données
+----------------------------------------------------
+
+-- Vous pouvez écrire vos propres types de données en Haskell
+
+data Couleur = Rouge | Bleu | Vert
+
+-- Et maintenant l'utiliser dans une fonction
+
+
+say :: Couleur -> String
+say Rouge = "Vous êtes Rouge!"
+say Bleu = "Vous êtes Bleu!"
+say Vert =  "Vous êtes Vert!"
+
+-- Vos types peuvent également avoir des paramètres
+
+data Maybe a = Nothing | Just a
+
+-- Tous les exemples ci-dessous sont issus du type Maybe
+Just "hello"    -- of type `Maybe String`
+Just 1          -- of type `Maybe Int`
+Nothing         -- of type `Maybe a` for any `a`
+
+----------------------------------------------------
+-- 8. Haskell IO
+----------------------------------------------------
+
+-- Tandis que l'IO ne peut pas être totalement expliqué pleinement
+-- sans que les monades ne le soient, il n'est pas difficile
+-- d'expliquer suffisamment pour commencer.
+
+-- Quand un programme en Haskell est exécuté, la fonction `main`
+-- est appelée. Il doit retourner une valeur de type `IO ()`.
+-- Par exemple:
+
+main :: IO ()
+main = putStrLn $ "Bonjour, le ciel! " ++ (say Blue) 
+-- putStrLn a comme type String -> IO ()
+
+-- La façon la plus simple pour faire de l'IO est de faire un programme 
+-- fonction de String vers String. La fonction
+--    interact :: (String -> String) -> IO ()
+-- prend un texte, applique une fonction et affiche le résultat.
+
+countLines :: String -> String
+countLines = show . length . lines
+
+main' = interact countLines
+
+-- Vous pouvez considérer qu'une valeur de type `IO ()` représente
+-- une séquence d'actions que l'ordinateur exécute, un peu comme 
+-- dans un langage impératif. On peut utiliser la structure `do` 
+-- pour enchaîner des actions. Par exemple:
+
+sayHello :: IO ()
+sayHello = do 
+   putStrLn "Quel est ton nom ?"
+   name <- getLine -- prend une ligne et assigne sa valeur à `name`
+   putStrLn $ "Salut, " ++ name
+   
+-- Exercice: écrire votre propre version d'`interact` qui ne fait 
+--           que de lire une ligne d'entrée.
+   
+-- Le code de `sayHello` ne sera jamais exécuté, cependant. La seule
+-- action qui sera exécutée est la valeur de `main`.
+-- Pour lancer `sayHello`, commentez l'ancienne définition de `main`
+-- et remplacez-le par:
+--   main = sayHello
+
+-- Essaions de mieux comprendre comment la fonction `getLine` que 
+-- nous venons d'utiliser. Son type est:
+--    getLine :: IO String
+-- vous pouvez considérer le type `IO a` comme un programme que
+-- le programme va générer comme une valeur de type `a` quand
+-- il sera exécuté. On peut l'enregistrer et la réutiliser en
+-- utilisant `<-`. On peut aussi faire nos propres actions
+-- de type `IO String`:
+
+action :: IO String
+action = do
+   putStrLn "C'est une ligne. Heu"
+   input1 <- getLine 
+   input2 <- getLine
+   -- Le type de la structure `do` est celui de sa dernière ligne.
+   -- `return` n'est pas un mot clef, mais simplement une fonction.
+   return (input1 ++ "\n" ++ input2) -- return :: String -> IO String
+
+-- On peut maintenant l'utiliser comme on a utilisé `getLine`
+-- tout à l'heure
+
+main'' = do
+    putStrLn "Je vais afficher deux lignes!"
+    result <- action 
+    putStrLn result
+    putStrLn "C'était tout!"
+
+-- Le type `IO` est un exemple de « monade ». La façon dont Haskell utilise
+-- une monade pour faire de l'IO lui permet d'être purement fonctionnel. N'importe
+-- quelle fonction qui interagit avec le « monde extérieur » (c'est à dire fait de l'IO)
+-- devient marqué comme `IO` dans la signature de son type. Ça nous montre
+-- quelles fonctions sont « pures » (n'interagissent pas avec le monde extérieur
+-- ou ne changent pas d'état) et quelles fonctions ne le sont pas.
+
+-- C'est une fonctionnalité très puissante, car il est facile d'exécuter 
+-- des fonctions pures simultanément, et donc la concurrence en Haskell
+-- est très facile.
+
+
+----------------------------------------------------
+-- 9. Le REPL de Haskell
+----------------------------------------------------
+
+-- Lancer le REPL en tapant `ghci`.
+-- Vous pouvez maintenant taper du code Haskell.
+-- Toutes les nouvelles valeurs peuvent être crées 
+-- avec `let`:
+
+let foo = 5
+
+-- Vous pouvez voir le type de n'importe quelle valeur avec `:t`:
+
+>:t foo
+foo :: Integer
+
+-- Vous pouvez également des actions de type `IO ()`
+
+> sayHello
+Quel est ton nom ?
+Ami!
+Salut, Ami!
+
+```
+
+Et Haskell ne se limite pas à ça, on trouve encore par exemple les classes de types et les monades. Il y a beaucoup de raisons qui font que coder en Haskell est si *fun*. Je vous laisse avec un dernier exemple: une implémentation de quicksort:
+
+```haskell
+qsort [] = []
+qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater
+    where lesser  = filter (< p) xs
+          greater = filter (>= p) xs
+```
+
+Haskell facile à installer. Téléchargez-le [ici](http://www.haskell.org/platform/).
+
+Vous pouvez trouver une approche beaucoup plus douce avec les excellents
+[Learn you a Haskell](http://lyah.haskell.fr/) ou
+[Real World Haskell (en)](http://book.realworldhaskell.org/).
-- 
cgit v1.2.3


From 200298c7691e0f0b78b7e879fcf7fc4909cea16a Mon Sep 17 00:00:00 2001
From: C-Duv <github.accounts@claude.duvergier.fr>
Date: Fri, 11 Oct 2013 10:13:12 +0200
Subject: French translation typo in comments for slice syntax with omitted
 indexes

Translation typo in comments for slice syntax with omitted indexes:
"Omit the beginning" meant omit the beginning *of the list* (not the beginning of the range)
"Omit the end" meant omit the end *of the list* (not the end of the range)
---
 fr-fr/python-fr.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/python-fr.html.markdown b/fr-fr/python-fr.html.markdown
index 2bf0afd0..9dbdafe1 100644
--- a/fr-fr/python-fr.html.markdown
+++ b/fr-fr/python-fr.html.markdown
@@ -156,9 +156,9 @@ li[4] # Lève un 'IndexError'
 # On peut accèder à des rangs de valeurs avec la syntaxe "slice"
 # (C'est un rang de type 'fermé/ouvert' pour les plus matheux)
 li[1:3] #=> [2, 4]
-# Sans spécifier de début de rang
+# Sans spécifier de fin de rang, on "saute" le début de la liste
 li[2:] #=> [4, 3]
-# Sans spécifier de fin de rang
+# Sans spécifier de début de rang, on "saute" la fin de la liste
 li[:3] #=> [1, 2, 4]
 
 # Retirer un élément spécifique dee la liste avec "del"
-- 
cgit v1.2.3


From aa2506aa2a06b108794b7e624c5375c088285b6c Mon Sep 17 00:00:00 2001
From: David Baumgartner <_davidbaumgartner@bluewin.ch>
Date: Wed, 16 Oct 2013 18:18:37 +0200
Subject: Applying corrections

---
 fr-fr/haskell.html.markdown | 97 +++++++++++++++++++++++----------------------
 1 file changed, 49 insertions(+), 48 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/haskell.html.markdown b/fr-fr/haskell.html.markdown
index 519bffd6..9d0cec99 100644
--- a/fr-fr/haskell.html.markdown
+++ b/fr-fr/haskell.html.markdown
@@ -2,7 +2,9 @@
 language: haskell
 contributors:
     - ["Adit Bhargava", "http://adit.io"]
-    - ["David Baumgartner", "http://davidbaumgartner.ch"]
+translators:
+    - ["David Baumgartner", "http://davidbaumgartner.ch"]    
+lang: fr-fr
 ---
 
 Haskell a été conçu pour être un langage fonctionnel pur et maniable. Il est connu pour ses monades et son système de types, mais je n'ai cesse d'y revenir pour son élégance. Pour moi, Haskell fait de la programmation une joie.
@@ -20,7 +22,7 @@ un bloc de cette façon.
 -- Vous avez les nombres
 3 -- 3
 
--- Les maths sont telles que vous vous y attendez
+-- Les maths sont comme vous vous y attendez
 1 + 1 -- 2
 8 - 1 -- 7
 10 * 2 -- 20
@@ -46,14 +48,14 @@ not False -- True
 -- Dans les exemples plus hauts, `not` est une fonction qui prend une valeur.
 -- Haskell n'a pas besoin de parenthèses pour appeler une fonction... tous
 -- les arguments sont juste listés après la fonction. Le schéma général est
--- donc:
+-- donc :
 -- func arg1 arg2 arg3...
 -- Voyez la section sur les fonctions pour savoir comment écrire les vôtres.
 
 -- Caractères et chaînes de caractère
 "Ceci est une chaîne de caractère."
 'a' -- caractère
-'Vous pouvez utiliser des apostrophes pour les chaînes de caractère.' -- erreur !
+'Vous ne pouvez pas utiliser des apostrophes pour les chaînes de caractère.' -- erreur !
 
 -- Les chaînes peuvent être concaténées
 "Hello " ++ "world!" -- "Hello world!"
@@ -63,27 +65,26 @@ not False -- True
 
 
 ----------------------------------------------------
--- Lists and Tuples
+-- Listes et tuples
 ----------------------------------------------------
 
--- Chaque élément d'une liste doit avoir le même type.
+-- Tous les éléments d'une liste doit avoir le même type.
 -- les deux lignes suivantes sont semblables
 [1, 2, 3, 4, 5]
 [1..5]
 
--- Il y a aussi des listes infinies en Haskell!
+-- Il y a aussi des listes infinies en Haskell !
 [1..] -- une liste de tous les nombres naturels
 
--- Les listes infinies fonctionnent parce que Haskell a « l'évaluation 
--- paresseuse ». Ça veut dire qu'il n'évalue que ce qui a besoin
--- de l'être. Vous pouvez donc vous demander le 1000e élément de votre liste
--- et il vous le donnera:
+-- Les listes infinies fonctionnent parce que Haskell est « paresseux »:
+-- ça veut dire qu'il n'évalue que ce qui a besoin de l'être. Vous pouvez
+-- donc vous demander le 1000e élément de votre liste et il vous le donnera :
 
 [1..] !! 999 -- 1000
 
 -- Et là, Haskell a évalué les éléments 1 à 1000 de la liste... mais le reste
--- de cette liste « infinie » n'existe pas encore! En fait, Haskell ne va jamais 
--- le faire à moins qu'il le doive.
+-- de cette liste « infinie » n'existe pas encore ! En fait, Haskell ne va jamais 
+-- le faire à moins qu'il ne le doive.
 
 -- Adjoindre deux listes 
 [1..5] ++ [6..10]
@@ -108,7 +109,7 @@ last [1..5] -- 5
 
 -- Chaque élément d'un tuple peut être d'un type différent, mais un
 -- tuple a une longueur fixée.
--- Un tuple:
+-- Un tuple :
 ("haskell", 1)
 
 -- accéder aux éléments d'un tuple
@@ -122,30 +123,30 @@ snd ("haskell", 1) -- 1
 add a b = a + b
 
 -- Notez que si vous utilisez ghci (l'interpréteur Haskell)
--- vous devrez utiliser `let`. Par exemple:
+-- vous devrez utiliser `let`. Par exemple :
 -- let add a b = a + b
 
 -- Utiliser une fonction
 add 1 2 -- 3
 
 -- Vous pouvez également mettre le nom de la fonction entre les
--- deux arguments avec des accents graves:
+-- deux arguments avec des accents graves :
 1 `add` 2 -- 3
 
 -- Vous pouvez également définir des fonctions qui n'ont pas de
--- lettres! Ça vous laisse créer vos propres opérateurs! Voilà 
--- un opérateur qui fait une division entière:
+-- lettres ! Ça vous laisse créer vos propres opérateurs ! Voilà 
+-- un opérateur qui fait une division entière :
 (//) a b = a `div` b
 35 // 4 -- 8
 
--- Gardes: une façon pour créer des bifurcations de fonction
+-- Gardes : Une façon de gérer la valeur de vos arguments en amont
 fib x
   | x < 2 = x
   | otherwise = fib (x - 1) + fib (x - 2)
 
--- Le filtrage par motif est similaire. Là on a donné trois 
+-- Le filtrage par motif est similaire. Là, on a donné trois 
 -- définitions différentes de `fib`. Haskell appellera automatiquement
--- la première fonction qui correspondra au motif de la valeur.
+-- la première fonction qui correspond au motif de la valeur.
 fib 1 = 1
 fib 2 = 2
 fib x = fib (x - 1) + fib (x - 2)
@@ -155,7 +156,7 @@ foo (x, y) = (x + 1, y + 2)
 
 -- Filtrage par motif sur des listes. Ici, `x` est le premier
 -- élément de la liste, et `xs` le reste. On peut écrire notre
--- propre fonction `map`:
+-- propre fonction `map` :
 myMap func [] = []
 myMap func (x:xs) = func x:(myMap func xs)
 
@@ -173,7 +174,7 @@ foldl1 (\acc x -> acc + x) [1..5] -- 15
 -- 4. Plus de fonctions
 ----------------------------------------------------
 
--- curryfaction: si vous n'appliquez pas tous les arguments à une
+-- curryfication : si vous n'appliquez pas tous les arguments à une
 -- fonction, elle devient « curryfiée ». Ça veut dire qu'elle retourne
 -- une fonction qui prend le reste des arguments.
 
@@ -198,7 +199,7 @@ foo 5 -- 75
 -- Haskell a une autre fonction appelée `$`. Elle peut changer la priorité
 -- de sorte que tout ce qu'il y a à sa gauche est calculé d'abord et ensuite 
 -- appliqué à tout ce qu'il y a à droite. Vous pouvez utiliser `.` et `$` 
--- pour vous débarrasser de beaucoup de parenthèses:
+-- pour vous débarrasser de beaucoup de parenthèses :
 
 -- avant
 (even (fib 7)) -- False
@@ -210,22 +211,22 @@ even . fib $ 7 -- False
 -- 5. Signature de type
 ----------------------------------------------------
 
--- Haskell a un système de types très strict; et en Haskell, tout a un type.
+-- Haskell a un système de types très strict : par exemple, tout a un type.
 
--- Quelques types simples:
+-- Quelques types simples :
 5 :: Integer
 "hello" :: String
 True :: Bool
 
--- Les fonctions ont des types également.
+-- Les fonctions ont également des types.
 -- `not` prend un booléen et retourne un booléen.
 -- not :: Bool -> Bool
 
 -- Voilà une fonction qui prend deux paramètres.
 -- add :: Integer -> Integer -> Integer
 
--- Quand vous définissez une valeur, une bonne pratique est d'écrire 
--- son type explicitement
+-- Quand vous définissez une valeur (souvenez-vous, tout est valeur en
+-- Haskell), une bonne pratique est d'écrire son type explicitement
 double :: Integer -> Integer
 double x = x * 2
 
@@ -241,7 +242,7 @@ haskell = if 1 == 1
             then "awesome"
             else "awful"
 
--- les structures case: voilà comment vous pouvez analyser les arguments de 
+-- les structures case : voilà comment vous pourriez analyser les arguments de 
 -- ligne de commande
 case args of
   "help" -> printHelp
@@ -290,9 +291,9 @@ data Couleur = Rouge | Bleu | Vert
 
 
 say :: Couleur -> String
-say Rouge = "Vous êtes Rouge!"
-say Bleu = "Vous êtes Bleu!"
-say Vert =  "Vous êtes Vert!"
+say Rouge = "Vous êtes Rouge !"
+say Bleu = "Vous êtes Bleu !"
+say Vert =  "Vous êtes Vert !"
 
 -- Vos types peuvent également avoir des paramètres
 
@@ -313,10 +314,10 @@ Nothing         -- of type `Maybe a` for any `a`
 
 -- Quand un programme en Haskell est exécuté, la fonction `main`
 -- est appelée. Il doit retourner une valeur de type `IO ()`.
--- Par exemple:
+-- Par exemple :
 
 main :: IO ()
-main = putStrLn $ "Bonjour, le ciel! " ++ (say Blue) 
+main = putStrLn $ "Bonjour, le ciel ! " ++ (say Blue) 
 -- putStrLn a comme type String -> IO ()
 
 -- La façon la plus simple pour faire de l'IO est de faire un programme 
@@ -332,7 +333,7 @@ main' = interact countLines
 -- Vous pouvez considérer qu'une valeur de type `IO ()` représente
 -- une séquence d'actions que l'ordinateur exécute, un peu comme 
 -- dans un langage impératif. On peut utiliser la structure `do` 
--- pour enchaîner des actions. Par exemple:
+-- pour enchaîner des actions. Par exemple :
 
 sayHello :: IO ()
 sayHello = do 
@@ -340,23 +341,23 @@ sayHello = do
    name <- getLine -- prend une ligne et assigne sa valeur à `name`
    putStrLn $ "Salut, " ++ name
    
--- Exercice: écrire votre propre version d'`interact` qui ne fait 
+-- Exercice : écrire votre propre version d'`interact` qui ne fait 
 --           que de lire une ligne d'entrée.
    
 -- Le code de `sayHello` ne sera jamais exécuté, cependant. La seule
 -- action qui sera exécutée est la valeur de `main`.
 -- Pour lancer `sayHello`, commentez l'ancienne définition de `main`
--- et remplacez-le par:
+-- et remplacez-le par :
 --   main = sayHello
 
 -- Essaions de mieux comprendre comment la fonction `getLine` que 
--- nous venons d'utiliser. Son type est:
+-- nous venons d'utiliser. Son type est :
 --    getLine :: IO String
 -- vous pouvez considérer le type `IO a` comme un programme que
 -- le programme va générer comme une valeur de type `a` quand
 -- il sera exécuté. On peut l'enregistrer et la réutiliser en
 -- utilisant `<-`. On peut aussi faire nos propres actions
--- de type `IO String`:
+-- de type `IO String` :
 
 action :: IO String
 action = do
@@ -371,10 +372,10 @@ action = do
 -- tout à l'heure
 
 main'' = do
-    putStrLn "Je vais afficher deux lignes!"
+    putStrLn "Je vais afficher deux lignes !"
     result <- action 
     putStrLn result
-    putStrLn "C'était tout!"
+    putStrLn "C'était tout !"
 
 -- Le type `IO` est un exemple de « monade ». La façon dont Haskell utilise
 -- une monade pour faire de l'IO lui permet d'être purement fonctionnel. N'importe
@@ -395,25 +396,25 @@ main'' = do
 -- Lancer le REPL en tapant `ghci`.
 -- Vous pouvez maintenant taper du code Haskell.
 -- Toutes les nouvelles valeurs peuvent être crées 
--- avec `let`:
+-- avec `let` :
 
 let foo = 5
 
--- Vous pouvez voir le type de n'importe quelle valeur avec `:t`:
+-- Vous pouvez voir le type de n'importe quelle valeur avec `:t` :
 
 >:t foo
 foo :: Integer
 
--- Vous pouvez également des actions de type `IO ()`
+-- Vous pouvez également lancer des actions de type `IO ()`
 
 > sayHello
 Quel est ton nom ?
-Ami!
-Salut, Ami!
+Ami
+Salut, Ami !
 
 ```
 
-Et Haskell ne se limite pas à ça, on trouve encore par exemple les classes de types et les monades. Il y a beaucoup de raisons qui font que coder en Haskell est si *fun*. Je vous laisse avec un dernier exemple: une implémentation de quicksort:
+Et Haskell ne se limite pas à ça, on trouve encore par exemple les classes de types et les monades. Il y a beaucoup de raisons qui font que coder en Haskell est si *fun*. Je vous laisse avec un dernier exemple : une implémentation de quicksort :
 
 ```haskell
 qsort [] = []
-- 
cgit v1.2.3


From e4b82f94155af6c18236b0811be8defd214d68a8 Mon Sep 17 00:00:00 2001
From: lkdjiin <xavier.nayrac@gmail.com>
Date: Sat, 7 Dec 2013 11:40:00 +0100
Subject: First draft for french translation of Racket

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

(limited to 'fr-fr')

diff --git a/fr-fr/racket-fr.html.markdown b/fr-fr/racket-fr.html.markdown
new file mode 100644
index 00000000..ab103647
--- /dev/null
+++ b/fr-fr/racket-fr.html.markdown
@@ -0,0 +1,630 @@
+---
+language: racket
+filename: learnracket-fr.rkt
+contributors:
+  - ["th3rac25", "https://github.com/voila"]
+  - ["Eli Barzilay", "https://github.com/elibarzilay"]
+  - ["Gustavo Schmidt", "https://github.com/gustavoschmidt"]
+translators:
+  - ["Xavier Nayrac", "https://github.com/lkdjiin"]
+lang: fr-fr
+---
+
+Racket est un langage de programmation généraliste, multi-paradigme,
+descendant de Lisp/Scheme.
+
+Les retours et commentaires sont appréciés ! Vous pouvez joindre l'auteur
+original ici :
+[@th3rac25](http://twitter.com/th3rac25) ou là : th3rac25 [at] [google's email
+service]. Vous pouvez joindre le traducteur de ce document ici :
+[@lkdjiin](http://twitter.com/lkdjiin).
+
+```racket
+#lang racket ; défini le dialecte à utiliser.
+
+;;; Commentaires
+
+;; Une ligne de commentaire commence par un point-virgule.
+
+#| Un bloc de commentaires
+   peut tenir sur plusieurs lignes…
+    #|
+       et on peut les imbriquer !
+    |#
+|#
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 1. Types de données et opérateurs primitifs
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; Nombres
+9999999999999999999999 ; entier
+#b111                  ; binaire => 7
+#o111                  ; octal => 73
+#x111                  ; hexadécimal => 273
+3.14                   ; réel
+6.02e+23
+1/2                    ; rationnel
+1+2i                   ; complexe
+
+;; Une fonction s'écrit (f x y z ...)
+;; où f est une fonction et x, y, z, ... sont des arguments.
+;; Si vous voulez créer une liste de données litérales, utilisez ' pour
+;; empécher l'évaluation de la liste.
+'(+ 1 2) ; => (+ 1 2)
+;; Et maintenant, un peu d'arithmétique
+(+ 1 1)  ; => 2
+(- 8 1)  ; => 7
+(* 10 2) ; => 20
+(expt 2 3) ; => 8
+(quotient 5 2) ; => 2
+(remainder 5 2) ; => 1
+(/ 35 5) ; => 7
+(/ 1 3) ; => 1/3
+(exact->inexact 1/3) ; => 0.3333333333333333
+(+ 1+2i  2-3i) ; => 3-1i
+
+;;; Booléens
+#t ; for true
+#f ; for false -- any value other than #f is true
+(not #t) ; => #f
+(and 0 #f (error "doesn't get here")) ; => #f
+(or #f 0 (error "doesn't get here"))  ; => 0
+
+;;; Caractères
+#\A ; => #\A
+#\λ ; => #\λ
+#\u03BB ; => #\λ
+
+;;; Une chaîne de caractères est un tableau de caractères de longueur
+;;; fixe.
+"Hello, world!"
+"Benjamin \"Bugsy\" Siegel"   ; le backslash est le caractère d'échappement
+"Foo\tbar\41\x21\u0021\a\r\n" ; sont inclus les échappements de type C
+                              ; et unicode
+"λx:(μα.α→α).xx"              ; une chaîne peut inclure de l'unicode
+
+;; On peut ajouter une chaîne à une autre
+(string-append "Hello " "world!") ; => "Hello world!"
+
+;; Une chaîne peut être traitée comme une liste de caractères
+(string-ref "Apple" 0) ; => #\A
+
+;; format est utilisé pour formatter une chaîne
+(format "~a can be ~a" "strings" "formatted")
+
+;; L'affichage est tout simple
+(printf "I'm Racket. Nice to meet you!\n")
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 2. Variables
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Vous pouvez créer une variable à l'aide de define
+;; a variable name can use any character except: ()[]{}",'`;#|\
+;; Une variable peut contenir n'importe quel caractères, à l'exception
+;; de : ()[]{}",'`;#|\
+(define some-var 5)
+some-var ; => 5
+
+;; Vous pouvez aussi utiliser des caractères unicode
+(define ⊆ subset?)
+(⊆ (set 3 2) (set 1 2 3)) ; => #t
+
+;; Accéder à une variable non-initialisée provoque une exception
+; x ; => x: indéfini ...
+
+;; Attachement local : `me` est attaché à "Bob" seulement à l'intérieur
+;; de (let ...)
+(let ([me "Bob"])
+  "Alice"
+  me) ; => "Bob"
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 3. Structures and Collections
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Structures
+(struct dog (name breed age))
+(define my-pet
+  (dog "lassie" "collie" 5))
+my-pet ; => #<dog>
+(dog? my-pet) ; => #t
+(dog-name my-pet) ; => "lassie"
+
+;;; Paires (non-mutable)
+;; `cons` construit une paire, `car` et `cdr` extraient respectivement les
+;; premiers et seconds éléments.
+(cons 1 2) ; => '(1 . 2)
+(car (cons 1 2)) ; => 1
+(cdr (cons 1 2)) ; => 2
+
+;;; Listes
+
+;; Les listes en Racket sont des structures de données de type *linked-list*,
+;; produites avec des paires assemblées avec `cons` et terminée avec `null`
+;; (ou '()).
+(cons 1 (cons 2 (cons 3 null))) ; => '(1 2 3)
+;; `list` est un constructeur variadique plus commode à utiliser
+(list 1 2 3) ; => '(1 2 3)
+;; et un guillemet simple peut aussi être utilisé pour une liste litérale
+'(1 2 3) ; => '(1 2 3)
+
+;; On peut toujours utiliser `cons` pour ajouter un élément au début
+;; d'une liste
+(cons 4 '(1 2 3)) ; => '(4 1 2 3)
+
+;; Utilisez `append` pour additionner des listes entre elles
+(append '(1 2) '(3 4)) ; => '(1 2 3 4)
+
+;; Les listes sont un type très basique, il y a donc *beaucoup* de
+;; fonctionnalités qui leur sont dédiées, quelques exemples :
+(map add1 '(1 2 3))          ; => '(2 3 4)
+(map + '(1 2 3) '(10 20 30)) ; => '(11 22 33)
+(filter even? '(1 2 3 4))    ; => '(2 4)
+(count even? '(1 2 3 4))     ; => 2
+(take '(1 2 3 4) 2)          ; => '(1 2)
+(drop '(1 2 3 4) 2)          ; => '(3 4)
+
+;;; Vecteurs
+
+;; Un vecteur est un tableau de taille fixe
+#(1 2 3) ; => '#(1 2 3)
+
+;; Utilisez `vector-append` pour additionner des vecteurs entre eux
+(vector-append #(1 2 3) #(4 5 6)) ; => #(1 2 3 4 5 6)
+
+;;; Sets
+
+;; Créew un set à partir d'une liste
+(list->set '(1 2 3 1 2 3 3 2 1 3 2 1)) ; => (set 1 2 3)
+
+;; Ajoutez un membre avec `set-add`
+;; (Fonctionnel: renvoit le set étendu, plutôt que de muter le set en entrée)
+(set-add (set 1 2 3) 4) ; => (set 1 2 3 4)
+
+;; Retirer un membre avec `set-remove`
+(set-remove (set 1 2 3) 1) ; => (set 2 3)
+
+;; Tester l'existence d'un membre avec `set-member?`
+(set-member? (set 1 2 3) 1) ; => #t
+(set-member? (set 1 2 3) 4) ; => #f
+
+;;; Tables de hashage
+
+;; Créer une table de hashage non-mutable (un exemple mutable plus loin)
+(define m (hash 'a 1 'b 2 'c 3))
+
+;; Retrouver une valeur
+(hash-ref m 'a) ; => 1
+
+;; Chercher une valeur inexistante provoque une exceptions
+; (hash-ref m 'd) => no value found
+
+;; Vous pouvez fournir une valeur par défaut pour les clés manquantes
+(hash-ref m 'd 0) ; => 0
+
+;; Utilisez `hash-set` pour étendre une table de hashage non-mutable
+;; (Renvoit la table étendu, plutôt que de la muter)
+(define m2 (hash-set m 'd 4))
+m2 ; => '#hash((b . 2) (a . 1) (d . 4) (c . 3))
+
+;; Rappelez-vous, ces tables de hashage sont non-mutables !
+m ; => '#hash((b . 2) (a . 1) (c . 3))  <-- no `d'
+
+;; Utilisez `hash-remove` pour supprimer des clés (également fonctionnel)
+(hash-remove m 'a) ; => '#hash((b . 2) (c . 3))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 3. Fonctions
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Utilisez `lambda` pour créer des fonctions.
+;; Une fonction renvoit toujours la valeur de sa dernière expression.
+(lambda () "Hello World") ; => #<procedure>
+;; Can also use a unicode `λ'
+;; On peut aussi utiliser le caractère unicode `λ'
+(λ () "Hello World")     ; => même fonction
+
+;; Utilisez des parenthèses pour appeler toutes les fonctions, ce qui
+;; inclus aussi les expressions lambda
+((lambda () "Hello World")) ; => "Hello World"
+((λ () "Hello World"))      ; => "Hello World"
+
+;; Assignez une fonction à une variable
+(define hello-world (lambda () "Hello World"))
+(hello-world) ; => "Hello World"
+
+;; Vous pouvez raccourcir ceci en utilisant le sucre syntaxique pour la
+;; définition des fonctions :
+(define (hello-world2) "Hello World")
+
+;; Entre les () après lambda, vous avez la liste des arguments de la fonction
+(define hello
+  (lambda (name)
+    (string-append "Hello " name)))
+(hello "Steve") ; => "Hello Steve"
+;; … ou alors, en utilisant le sucre syntaxique, ce qui suit est équivalent
+(define (hello2 name)
+  (string-append "Hello " name))
+
+;; Vous pouvez obtenir des fonctions variadique en utilisant `case-lambda`
+(define hello3
+  (case-lambda
+    [() "Hello World"]
+    [(name) (string-append "Hello " name)]))
+(hello3 "Jake") ; => "Hello Jake"
+(hello3) ; => "Hello World"
+;; … ou spécifier des arguments optionnels avec une valeur par défaut
+(define (hello4 [name "World"])
+  (string-append "Hello " name))
+
+;; Les fonctions peuvent rassembler des arguments supplémentaires dans une
+;; liste
+(define (count-args . args)
+  (format "You passed ~a args: ~a" (length args) args))
+(count-args 1 2 3) ; => "You passed 3 args: (1 2 3)"
+;; … ou bien avec `lambda`, sans sucre syntaxique
+(define count-args2
+  (lambda args
+    (format "You passed ~a args: ~a" (length args) args)))
+
+;; Vous pouvez mixer arguments réguliers et supplémentaires
+(define (hello-count name . args)
+  (format "Hello ~a, you passed ~a extra args" name (length args)))
+(hello-count "Finn" 1 2 3)
+; => "Hello Finn, you passed 3 extra args"
+;; … sans sucre syntaxique
+(define hello-count2
+  (lambda (name . args)
+    (format "Hello ~a, you passed ~a extra args" name (length args))))
+
+;; Avec des mot-clés cette fois
+(define (hello-k #:name [name "World"] #:greeting [g "Hello"] . args)
+  (format "~a ~a, ~a extra args" g name (length args)))
+(hello-k)                 ; => "Hello World, 0 extra args"
+(hello-k 1 2 3)           ; => "Hello World, 3 extra args"
+(hello-k #:greeting "Hi") ; => "Hi World, 0 extra args"
+(hello-k #:name "Finn" #:greeting "Hey") ; => "Hey Finn, 0 extra args"
+(hello-k 1 2 3 #:greeting "Hi" #:name "Finn" 4 5 6)
+                                         ; => "Hi Finn, 6 extra args"
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 4. Égalité
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Pour les nombres, utilisez `=`
+(= 3 3.0) ; => #t
+(= 2 1) ; => #f
+
+;; Pour tester l'identité des objets, utilisez `eq?`
+(eq? 3 3) ; => #t
+(eq? 3 3.0) ; => #f
+(eq? (list 3) (list 3)) ; => #f
+
+;; Pour les collections, utilisez `equal?`
+(equal? (list 'a 'b) (list 'a 'b)) ; => #t
+(equal? (list 'a 'b) (list 'b 'a)) ; => #f
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 5. Contrôle du flot
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; Conditions
+
+(if #t               ; expression pour le test
+    "this is true"   ; expression si vrai
+    "this is false") ; expression si faux
+; => "this is true"
+
+;; Dans les condition, toutes les valeurs non-fausses sont traitées commentaires
+;; étant vraies (c'est à dire toutes sauf #f)
+(member 'Groucho '(Harpo Groucho Zeppo)) ; => '(Groucho Zeppo)
+(if (member 'Groucho '(Harpo Groucho Zeppo))
+    'yep
+    'nope)
+; => 'yep
+
+;; `cond` permet d'enchaîner une série de tests afin d'obtenir un résultat
+(cond [(> 2 2) (error "wrong!")]
+      [(< 2 2) (error "wrong again!")]
+      [else 'ok]) ; => 'ok
+
+;;; Filtrage par motif (*pattern matching*)
+
+(define (fizzbuzz? n)
+  (match (list (remainder n 3) (remainder n 5))
+    [(list 0 0) 'fizzbuzz]
+    [(list 0 _) 'fizz]
+    [(list _ 0) 'buzz]
+    [_          #f]))
+
+(fizzbuzz? 15) ; => 'fizzbuzz
+(fizzbuzz? 37) ; => #f
+
+;;; Les boucles
+
+;; On peut boucler en utilisant la récursion (terminale)
+(define (loop i)
+  (when (< i 10)
+    (printf "i=~a\n" i)
+    (loop (add1 i))))
+(loop 5) ; => i=5, i=6, ...
+
+;; D'une manière similaire, avec un `let` nommé
+(let loop ((i 0))
+  (when (< i 10)
+    (printf "i=~a\n" i)
+    (loop (add1 i)))) ; => i=0, i=1, ...
+
+;; Voir plus loin pour l'ajout d'une nouvelle forme `loop`, mais Racket
+;; possède déjà une forme `for` flexible et élaborée pour les itérations
+(for ([i 10])
+  (printf "i=~a\n" i)) ; => i=0, i=1, ...
+(for ([i (in-range 5 10)])
+  (printf "i=~a\n" i)) ; => i=5, i=6, ...
+
+;;; Itérer sur autre chose que des nombres
+;; `for` permet d'itérer sur plein de type de séquences:
+;; listes, vecteurs, chaînes de caractères, sets, tables de hashage, etc
+
+(for ([i (in-list '(l i s t))])
+  (displayln i))
+
+(for ([i (in-vector #(v e c t o r))])
+  (displayln i))
+
+(for ([i (in-string "string")])
+  (displayln i))
+
+(for ([i (in-set (set 'x 'y 'z))])
+  (displayln i))
+
+(for ([(k v) (in-hash (hash 'a 1 'b 2 'c 3 ))])
+  (printf "key:~a value:~a\n" k v))
+
+;;; Itérations plus complexes
+
+;; Balayage parallèle de plusieurs séquences (on stoppe sur la plus petite)
+(for ([i 10] [j '(x y z)]) (printf "~a:~a\n" i j))
+; => 0:x 1:y 2:z
+
+;; Boucles imbriquées
+(for* ([i 2] [j '(x y z)]) (printf "~a:~a\n" i j))
+; => 0:x, 0:y, 0:z, 1:x, 1:y, 1:z
+
+;; Conditions dans les boucles
+(for ([i 1000]
+      #:when (> i 5)
+      #:unless (odd? i)
+      #:break (> i 10))
+  (printf "i=~a\n" i))
+; => i=6, i=8, i=10
+
+;;; Compréhensions de liste
+;; Très similaires aux boucles `for` -- renvoient en plus une collection
+
+(for/list ([i '(1 2 3)])
+  (add1 i)) ; => '(2 3 4)
+
+(for/list ([i '(1 2 3)] #:when (even? i))
+  i) ; => '(2)
+
+(for/list ([i 10] [j '(x y z)])
+  (list i j)) ; => '((0 x) (1 y) (2 z))
+
+(for/list ([i 1000] #:when (> i 5) #:unless (odd? i) #:break (> i 10))
+  i) ; => '(6 8 10)
+
+(for/hash ([i '(1 2 3)])
+  (values i (number->string i)))
+; => '#hash((1 . "1") (2 . "2") (3 . "3"))
+
+;; Il y a plein d'autres fonctions natives pour collecter des données à
+;; l'aide de boucles
+(for/sum ([i 10]) (* i i)) ; => 285
+(for/product ([i (in-range 1 11)]) (* i i)) ; => 13168189440000
+(for/and ([i 10] [j (in-range 10 20)]) (< i j)) ; => #t
+(for/or ([i 10] [j (in-range 0 20 2)]) (= i j)) ; => #t
+;; Et pour n'importe quell combinaison arbitraire, utilisez `for/fold`
+(for/fold ([sum 0]) ([i '(1 2 3 4)]) (+ sum i)) ; => 10
+;; (Ceci peut souvent remplacer des boucles communes de style impératif)
+
+;;; Exceptions
+
+;; Pour capturer une exception, utilisez la forme `with-handlers`
+(with-handlers ([exn:fail? (lambda (exn) 999)])
+  (+ 1 "2")) ; => 999
+(with-handlers ([exn:break? (lambda (exn) "no time")])
+  (sleep 3)
+  "phew") ; => "phew", but if you break it => "no time"
+
+;; Utilisez `raise` pour soulever une exception, ou encore n'importe quelle
+;; autre valeur
+(with-handlers ([number?    ; capturer la valeur numérique soulevée
+                 identity]) ; la renvoyer en tant que valeur simple
+  (+ 1 (raise 2))) ; => 2
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 6. Mutabilité
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Util `set!` pour réassigner une valeur à une variable existante
+(define n 5)
+(set! n (add1 n))
+n ; => 6
+
+;; Utilisez le mécanisme des boites (*box*) pour les valeurs explicitement
+;; mutables (similaire aux pointeurs ou références dans d'autres langages)
+(define n* (box 5))
+(set-box! n* (add1 (unbox n*)))
+(unbox n*) ; => 6
+
+;; Beaucoup de types de données en Racket sont non-mutables (paires, listes,
+;; etc), certains ont à la fois une version mutable et une version
+;; non-mutable (chaînes, vecteurs, tables de hashage, etc)
+
+;; Utilisez `vector` ou `make-vector` pour créer des vecteurs mutables
+(define vec (vector 2 2 3 4))
+(define wall (make-vector 100 'bottle-of-beer))
+;; Utilisez `vector-set!` pour mettre à jour un emplacement
+(vector-set! vec 0 1)
+(vector-set! wall 99 'down)
+vec ; => #(1 2 3 4)
+
+;; Créer une table de hashage mutable vide et la manipuler
+(define m3 (make-hash))
+(hash-set! m3 'a 1)
+(hash-set! m3 'b 2)
+(hash-set! m3 'c 3)
+(hash-ref m3 'a)   ; => 1
+(hash-ref m3 'd 0) ; => 0
+(hash-remove! m3 'a)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 7. Modules
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Les modules permettent d'organiser le code en plusieurs fichiers
+;; et bibliothèques réutilisables. Ici, nous utiliserons des sous-modules,
+;; imbriqués dans le grand module que forme ce texte (qui démarre à la
+;; ligne `#lang`).
+
+(module cake racket/base ; défini un module `cake', basé sur racket/base
+
+  (provide print-cake) ; fonction exportée par le module (publique)
+
+  (define (print-cake n)
+    (show "   ~a   " n #\.)
+    (show " .-~a-. " n #\|)
+    (show " | ~a | " n #\space)
+    (show "---~a---" n #\-))
+
+  (define (show fmt n ch) ; fonction interne/privée
+    (printf fmt (make-string n ch))
+    (newline)))
+
+;; Utilisez `require` pour importer les fonctions fournies par le
+;; module (provide)
+(require 'cake) ; le ' est pour un sous-module local
+(print-cake 3)
+; (show "~a" 1 #\A) ; => erreur, `show` n'est pas exportée
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 8. Classes et objets
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Créer une classe fish% (% est idiomatique pour les noms de classes)
+(define fish%
+  (class object%
+    (init size) ; argument pour l'initialisation
+    (super-new) ; initialisation de la super-classe
+    ;; Les champs/membres/variables de classe
+    (define current-size size)
+    ;; Méthodes publiques
+    (define/public (get-size)
+      current-size)
+    (define/public (grow amt)
+      (set! current-size (+ amt current-size)))
+    (define/public (eat other-fish)
+      (grow (send other-fish get-size)))))
+
+;; Créer une instance de fish%
+(define charlie
+  (new fish% [size 10]))
+
+;; Utilisez `send` pour appeler une méthode d'un objet
+(send charlie get-size) ; => 10
+(send charlie grow 6)
+(send charlie get-size) ; => 16
+
+;; `fish%' is a plain "first class" value, which can get us mixins
+;; `fish%` est une simple valeur de «première classe», ce qui va permettre
+;; les mélanges (*mixins*)
+(define (add-color c%)
+  (class c%
+    (init color)
+    (super-new)
+    (define my-color color)
+    (define/public (get-color) my-color)))
+(define colored-fish% (add-color fish%))
+(define charlie2 (new colored-fish% [size 10] [color 'red]))
+(send charlie2 get-color)
+;; ou, sans les noms:
+(send (new (add-color fish%) [size 10] [color 'red]) get-color)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 9. Macros
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Les macros permettent d'étendre la syntaxe du langage
+
+;; Ajoutons une boucle `loop`
+(define-syntax-rule (while condition body ...)
+  (let loop ()
+    (when condition
+      body ...
+      (loop))))
+
+(let ([i 0])
+  (while (< i  10)
+    (displayln i)
+    (set! i (add1 i))))
+
+;; Les macros sont hygiéniques, vous ne pouvez pas *clasher* avec les
+;; variables existantes !
+(define-syntax-rule (swap! x y) ; ! est idiomatique pour la mutation
+  (let ([tmp x])
+    (set! x y)
+    (set! y tmp)))
+
+(define tmp 2)
+(define other 3)
+(swap! tmp other)
+(printf "tmp = ~a; other = ~a\n" tmp other)
+;; La variable `tmp` est renommée en `tmp_1`
+;; dans le but d'éviter un conflit de nom
+;; (let ([tmp_1 tmp])
+;;   (set! tmp other)
+;;   (set! other tmp_1))
+
+;; Mais il faut quand même faire bien attention avec les macros, par exemple:
+(define-syntax-rule (bad-while condition body ...)
+  (when condition
+    body ...
+    (bad-while condition body ...)))
+;; cette macro est cassée : ell génère un code infini, si vous l'essayez
+;; le compilateur va entrer dans une boucle infinie.
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 10. Contrats
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Les contrats imposent des contraintes aux valeurs exportées depuis
+;; les modules
+
+(module bank-account racket
+  (provide (contract-out
+            [deposit (-> positive? any)] ; un dépot est toujours positif
+            [balance (-> positive?)]))
+
+  (define amount 0)
+  (define (deposit a) (set! amount (+ amount a)))
+  (define (balance) amount)
+  )
+
+(require 'bank-account)
+(deposit 5)
+
+(balance) ; => 5
+
+;; Les clients qui essaient de déposer un montant non-positif sont blamés
+;; (deposit -5) ; => deposit: contract violation
+;; expected: positive?
+;; given: -5
+;; more details....
+```
+
+## Pour aller plus loin
+
+Vous en voulez plus ? Essayez
+[Getting Started with Racket](http://docs.racket-lang.org/getting-started/)
-- 
cgit v1.2.3


From 9221714ccc15ec315d1df671ecd08697028ee358 Mon Sep 17 00:00:00 2001
From: lkdjiin <xavier.nayrac@gmail.com>
Date: Sat, 7 Dec 2013 13:55:06 +0100
Subject: Second draft for french translation of Racket

---
 fr-fr/racket-fr.html.markdown | 52 +++++++++++++++++++++----------------------
 1 file changed, 25 insertions(+), 27 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/racket-fr.html.markdown b/fr-fr/racket-fr.html.markdown
index ab103647..8b2420f8 100644
--- a/fr-fr/racket-fr.html.markdown
+++ b/fr-fr/racket-fr.html.markdown
@@ -47,9 +47,9 @@ service]. Vous pouvez joindre le traducteur de ce document ici :
 1/2                    ; rationnel
 1+2i                   ; complexe
 
-;; Une fonction s'écrit (f x y z ...)
+;; Un appel de fonction s'écrit (f x y z ...)
 ;; où f est une fonction et x, y, z, ... sont des arguments.
-;; Si vous voulez créer une liste de données litérales, utilisez ' pour
+;; Si vous voulez créer une liste littérales, utilisez ' pour
 ;; empécher l'évaluation de la liste.
 '(+ 1 2) ; => (+ 1 2)
 ;; Et maintenant, un peu d'arithmétique
@@ -65,8 +65,8 @@ service]. Vous pouvez joindre le traducteur de ce document ici :
 (+ 1+2i  2-3i) ; => 3-1i
 
 ;;; Booléens
-#t ; for true
-#f ; for false -- any value other than #f is true
+#t ; pour vrai
+#f ; pour faux -- Toute autre valeur que #f est vraie
 (not #t) ; => #f
 (and 0 #f (error "doesn't get here")) ; => #f
 (or #f 0 (error "doesn't get here"))  ; => 0
@@ -79,8 +79,8 @@ service]. Vous pouvez joindre le traducteur de ce document ici :
 ;;; Une chaîne de caractères est un tableau de caractères de longueur
 ;;; fixe.
 "Hello, world!"
-"Benjamin \"Bugsy\" Siegel"   ; le backslash est le caractère d'échappement
-"Foo\tbar\41\x21\u0021\a\r\n" ; sont inclus les échappements de type C
+"Benjamin \"Bugsy\" Siegel"   ; Le backslash est le caractère d'échappement
+"Foo\tbar\41\x21\u0021\a\r\n" ; Sont inclus les échappements de type C
                               ; et unicode
 "λx:(μα.α→α).xx"              ; une chaîne peut inclure de l'unicode
 
@@ -100,7 +100,6 @@ service]. Vous pouvez joindre le traducteur de ce document ici :
 ;; 2. Variables
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Vous pouvez créer une variable à l'aide de define
-;; a variable name can use any character except: ()[]{}",'`;#|\
 ;; Une variable peut contenir n'importe quel caractères, à l'exception
 ;; de : ()[]{}",'`;#|\
 (define some-var 5)
@@ -113,7 +112,7 @@ some-var ; => 5
 ;; Accéder à une variable non-initialisée provoque une exception
 ; x ; => x: indéfini ...
 
-;; Attachement local : `me` est attaché à "Bob" seulement à l'intérieur
+;; Déclaration locale : `me` est attaché à "Bob" seulement à l'intérieur
 ;; de (let ...)
 (let ([me "Bob"])
   "Alice"
@@ -131,9 +130,9 @@ my-pet ; => #<dog>
 (dog? my-pet) ; => #t
 (dog-name my-pet) ; => "lassie"
 
-;;; Paires (non-mutable)
-;; `cons` construit une paire, `car` et `cdr` extraient respectivement les
-;; premiers et seconds éléments.
+;;; Paires (non mutable)
+;; `cons` construit une paire, `car` et `cdr` extraient respectivement le
+;; premier et le second élément.
 (cons 1 2) ; => '(1 . 2)
 (car (cons 1 2)) ; => 1
 (cdr (cons 1 2)) ; => 2
@@ -141,22 +140,22 @@ my-pet ; => #<dog>
 ;;; Listes
 
 ;; Les listes en Racket sont des structures de données de type *linked-list*,
-;; produites avec des paires assemblées avec `cons` et terminée avec `null`
+;; produites avec des paires assemblées avec `cons` et terminée par `null`
 ;; (ou '()).
 (cons 1 (cons 2 (cons 3 null))) ; => '(1 2 3)
 ;; `list` est un constructeur variadique plus commode à utiliser
 (list 1 2 3) ; => '(1 2 3)
-;; et un guillemet simple peut aussi être utilisé pour une liste litérale
+;; et un guillemet simple peut aussi être utilisé pour une liste littérale
 '(1 2 3) ; => '(1 2 3)
 
 ;; On peut toujours utiliser `cons` pour ajouter un élément au début
 ;; d'une liste
 (cons 4 '(1 2 3)) ; => '(4 1 2 3)
 
-;; Utilisez `append` pour additionner des listes entre elles
+;; Utilisez `append` pour ajouter une liste à une autre
 (append '(1 2) '(3 4)) ; => '(1 2 3 4)
 
-;; Les listes sont un type très basique, il y a donc *beaucoup* de
+;; Une liste est un type très basique, il y a donc *beaucoup* de
 ;; fonctionnalités qui leur sont dédiées, quelques exemples :
 (map add1 '(1 2 3))          ; => '(2 3 4)
 (map + '(1 2 3) '(10 20 30)) ; => '(11 22 33)
@@ -175,17 +174,17 @@ my-pet ; => #<dog>
 
 ;;; Sets
 
-;; Créew un set à partir d'une liste
+;; Créez un set à partir d'une liste
 (list->set '(1 2 3 1 2 3 3 2 1 3 2 1)) ; => (set 1 2 3)
 
 ;; Ajoutez un membre avec `set-add`
 ;; (Fonctionnel: renvoit le set étendu, plutôt que de muter le set en entrée)
 (set-add (set 1 2 3) 4) ; => (set 1 2 3 4)
 
-;; Retirer un membre avec `set-remove`
+;; Retirez un membre avec `set-remove`
 (set-remove (set 1 2 3) 1) ; => (set 2 3)
 
-;; Tester l'existence d'un membre avec `set-member?`
+;; Testez l'existence d'un membre avec `set-member?`
 (set-member? (set 1 2 3) 1) ; => #t
 (set-member? (set 1 2 3) 4) ; => #f
 
@@ -219,9 +218,8 @@ m ; => '#hash((b . 2) (a . 1) (c . 3))  <-- no `d'
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Utilisez `lambda` pour créer des fonctions.
-;; Une fonction renvoit toujours la valeur de sa dernière expression.
+;; Une fonction renvoie toujours la valeur de sa dernière expression.
 (lambda () "Hello World") ; => #<procedure>
-;; Can also use a unicode `λ'
 ;; On peut aussi utiliser le caractère unicode `λ'
 (λ () "Hello World")     ; => même fonction
 
@@ -235,10 +233,11 @@ m ; => '#hash((b . 2) (a . 1) (c . 3))  <-- no `d'
 (hello-world) ; => "Hello World"
 
 ;; Vous pouvez raccourcir ceci en utilisant le sucre syntaxique pour la
-;; définition des fonctions :
+;; définition de fonction :
 (define (hello-world2) "Hello World")
 
-;; Entre les () après lambda, vous avez la liste des arguments de la fonction
+;; Entre les () après lambda, vous déclarez la liste des arguments de la
+;; fonction
 (define hello
   (lambda (name)
     (string-append "Hello " name)))
@@ -306,7 +305,7 @@ m ; => '#hash((b . 2) (a . 1) (c . 3))  <-- no `d'
 (equal? (list 'a 'b) (list 'b 'a)) ; => #f
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; 5. Contrôle du flot
+;; 5. Structures de contrôle
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;;; Conditions
@@ -448,7 +447,7 @@ m ; => '#hash((b . 2) (a . 1) (c . 3))  <-- no `d'
 ;; 6. Mutabilité
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; Util `set!` pour réassigner une valeur à une variable existante
+;; Utilisez `set!` pour réassigner une valeur à une variable existante
 (define n 5)
 (set! n (add1 n))
 n ; => 6
@@ -503,7 +502,7 @@ vec ; => #(1 2 3 4)
     (printf fmt (make-string n ch))
     (newline)))
 
-;; Utilisez `require` pour importer les fonctions fournies par le
+;; Utilisez `require` pour importer les fonctions fournies par un
 ;; module (provide)
 (require 'cake) ; le ' est pour un sous-module local
 (print-cake 3)
@@ -537,9 +536,8 @@ vec ; => #(1 2 3 4)
 (send charlie grow 6)
 (send charlie get-size) ; => 16
 
-;; `fish%' is a plain "first class" value, which can get us mixins
 ;; `fish%` est une simple valeur de «première classe», ce qui va permettre
-;; les mélanges (*mixins*)
+;; la composition (*mixins*)
 (define (add-color c%)
   (class c%
     (init color)
-- 
cgit v1.2.3


From 071de314fd97959f6defb6fffd077cc185c9400e Mon Sep 17 00:00:00 2001
From: Yonaba <roland.yonaba@gmail.com>
Date: Mon, 30 Dec 2013 14:49:43 +0000
Subject: Added french translation  for Lua

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

(limited to 'fr-fr')

diff --git a/fr-fr/lua-fr.html.markdown b/fr-fr/lua-fr.html.markdown
new file mode 100644
index 00000000..e3979f08
--- /dev/null
+++ b/fr-fr/lua-fr.html.markdown
@@ -0,0 +1,450 @@
+---
+language: lua
+filename: learnlua-fr.lua
+contributors:
+    - ["Tyler Neylon", "http://tylerneylon.com/"]
+translators:
+    - ["Roland Yonaba", "http://github.com/Yonaba"]
+lang: fr-fr
+---
+
+```lua
+-- Les commentaires unilignes commencent par un double-tiret.
+
+--[[
+     Les doubles crochets ouverts ([[) et fermés (]]) à la suite
+     du double-tiret permettent d'avoir des commentaires
+     multilignes.
+--]]
+
+----------------------------------------------------
+-- 1. Variables et contrôle d'exécution.
+----------------------------------------------------
+
+num = 42  -- Tous les nombres sont de type double.
+-- Rassurez vous cependant, les doubles stockés sur 64-bits
+-- en réservent 52 pour la valeur exacte des entiers. La
+-- précision n'est donc pas un problème pour tout entier qui
+-- peut être codé sur moins de 52 bits.
+
+s = 'walternate'  -- Chaines de caractères immuables comme en Python.
+t = "une chaine avec des guillemets doubles"
+u = [[les double crochets permettent
+      d'avoir une chaine de caractères
+      sur plusieurs lignes.]]
+t = nil  -- Affecte la valeur nulle à t; Lua possède un ramasse-miettes
+
+-- Le do/end définit un bloc de code
+while num < 50 do
+  num = num + 1  -- Pas d'opérateurs de type ++ ou +=.
+end
+
+-- Les structures en if:
+if num > 40 then
+  print('supérieur à 40')
+elseif s ~= 'walternate' then  -- ~= : est différent de.
+  -- Le test d'égalité se fait avec == comme en Python.
+  io.write('inférieur à 40\n')  -- Ecrit par defaut sur la sortie stdout.
+else
+  -- Les variables sont globales par défaut.
+  thisIsGlobal = 5  -- le style camelCase est courant.
+
+  -- Une variable locale est déclarée avec le mot-clé local:
+  local line = io.read()  -- Permet de lire la ligne suivante dans stdin.
+
+  -- .. est l'opérateur de concaténation:
+  print("L'hiver approche, " .. line)
+end
+
+-- Les variables non définies reçoivent par défaut la valeur nil.
+foo = anUnknownVariable  -- Maintenant, foo = nil.
+
+aBoolValue = false
+
+-- Seuls nil et false sont des valeurs fausses.
+-- Mais 0 et '' sont des valeurs vraies!
+if not aBoolValue then print('etait faux') end
+
+-- L'évaluation du 'or' et du 'and' est court-circuitée.
+-- Comme avec les ternaires du C et de JS: a?b:c
+ans = aBoolValue and 'oui' or 'non'  --> 'non'
+
+karlSum = 0
+for i = 1, 100 do  -- Les bornes sont incluses dans l'intervalle.
+  karlSum = karlSum + i
+end
+
+-- Utilisez "100, 1, -1" pour la décrémentation:
+fredSum = 0
+for j = 100, 1, -1 do fredSum = fredSum + j end
+
+-- En général, l'intervalle est début, fin[, pas].
+
+-- Un autre type de boucle:
+repeat
+  print('the way of the future')
+  num = num - 1
+until num == 0
+
+
+----------------------------------------------------
+-- 2. Fonctions.
+----------------------------------------------------
+
+function fib(n)
+  if n < 2 then return n end
+  return fib(n - 2) + fib(n - 1)
+end
+
+-- Lua implémente les fermetures et les fonctions anonymes:
+function adder(x)
+  -- La fonction retournée est créée lorsque adder est appelé
+  -- et elle se rappelle de la valeur de x.
+  return function (y) return x + y end
+end
+a1 = adder(9)
+a2 = adder(36)
+print(a1(16))  --> 25
+print(a2(64))  --> 100
+
+-- Les valeurs de retour, les appels de fonction, les assignations
+-- supportent tous les listes qui peuvent ne pas correspondre en longueur.
+-- Dans ce cas, les variables à assigner en supplément recoivent nil
+-- tandis que les valeurs à attribuer en supplément sont ignorées
+
+x, y = 1, 2 -- x = 1 et y = 2
+x, y, z = 1, 2 -- x = 1, y = 2 et z = nil
+x, y, z = 1, 2, 3, 4 -- x = 1, y = 2, z = 3, et 4 est ignoré.
+
+function bar(a, b, c)
+  print(a, b, c)
+  return 4, 8, 15, 16, 23, 42
+end
+
+x, y = bar('zaphod')  --> affiche "zaphod  nil nil"
+-- x = 4, y = 8, les valeurs 15 à 42 sont ignorées.
+
+-- Les fonctions sont des valeurs de première classe 
+-- et peuvent être locales/globales.
+-- Les déclarations suivantes sont identiques:
+function f(x) return x * x end
+f = function (x) return x * x end
+
+-- Il en va de même pour les déclarations suivantes:
+local function g(x) return math.sin(x) end
+local g = function(x) return math.sin(x) end
+-- Sauf que pour le dernier cas, même si local g = function(x)
+-- est équivalent à local function g(x), il n'est pas possible
+-- de faire appel à g à l'intérieur du corps de la fonction (récursion)
+
+-- A moins de déclarer la fonction auparavant:
+local g; g  = function (x) return math.sin(x) end
+
+-- A propos, les fonctions trigonométriques interprètent 
+-- leurs arguments en radians.
+print(math.cos(math.pi)) -- affiche "-1"
+print(math.sin(math.pi)) -- affiche "0"
+
+-- Lorsqu'une fonction est appellée avec un seul argument qui est une chaine,
+-- les parenthèses peuvent être omises:
+print 'hello'  -- équivalent à print('hello').
+
+-- Lorsqu'une fonction est appellée avec un seul argument qui est une table,
+-- les parenthèses peuvent aussi être omises.
+print {} -- équivalent à print({}).
+
+
+----------------------------------------------------
+-- 3. Tables.
+----------------------------------------------------
+
+-- Tables = Seule structure de données en Lua;
+--          Ce sont des listes assotiatives.
+-- Elles sont similaires aux tables PHP ou aux objets JS :
+-- des tables-dictionnaires que l'on peut utiliser en tant que listes.
+
+-- Tables en tant que dictionnaires:
+
+-- Les clés sont des chaines de caractères par défaut:
+t = {key1 = 'valeur1', key2 = false}
+
+-- Elles peuvent être indexées avec la notation en point, comme en JS:
+print(t.key1)  -- Affiche "valeur1".
+t.newKey = {}  -- Ajoute une nouvelle paire clé/valeur.
+t.key2 = nil   -- Supprime la clé "key2" de la table.
+
+-- Notation littérale pour toute valeur non nulle en tant que clé:
+u = {['@!#'] = 'qbert', [{}] = 1729, [6.28] = 'tau'}
+print(u[6.28])  -- affiche "tau"
+
+-- La correspondance des clés se fait par valeur pour
+-- les nombres et les chaines, mais par référence pour les tables.
+a = u['@!#']  -- a = 'qbert'.
+b = u[{}]     -- On pourrait s'attendre à 1729, mais l'on obtient nil:
+-- b = nil car la clé utilisée n'est pas le même objet que celui
+-- utilisé pour stocker la valeur originale 1729.
+
+-- Si une fonction prend en argument une seule table, l'on peut
+-- omettre les parenthèses:
+function h(x) print(x.key1) end
+h{key1 = 'Sonmi~451'}  -- Affiche 'Sonmi~451'.
+
+for key, val in pairs(u) do  -- Parcours d'une table.
+  print(key, val)
+end
+
+-- _G est une table spéciale contenant toutes les variables globales,
+-- et donc elle même.
+print(_G['_G'] == _G)  -- Affiche 'true'.
+
+-- Tables en tant que listes:
+
+-- De manière implicite, les clés sont des nombres entiers:
+v = {'value1', 'value2', 1.21, 'gigawatts'}
+for i = 1, #v do  -- #v retourne la taille d'une table si elle est une liste.
+  print(v[i])  -- Attention, en Lua, les index commencent à 1!
+end
+-- Il n'existe pas vraiment de type 'liste' en Lua, v est juste
+-- une table avec des clés qui sont des nombres entiers consécutifs
+-- commençant à 1. Lua le traite comme étant une liste.
+
+----------------------------------------------------
+-- 3.1 Métatables and métaméthodes.
+----------------------------------------------------
+
+-- Une table peut avoir une métatable qui confère à la table
+-- un patron/prototype de conception (surcharge d'opération). Nous verrons
+-- dans la suite comment les métatables imitent le prototypage de JS.
+
+f1 = {a = 1, b = 2}  -- Représente la fraction a/b.
+f2 = {a = 2, b = 3}
+
+-- Ceci créée une erreur:
+-- s = f1 + f2
+
+metafraction = {}
+function metafraction.__add(f1, f2)
+  local sum = {}
+  sum.b = f1.b * f2.b
+  sum.a = f1.a * f2.b + f2.a * f1.b
+  return sum
+end
+
+setmetatable(f1, metafraction)
+setmetatable(f2, metafraction)
+
+s = f1 + f2  -- appèle __add(f1, f2) de la métatable de f1
+
+-- f1, f2 ne possède pas de clé qui pointent vers leur métatable, comme
+-- avec les prototypes en JS. Mais l'on peut utiliser getmetatable(f1).
+-- La métatable est une table normale avec des clés prédéfinie, comme __add.
+
+-- Mais la ligne suivante génère une erreur puisque s n'a pas de métatable:
+-- t = s + s
+-- En implémentant de l'orienté-objet, comme nous le verrons dans la suite,
+-- le problème est résolu.
+
+-- Une clé __index dans une métatable mt surcharge l'indexation dans sa table t
+-- si la clé est absente de cette table t:
+defaultFavs = {animal = 'gru', food = 'donuts'}
+myFavs = {food = 'pizza'}
+setmetatable(myFavs, {__index = defaultFavs})
+eatenBy = myFavs.animal  -- Affiche "gru"! merci à la métatable!
+
+-- Ainsi donc, un accès direct à une valeur dans une table via une clé 
+-- inexistante (ce qui normalement retourne "nil") conduira à exploiter
+-- le champ __index de la métatable. Cela peut être récursif.
+
+-- Le champ __index peut aussi être une fonction (tbl, clé)
+-- ce qui permet une gestion plus souple des indexations.
+
+-- Les clés __index, __add,... sont appelées métaméthodes.
+-- En voici la liste complète:
+
+-- __add(a, b)                   pour a + b
+-- __sub(a, b)                   pour a - b
+-- __mul(a, b)                   pour a * b
+-- __div(a, b)                   pour a / b
+-- __mod(a, b)                   pour a % b
+-- __pow(a, b)                   pour a ^ b
+-- __unm(a)                      pour -a
+-- __concat(a, b)                pour a .. b
+-- __len(a)                      pour #a
+-- __eq(a, b)                    pour a == b
+-- __lt(a, b)                    pour a < b
+-- __le(a, b)                    pour a <= b
+-- __index(a, b)  <fn ou table>  pour a.b
+-- __newindex(a, b, c)           pour a.b = c
+-- __call(a, ...)                pour a(...)
+
+----------------------------------------------------
+-- 3.2 Pseudo-orienté objet et héritage.
+----------------------------------------------------
+
+-- Lua n'implémente pas d'orienté objet par défaut.
+-- Mais il reste possible d'imiter de plusieurs manières 
+-- le concept de "classe" grâce aux tables et aux métatables.
+
+-- L'explication pour l'exemple qui suit vient juste après.
+
+Dog = {}                                   -- 1.
+
+function Dog:new()                         -- 2.
+  local newObj = {sound = 'woof'}          -- 3.
+  self.__index = self                      -- 4.
+  return setmetatable(newObj, self)        -- 5.
+end
+
+function Dog:makeSound()                   -- 6.
+  print('Je dis: ' .. self.sound..'!')
+end
+
+mrDog = Dog:new()                          -- 7.
+mrDog:makeSound()  -- 'Je dis: woof!       -- 8.
+
+-- 1. Dog agit comme une classe; c'est une simple table.
+-- 2. L'expression tbl:fn(...) est identique à 
+--    tbl.fn(self, ...)
+--    La notation : permet de passer par défaut un premier 
+--    argument appellé "self" à la fonction tbl.fn
+--    Voir 7 & 8 ci-après pour comprendre comment self prend
+--    sa valeur.
+-- 3. newObj sera une instance de la classe Dog.
+-- 4. self = la classe instanciée. Souvent, self = Dog, mais
+--    cela peut changer du fait de l'héritage.
+--    newObj reçoit les fonctions de self si l'__index des
+--    métatables de newObj et de self pointent vers self.
+-- 5. Rappel: setmetatable retourne son premier argument.
+-- 6. La notation : fonctionne comme au 2, mais cette fois, self
+--    est une instance au lieu d'être une classe.
+-- 7. Similaire à Dog.new(Dog), donc self = Dog dans new().
+-- 8. Similaire à mrDog.makeSound(mrDog); self = mrDog.
+
+----------------------------------------------------
+
+-- Exemple d'héritage:
+
+LoudDog = Dog:new()                           -- 1.
+
+function LoudDog:makeSound()
+  local s = self.sound .. ' '                 -- 2.
+  print(s .. s .. s..'!')
+end
+
+seymour = LoudDog:new()                       -- 3.
+seymour:makeSound()  -- 'woof woof woof!'     -- 4.
+
+-- 1. LoudDog reçoit les méthodes et les variables de Dog.
+-- 2. self possède une clé 'sound', reçue de new(), voir 3.
+-- 3. Similaire à LoudDog.new(LoudDog) et traduit en Dog.new(LoudDog),
+--    puisque LoudDog ne possède pas de clé 'new', mais a une métatable
+--    qui a la clé __index = Dog.
+--    Résulat: la métatable de seymour est LoudDog, et
+--    LoudDog.__index = LoudDog. Donc seymour.key deviendra soit égal à
+--    seymour.key, LoudDog.key, Dog.key, selon le fait qu'il s'agira
+--    de la première table ayant la clé 'key' en question, en remontant
+--    dans la hiérarchie.
+-- 4. La clé 'makeSound' est trouvée dans LoudDog; cela est similaire
+--    à LoudDog.makeSound(seymour).
+
+-- Si besoin est, la méthode new() de la sous-classe est
+-- identique à la méthode new() de sa classe mère:
+function LoudDog:new()
+  local newObj = {}
+  -- Prépare self à être la superclasse de newObj:
+  self.__index = self
+  return setmetatable(newObj, self)
+end
+
+----------------------------------------------------
+-- 4. Modules.
+----------------------------------------------------
+
+
+--[[ Cette section est mise en commentaire afin que le reste du
+--   ce script reste exécutable.
+```
+
+```lua
+-- Supposons que le fichier mod.lua contienne ceci:
+local M = {}
+
+local function sayMyName()
+  print('Hrunkner')
+end
+
+function M.sayHello()
+  print('hello')
+  sayMyName()
+end
+
+return M
+
+--  Un autre fichier peut exploiter le contenu défini dans mod.lua's:
+local mod = require('mod')  -- Exécute le fichier mod.lua.
+
+-- require est le moyen par défaut d'inclure des modules.
+-- require  agit comme:     (si non trouvé en cache; voir ci-après)
+local mod = (function ()
+  <contenu de mod.lua>
+end)()
+-- Comme si le contenu de mod.lua est enveloppé dans le corps d'une fonction,
+-- si bien que les variables locales contenues dans mod.lua deviennent 
+-- inaccessibles en dehors de ce module.
+
+-- Le code suivant fonctionne car mod = M (dans mod.lua):
+mod.sayHello()  -- Dis bonjour à Hrunkner.
+
+-- Le code suivant génère une erreur car sayMyName est local à mod.lua:
+mod.sayMyName()  -- erreur!
+
+-- Les valeurs retournées par require sont mises en cache, ce qui fait
+-- qu'un module est toujours chargé une seule fois, même s'il est inclus
+-- avec require à plusieurs reprises.
+
+-- Supposons que mod2.lua contienne le code "print('Hi!')".
+local a = require('mod2')  -- Affiche "Hi!"
+local b = require('mod2')  -- N'affiche rien; et a = b.
+
+-- dofile est identique à require, sauf qu'il ne fait pas de mise en cache:
+dofile('mod2')  --> Hi!
+dofile('mod2')  --> Hi! (le code de mod2.lua est encore exécuté)
+
+-- loadfile charge le contenu d'un fichier, sans l'exécuter.
+f = loadfile('mod2')  -- L'appel f() exécute le contenu de mod2.lua.
+
+-- loadstring est similaire à loadfile, mais pour les chaines de caractères.
+g = loadstring('print(343)')  -- Retourne une fonction.
+g()  -- Affiche 343; Rien n'est affiché avant cet appel.
+
+--]]
+
+```
+## Références
+
+*Les références qui suivent sont en Anglais.*
+
+Les sujets non abordés dans ce tutoriel sont couverts en intégralité par 
+les librairies standard:
+
+* <a href="http://lua-users.org/wiki/StringLibraryTutorial">la librairie string</a>
+* <a href="http://lua-users.org/wiki/TableLibraryTutorial">la librairie table</a>
+* <a href="http://lua-users.org/wiki/MathLibraryTutorial">la librairie math</a>
+* <a href="http://lua-users.org/wiki/IoLibraryTutorial">la librairie io</a>
+* <a href="http://lua-users.org/wiki/OsLibraryTutorial">la librairie os</a>
+
+Autres références complémentaires:
+
+* <a href="http://nova-fusion.com/2012/08/27/lua-for-programmers-part-1/">Lua for programmers</a>
+* <a href="lua-users.org/files/wiki_insecure/users/thomasl/luarefv51.pdf">Courte de référence de Lua</a>
+* <a href="http://www.lua.org/pil/contents.html">Programming In Lua</a>
+* <a href="http://www.lua.org/manual/">Les manuels de référence Lua</a>
+
+A propos, ce fichier est exécutable. Sauvegardez-le sous le nom learn.lua et
+exécutez-le avec la commande "lua learn.lua" !
+
+Ce tutoriel a été originalement écrit pour <a href="tylerneylon.com">tylerneylon.com</a> et est aussi 
+disponible en tant que <a href="https://gist.github.com/tylerneylon/5853042">gist</a>.
+Il a été traduit en français par Roland Yonaba (voir son <a href="http://github.com/Yonaba">github</a>).
+
+Amusez-vous bien avec Lua!
\ No newline at end of file
-- 
cgit v1.2.3


From bb673a40a9779a8abe9e3a430160f58670e01a5b Mon Sep 17 00:00:00 2001
From: Yonaba <roland.yonaba@gmail.com>
Date: Mon, 30 Dec 2013 14:54:30 +0000
Subject: Bit of prettification

---
 fr-fr/lua-fr.html.markdown | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/lua-fr.html.markdown b/fr-fr/lua-fr.html.markdown
index e3979f08..63b65c38 100644
--- a/fr-fr/lua-fr.html.markdown
+++ b/fr-fr/lua-fr.html.markdown
@@ -12,9 +12,8 @@ lang: fr-fr
 -- Les commentaires unilignes commencent par un double-tiret.
 
 --[[
-     Les doubles crochets ouverts ([[) et fermés (]]) à la suite
-     du double-tiret permettent d'avoir des commentaires
-     multilignes.
+     Les doubles crochets à la suite du double-tiret 
+     permettent d'insérer des commentaires multilignes.
 --]]
 
 ----------------------------------------------------
@@ -427,11 +426,11 @@ g()  -- Affiche 343; Rien n'est affiché avant cet appel.
 Les sujets non abordés dans ce tutoriel sont couverts en intégralité par 
 les librairies standard:
 
-* <a href="http://lua-users.org/wiki/StringLibraryTutorial">la librairie string</a>
-* <a href="http://lua-users.org/wiki/TableLibraryTutorial">la librairie table</a>
-* <a href="http://lua-users.org/wiki/MathLibraryTutorial">la librairie math</a>
-* <a href="http://lua-users.org/wiki/IoLibraryTutorial">la librairie io</a>
-* <a href="http://lua-users.org/wiki/OsLibraryTutorial">la librairie os</a>
+* La librairie <a href="http://lua-users.org/wiki/StringLibraryTutorial">string</a>
+* La librairie <a href="http://lua-users.org/wiki/TableLibraryTutorial">table</a>
+* La librairie <a href="http://lua-users.org/wiki/MathLibraryTutorial">math</a>
+* La librairie <a href="http://lua-users.org/wiki/IoLibraryTutorial">io</a>
+* La librairie <a href="http://lua-users.org/wiki/OsLibraryTutorial">os</a>
 
 Autres références complémentaires:
 
@@ -440,8 +439,8 @@ Autres références complémentaires:
 * <a href="http://www.lua.org/pil/contents.html">Programming In Lua</a>
 * <a href="http://www.lua.org/manual/">Les manuels de référence Lua</a>
 
-A propos, ce fichier est exécutable. Sauvegardez-le sous le nom learn.lua et
-exécutez-le avec la commande "lua learn.lua" !
+A propos, ce fichier est exécutable. Sauvegardez-le sous le nom *learn.lua* et
+exécutez-le avec la commande `lua learn.lua` !
 
 Ce tutoriel a été originalement écrit pour <a href="tylerneylon.com">tylerneylon.com</a> et est aussi 
 disponible en tant que <a href="https://gist.github.com/tylerneylon/5853042">gist</a>.
-- 
cgit v1.2.3


From a0ee6f45a973092ef58b08759c0300a2ce772e00 Mon Sep 17 00:00:00 2001
From: Yonaba <roland.yonaba@gmail.com>
Date: Mon, 30 Dec 2013 15:35:44 +0000
Subject: Fixed a lot of typos (thanks @Nami-Doc for the proofreading)

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

(limited to 'fr-fr')

diff --git a/fr-fr/lua-fr.html.markdown b/fr-fr/lua-fr.html.markdown
index 63b65c38..8535848a 100644
--- a/fr-fr/lua-fr.html.markdown
+++ b/fr-fr/lua-fr.html.markdown
@@ -9,10 +9,10 @@ lang: fr-fr
 ---
 
 ```lua
--- Les commentaires unilignes commencent par un double-tiret.
+-- Les commentaires unilignes commencent par un double tiret.
 
 --[[
-     Les doubles crochets à la suite du double-tiret 
+     Les doubles crochets à la suite du double tiret 
      permettent d'insérer des commentaires multilignes.
 --]]
 
@@ -43,7 +43,7 @@ if num > 40 then
   print('supérieur à 40')
 elseif s ~= 'walternate' then  -- ~= : est différent de.
   -- Le test d'égalité se fait avec == comme en Python.
-  io.write('inférieur à 40\n')  -- Ecrit par defaut sur la sortie stdout.
+  io.write('inférieur à 40\n')  -- Écrit par defaut sur la sortie stdout.
 else
   -- Les variables sont globales par défaut.
   thisIsGlobal = 5  -- le style camelCase est courant.
@@ -64,8 +64,8 @@ aBoolValue = false
 -- Mais 0 et '' sont des valeurs vraies!
 if not aBoolValue then print('etait faux') end
 
--- L'évaluation du 'or' et du 'and' est court-circuitée.
--- Comme avec les ternaires du C et de JS: a?b:c
+-- L'évaluation du 'or' et du 'and' est court-circuité.
+-- Comme avec les ternaires du C et du JS: a?b:c
 ans = aBoolValue and 'oui' or 'non'  --> 'non'
 
 karlSum = 0
@@ -108,7 +108,7 @@ print(a2(64))  --> 100
 
 -- Les valeurs de retour, les appels de fonction, les assignations
 -- supportent tous les listes qui peuvent ne pas correspondre en longueur.
--- Dans ce cas, les variables à assigner en supplément recoivent nil
+-- Dans ce cas, les variables à assigner en supplément reçoivent nil
 -- tandis que les valeurs à attribuer en supplément sont ignorées
 
 x, y = 1, 2 -- x = 1 et y = 2
@@ -120,7 +120,7 @@ function bar(a, b, c)
   return 4, 8, 15, 16, 23, 42
 end
 
-x, y = bar('zaphod')  --> affiche "zaphod  nil nil"
+x, y = bar('zaphod')  --> affiche "zaphod nil nil"
 -- x = 4, y = 8, les valeurs 15 à 42 sont ignorées.
 
 -- Les fonctions sont des valeurs de première classe 
@@ -136,19 +136,19 @@ local g = function(x) return math.sin(x) end
 -- est équivalent à local function g(x), il n'est pas possible
 -- de faire appel à g à l'intérieur du corps de la fonction (récursion)
 
--- A moins de déclarer la fonction auparavant:
+-- À moins de déclarer la fonction auparavant:
 local g; g  = function (x) return math.sin(x) end
 
--- A propos, les fonctions trigonométriques interprètent 
+-- À propos, les fonctions trigonométriques interprètent 
 -- leurs arguments en radians.
 print(math.cos(math.pi)) -- affiche "-1"
 print(math.sin(math.pi)) -- affiche "0"
 
--- Lorsqu'une fonction est appellée avec un seul argument qui est une chaine,
+-- Lorsqu'une fonction est appelée avec un seul argument qui est une chaine,
 -- les parenthèses peuvent être omises:
 print 'hello'  -- équivalent à print('hello').
 
--- Lorsqu'une fonction est appellée avec un seul argument qui est une table,
+-- Lorsqu'une fonction est appelée avec un seul argument qui est une table,
 -- les parenthèses peuvent aussi être omises.
 print {} -- équivalent à print({}).
 
@@ -200,8 +200,8 @@ print(_G['_G'] == _G)  -- Affiche 'true'.
 
 -- De manière implicite, les clés sont des nombres entiers:
 v = {'value1', 'value2', 1.21, 'gigawatts'}
-for i = 1, #v do  -- #v retourne la taille d'une table si elle est une liste.
-  print(v[i])  -- Attention, en Lua, les index commencent à 1!
+for i = 1, #v do  -- #v retourne la taille de la table v si elle est une liste.
+  print(v[i])  -- Attention, en Lua, les indices commencent à 1!
 end
 -- Il n'existe pas vraiment de type 'liste' en Lua, v est juste
 -- une table avec des clés qui sont des nombres entiers consécutifs
@@ -213,7 +213,7 @@ end
 
 -- Une table peut avoir une métatable qui confère à la table
 -- un patron/prototype de conception (surcharge d'opération). Nous verrons
--- dans la suite comment les métatables imitent le prototypage de JS.
+-- dans la suite comment les métatables imitent le prototypage du JS.
 
 f1 = {a = 1, b = 2}  -- Représente la fraction a/b.
 f2 = {a = 2, b = 3}
@@ -236,11 +236,11 @@ s = f1 + f2  -- appèle __add(f1, f2) de la métatable de f1
 
 -- f1, f2 ne possède pas de clé qui pointent vers leur métatable, comme
 -- avec les prototypes en JS. Mais l'on peut utiliser getmetatable(f1).
--- La métatable est une table normale avec des clés prédéfinie, comme __add.
+-- La métatable est une table normale avec des clés prédéfinies, comme __add.
 
 -- Mais la ligne suivante génère une erreur puisque s n'a pas de métatable:
 -- t = s + s
--- En implémentant de l'orienté-objet, comme nous le verrons dans la suite,
+-- En implémentant de l'orienté objet, comme nous le verrons par la suite,
 -- le problème est résolu.
 
 -- Une clé __index dans une métatable mt surcharge l'indexation dans sa table t
@@ -305,7 +305,7 @@ mrDog:makeSound()  -- 'Je dis: woof!       -- 8.
 -- 2. L'expression tbl:fn(...) est identique à 
 --    tbl.fn(self, ...)
 --    La notation : permet de passer par défaut un premier 
---    argument appellé "self" à la fonction tbl.fn
+--    argument appelé "self" à la fonction tbl.fn
 --    Voir 7 & 8 ci-après pour comprendre comment self prend
 --    sa valeur.
 -- 3. newObj sera une instance de la classe Dog.
@@ -383,12 +383,12 @@ return M
 local mod = require('mod')  -- Exécute le fichier mod.lua.
 
 -- require est le moyen par défaut d'inclure des modules.
--- require  agit comme:     (si non trouvé en cache; voir ci-après)
+-- require agit comme:     (si non trouvé en cache; voir ci-après)
 local mod = (function ()
   <contenu de mod.lua>
 end)()
--- Comme si le contenu de mod.lua est enveloppé dans le corps d'une fonction,
--- si bien que les variables locales contenues dans mod.lua deviennent 
+-- Comme si le contenu de mod.lua était enveloppé dans le corps d'une fonction,
+-- si bien que les variables locales contenues dans mod.lua sont 
 -- inaccessibles en dehors de ce module.
 
 -- Le code suivant fonctionne car mod = M (dans mod.lua):
-- 
cgit v1.2.3


From f3d043f7b8d8e318557eabd0a9cdac05bc39779d Mon Sep 17 00:00:00 2001
From: Yonaba <roland.yonaba@gmail.com>
Date: Mon, 30 Dec 2013 15:50:33 +0000
Subject: Typo fix, again

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

(limited to 'fr-fr')

diff --git a/fr-fr/lua-fr.html.markdown b/fr-fr/lua-fr.html.markdown
index 8535848a..922d6ebc 100644
--- a/fr-fr/lua-fr.html.markdown
+++ b/fr-fr/lua-fr.html.markdown
@@ -234,7 +234,7 @@ setmetatable(f2, metafraction)
 
 s = f1 + f2  -- appèle __add(f1, f2) de la métatable de f1
 
--- f1, f2 ne possède pas de clé qui pointent vers leur métatable, comme
+-- f1, f2 ne possèdent pas de clé qui pointent vers leur métatable, comme
 -- avec les prototypes en JS. Mais l'on peut utiliser getmetatable(f1).
 -- La métatable est une table normale avec des clés prédéfinies, comme __add.
 
-- 
cgit v1.2.3


From 84b7e2ccd6ac9f9641edeb30f2c0ed22e18b0666 Mon Sep 17 00:00:00 2001
From: Yannick <yannick.loriot@gmail.com>
Date: Sat, 11 Jan 2014 22:31:22 +0100
Subject: [ADD] Translation in french of the first part

---
 fr-fr/objective-c.html.markdown | 509 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 509 insertions(+)
 create mode 100644 fr-fr/objective-c.html.markdown

(limited to 'fr-fr')

diff --git a/fr-fr/objective-c.html.markdown b/fr-fr/objective-c.html.markdown
new file mode 100644
index 00000000..b6567382
--- /dev/null
+++ b/fr-fr/objective-c.html.markdown
@@ -0,0 +1,509 @@
+---
+
+language: Objective-C
+contributors:
+    - ["Eugene Yagrushkin", "www.about.me/yagrushkin"]
+    - ["Yannick Loriot", "https://github.com/YannickL"]
+    - ["Levi Bostian", "https://github.com/levibostian"]
+translators:
+    - ["Yannick Loriot", "https://github.com/YannickL"]
+filename: LearnObjectiveC.m
+
+---
+
+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 framworks respectifs, Cocoa et Cocoa Touch.
+
+```objective-c
+// Les commentaires unilignes commencent par //
+
+/*
+Les commentaires multilignes ressemblent à ça
+*/
+
+// Importe les en-têtes en utilisant #import
+// Utilisez <> pour importer des fichiers globaux (en général des frameworks)
+// Utilisez "" pour importer des fichiers locaux (du projet)
+#import <Foundation/Foundation.h>
+#import "MaClasse.h"
+
+// Si vous activez les modules pour les projects iOS >= 7 ou Mac OS X >= 10.9
+// dans Xcode 5 vous pouvez importer les frameworks comme cela :
+@import Foundation;
+
+// Le point d'entrée de votre programme est une fonction qui s'appelle main
+// et qui return un entier comme type
+int main (int argc, const char * argv[])
+{
+    // Créer un groupe de libération automatique de la mémoire pour l'ensemble
+    // du programme
+    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
+    // Si vous utilisez le comptage de référence automatique (ARC), utilisez
+    // @autoreleasepool à la place :
+    @autoreleasepool {
+
+    // Utilisez NSLog pour afficher les lignes sur la console
+    // Affiche la chaine de caractères "Bonjour Tous Le Monde !"
+    NSLog(@"Bonjour tous le Monde !"); 
+ 
+    ///////////////////////////////////////
+    // Les Types & Les Variables
+    ///////////////////////////////////////
+    
+    // Déclarations de primitive
+    int maPrimitive1  = 1;
+    long maPrimitive2 = 234554664565;
+    
+    // Declarations d'objets
+    // Il faut mettre l'* devant la déclaration d'objets fortement typés
+    MaClasse *monObject1 = nil;  // Typage fort
+    id       monObject2  = nil;  // Typage faible
+    // %@ est un objet
+    // 'description' est une convention pour afficher la valeur des objets
+    NSLog(@"%@ and %@", monObject1, [monObject2 description]); // Affiche "(null) et (null)"
+    
+    // Chaines de caractères
+    NSString *chaineMonde = @"Monde";
+    NSLog(@"Bonjour tous le %@ !", chaineMonde); // affiche => "Bonjour Tous Le Monde !" 
+    // NSMutableString est une chaine mutable
+    NSMutableString *chaineMutable = [NSMutableString stringWithString:@"Bonjour tous le"];
+    [chaineMutable appendString:@" Monde !"];
+    NSLog(@"%@", chaineMutable); // affiche => "Bonjour Tous Le Monde !"
+    
+    // Les littéraux pour les caratères
+    NSNumber *laLettreZSousFormeDeNombre = @'Z';
+    char laLettreZ                       = [laLettreZSousFormeDeNombre charValue]; // ou 'Z'
+    NSLog(@"%c", laLettreZ);
+
+    // Les littéraux pour les nombres
+    NSNumber *nombreQuaranteDeux = @42;
+    int quaranteDeux             = [nombreQuaranteDeux intValue]; // ou 42
+    NSLog(@"%i", quaranteDeux);
+    
+    NSNumber *nombreQuaranteDeuxnonSigne = @42U;
+    unsigned int quaranteDeuxnonSigne    = [nombreQuaranteDeuxnonSigne unsignedIntValue];
+    NSLog(@"%u", fortyTwoUnsigned);
+    
+    NSNumber *nombreQuaranteDeuxCourt = [NSNumber numberWithShort:42];
+    short quaranteDeuxCourt           = [nombreQuaranteDeuxCourt shortValue]; // ou 42
+    NSLog(@"%hi", fortyTwoShort);
+    
+    NSNumber *nombreQuaranteDeuxLong = @42L;
+    long quaranteDeuxLong            = [nombreQuaranteDeuxLong longValue]; // ou 42
+    NSLog(@"%li", fortyTwoLong);
+
+    // Les littéraux pour les flottans
+    NSNumber *nombrePiFlottan = @3.141592654F;
+    float piFlottan           = [nombrePiFlottan floatValue]; // ou 3.141592654f
+    NSLog(@"%f", piFlottan); // affiche => 3.141592654
+    NSLog(@"%5.2f", piFlottan); // affiche => " 3.14"
+    
+    NSNumber *nombrePiDouble = @3.1415926535;
+    double piDouble          = [nombrePiDouble doubleValue]; // ou 3.1415926535
+    NSLog(@"%f", piDouble);
+    NSLog(@"%4.2f", piDouble); // affiche => "3.14"
+
+    // NSDecimalNumber est une classe pour avoir plus de précision sur les flottans
+    // et les doubles
+    NSDecimalNumber *decNumUn   = [NSDecimalNumber decimalNumberWithString:@"10.99"];
+    NSDecimalNumber *decNumDeux = [NSDecimalNumber decimalNumberWithString:@"5.002"];
+    // NSDecimalNumber n'est pas capable d'utiliser les opérations standards : 
+    // +, -, *, /, il utilise donc ses propres fonctions :
+    [decNumUn decimalNumberByAdding:decNumDeux]; 
+    [decNumUn decimalNumberBySubtracting:decNumDeux];
+    [decNumUn decimalNumberByMultiplyingBy:decNumDeux];
+    [decNumUn decimalNumberByDividingBy:decNumDeux];
+    NSLog(@"%@", decNumUn); // affiche => 10.99 comme NSDecimalNumber is immuable
+
+    // Les littéraux pour les booléens
+    NSNumber *ouiNumber = @YES;
+    NSNumber *nonNumber = @NO;
+    // ou
+    BOOL ouiBool = YES;
+    BOOL nonBool  = NO;
+    NSLog(@"%i", ouiBool); // affiche => 1
+
+    // Les listes
+    // Ils peuvent contenir différents types de données, mais ils doivent absolument 
+    // être des objets
+    NSArray *uneListe         = @[@1, @2, @3, @4];
+    NSNumber *troisiemeNombre = uneListe[2];
+    NSLog(@"Troisième nombre = %@", troisiemeNombre); // affiche "Troisième nombre = 3"
+    // NSMutableArray est une version mutable de NSArray qui permet de changer les
+    // objets dans la liste et l'étendre ou  la réduire
+    // C'est très pratique, mais pas aussi performant que l'utilsation de la classe
+    // NSArray
+    NSMutableArray *listeMutable = [NSMutableArray arrayWithCapacity:2];
+    [listeMutable addObject:@"Bonjour tous le"];
+    [listeMutable addObject:@"Monde"];
+    [listeMutable removeObjectAtIndex:0];
+    NSLog(@"%@", [listeMutable objectAtIndex:0]); // affiche => "Monde"
+
+    // Les dictionnaires
+    NSDictionary *unDictionnaire = @{ @"cle1" : @"valeur1", @"cle2" : @"valeur2" };
+    NSObject *valeur             = unDictionnaire[@"Une clé"];
+    NSLog(@"Objet = %@", valeur); // affiche "Objet = (null)"
+    // NSMutableDictionary est un dictionnaire mutable
+    NSMutableDictionary *dictionnaireMutable = [NSMutableDictionary dictionaryWithCapacity:2];
+    [dictionnaireMutable setObject:@"valeur1" forKey:@"cle1"];
+    [dictionnaireMutable setObject:@"valeur2" forKey:@"cle2"];
+    [dictionnaireMutable removeObjectForKey:@"cle1"];
+
+    // Les ensembles
+    NSSet *ensemble = [NSSet setWithObjects:@"Salut", @"Salut", @"Monde", nil];
+    NSLog(@"%@", ensemble); // affiche => {(Salut, Monde)} (peut être dans un ordre différente)
+    // NSMutableSet est un ensemble mutable 
+    NSMutableSet *ensembleMutable = [NSMutableSet setWithCapacity:2];
+    [ensembleMutable addObject:@"Salut"];
+    [ensembleMutable addObject:@"Salut"];
+    NSLog(@"%@", ensembleMutable); // affiche => {(Salut)}
+
+    ///////////////////////////////////////
+    // Operateurs
+    ///////////////////////////////////////
+    
+    // Les opérateurs sont les mêmes que ceux du langage C
+    // Par exemple :
+    2 + 5; // => 7
+    4.2f + 5.1f; // => 9.3f
+    3 == 2; // => 0 (NO)
+    3 != 2; // => 1 (YES)
+    1 && 1; // => 1 (et logique)
+    0 || 1; // => 1 (ou logique)
+    ~0x0F; // => 0xF0 (négation bit à bit)
+    0x0F & 0xF0; // => 0x00 (et bit à bit)
+    0x01 << 1; // => 0x02 (décale à gauche (par 1))
+
+    ///////////////////////////////////////
+    // Structures de controle
+    ///////////////////////////////////////
+
+    // Expression If-Else 
+    if (NO)
+    {
+        NSLog(@"Je ne suis jamais affiché");
+    } else if (0)
+    {
+        NSLog(@"Je ne suis jamais affiché aussi");
+    } else
+    {
+        NSLog(@"Je suis affiché");
+    }
+
+    // Expression Switch
+    switch (2)
+    {
+        case 0:
+        {
+            NSLog(@"Je ne suis jamais affiché");
+        } break;
+        case 1:
+        {
+            NSLog(@"Je ne suis jamais affiché aussi");
+        } break;
+        default:
+        {
+            NSLog(@"Je suis affiché");
+        } break;
+    }
+    
+    // Expression de boucle While
+    int ii = 0;
+    while (ii < 4)
+    {
+        NSLog(@"%d,", ii++); // ii++ incrémente ii après avoir utilisé sa valeure
+    } // => affiche "0," 
+      //            "1,"
+      //            "2,"
+      //            "3,"
+
+    // Expression de boucle For loops
+    int jj;
+    for (jj=0; jj < 4; jj++)
+    {
+        NSLog(@"%d,", jj);
+    } // => affiche "0," 
+      //            "1,"
+      //            "2,"
+      //            "3,"
+     
+    // Expression de boucle Foreach
+    NSArray *valeurs = @[@0, @1, @2, @3];
+    for (NSNumber *valeur in valeurs)
+    {
+        NSLog(@"%@,", valeur);
+    } // => affiche "0," 
+      //            "1,"
+      //            "2,"
+      //            "3,"
+
+    // Expressions Try-Catch-Finally
+    @try
+    {
+        @throw [NSException exceptionWithName:@"FileNotFoundException"
+                            reason:@"Fichier non trouvé" userInfo:nil];
+    } @catch (NSException * e)
+    {
+        NSLog(@"Exception : %@", e);
+    } @finally
+    {
+        NSLog(@"Finalement");
+    } // => affiche "Exceptio : Fichier non trouvé"
+      //            "Finalement"
+ 
+    ///////////////////////////////////////
+    // Objets
+    ///////////////////////////////////////
+    
+    // Créez une instance d'objet en allouant un espace mémoire puis en l'initialisant
+    // Un objet n'est pas complétement fonctionnel jusqu'à ce que les deux étapes précédente
+    // ne sont pas fini
+    MaClass *monObjet = [[MaClass alloc] init];
+        
+    // Le modèle Objective-C est basé sur l'envoie de message et non sur les appels de
+    // méthodes comme la plupart des autres langage de programmation
+    [myObject instanceMethodWithParameter:@"Steve Jobs"];
+
+    // Nettoie la mémoire que vous avez utilisé dans votre programme
+    [pool drain];
+
+    // Fin the l'@autoreleasepool
+    }
+    
+    // Fin du programme
+    return 0;
+}
+
+///////////////////////////////////////
+// Classes et Fonctions
+///////////////////////////////////////
+
+// Déclarez votre classe dans une en-tête de fichier (MaClasse.h) :
+// La syntaxe de déclaration :
+// @interface NomDeLaClasse : NomDeLaClasseParent <ProtocolesImplemente>
+// {
+//    type nom; <= declarations de variable;
+// }
+// @property type nom; <= declarations de propriété.
+// -/+ (type) Methode declarations; <= Declarations de methodes. 
+// @end
+// NSObject est la classe de base de l'Objective-C
+@interface MaClasse : NSObject <MonProtocole>
+{
+    // Déclaration des variables d'instances (peut existé soit dans l'interface soir dans 
+    // l'implémentation)
+    int nombre; // Accès protégé par défaut
+    @private id donnee; // Accès privé (il est plus pratique de le faire dans l'implémentation)
+    NSString *nom; 
+}
+// Notation pratique pour l'accès aux variable public et pour générrer les 
+// accésseurs/affecteurs
+// Par défaut, le nom de l'affecteur vaut 'set' suivi par le nom de la @property
+@property int propInt; // Nom du setter = 'setPropInt'
+@property (copy) id copyId; // (copy) => Copie l'objet pendant l'affectation
+// (readonly) => Ne peut pas affecté la variable en dehors de l'@interface
+// Utilisez @synthesize dans l'@implementation pour créer l'accésseur
+@property (readonly) NSString *roString;
+// Vous pouvez personnaliser les noms des accésseurs et des affecteurs au lieu d'utiliser les
+// noms par défauts
+@property (getter=longeurGet, setter=longeurSet:) int longeur;
+ 
+// Methodes
++/- (type de retour)signatureDeLaMethode:(Type Du Parametre *)nomDuParametre;
+
+// + pour les méthodes de classe :
++ (NSString *)methodeDeClasse;
++ (MaClasse *)maClasseDepuisLaHauteur:(NSNumber *)hauteurParDefaut;
+
+// - pour les méthodes d'instances :
+- (NSString *)methodeInstanceAvecUnParametre:(NSString *)string;
+- (NSNumber *)methodeInstanceAvecUnParametre:(NSString*)string puisUnDeuxieme:(NSNumber *)number;
+
+// Contructeur avec des arguments :
+- (id)initAvecDistance:(int)distanceParDefault;
+// Les méthodes en Objective-C sont très descriptive
+
+@end // Définit la fin de l'interface
+
+
+// Exemple d'utilisation de MaClasse
+MaClasse *maClasse = [[MaClasse alloc] init]; // créer une instance de MaClasse
+[maClasse setNombre:10]; 
+NSLog(@"%d", [maClasse nombre]); // affiche => 10
+[myClass longeurSet:32];
+NSLog(@"%i", [maClasse longeurGet]); // affiche => 32
+// Pour des raisons pratiques vous pouvez aussi utiliser la notation en point pour accéder aux 
+// variables d'instances :
+maClasse.nombre = 45;
+NSLog(@"%i", maClasse.nombre); // maClasse => 45
+
+// Appeler un méthode de classe :
+NSString *s1 = [MaClasse methodeDeClasse];
+MaClasse *m2 = [MaClasse maClasseDepuisLaHauteur:38];
+
+// Appeler un méthode d'instance :
+MaClasse *maClasse = [[MaClasse alloc] init]; // Créer une instance de MaClasse
+NSString *stringDepuisUneInstanceDeMethode = [maClasse methodeInstanceAvecUnParametre:@"Salut"];
+
+// Sélecteurs sont un moyen de représenté les méthodes dynamiquement
+// Ils sont utilisé pour appeller des méthodes de classe, passer des methodes au travers de fonctions
+// pour notifier les autres classes qu'elle peuvent les appellé, et pour sauvegarder les méthodes en
+// tant que variables
+// SEL est un type de donnée. @selected retourne un selecteur à partir d'un nom de methode
+SEL selecteur = @selector(methodeInstanceAvecUnParametre:puisUnDeuxieme:); 
+if ([maClasse respondsToSelector:selecteur]) { // Vérifie si la classe contient la méthode
+    // Doit mettre tous les arguments de la méthode dans un seul objet pour l'envoyer via la fonction
+    // performSelector:withObject: 
+    NSArray *arguments = [NSArray arrayWithObjects:@"Hello", @4, nil];
+    [myClass performSelector:selectorVar withObject:arguments]; // Appele la méthode
+} else {
+    // NSStringFromSelector() retourne une chaine de charactères à partir d'un sélecteur
+    NSLog(@"MaClasse ne possède pas de méthode : %@", NSStringFromSelector(selecteur));
+}
+
+// Implement la méthode dans le fichier d'impémentation (MaClasse.m)
+@implementation MaClasse {
+    long distance; // Variable d'instance privé
+    NSNumber hauteur;
+}
+
+// Pour accéder à une variable depuis le fichier d'implémentation on peut utiliser le _ devant le nom
+// de la variable :
+_nombre = 5;
+// Accès d'une variable définit dans le fichier d'implémentation :
+distance = 18;
+// Pour utiliser la varible @property dans l'implémentation, utiliser @synthesize qui créer les 
+// accésseurs :
+@synthesize roString = _roString; // _roString est disponible dans l'@implementation
+
+// Première méthode appelé
++ (void)initialize 
+{
+    if (self == [MaClasse class]) {
+        distance = 0;
+    }
+}
+
+// Counterpart to initialize method. Called when an object's reference count is zero.
+- (void)dealloc
+{
+    [height release]; // If not using ARC, make sure to release class variable objects 
+    [super dealloc];  // and call parent class dealloc. 
+}
+
+// Constructors are a way of creating instances of a class.
+// This is a default constructor which is called when the object is initialized. 
+- (id)init
+{
+    if ((self = [super init])) // 'super' used to access methods from parent class.
+    {
+        self.count = 1; // 'self' used for object to call itself.
+    }
+    return self;
+}
+// Can create constructors that contain arguments:
+- (id)initWithDistance:(int)defaultDistance 
+{
+    distance = defaultDistance;
+    return self;
+}
+
++ (NSString *)classMethod
+{
+    return [[self alloc] init];
+}
+
++ (MyClass *)myClassFromHeight:(NSNumber *)defaultHeight 
+{
+    height = defaultHeight;
+    return [[self alloc] init];
+}
+
+- (NSString *)instanceMethodWithParameter:(NSString *)string
+{
+    return @"New string";
+}
+
+- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number
+{
+    return @42;
+}
+
+// To create a private method, create the method in the @implementation but not in the @interface.
+- (NSNumber *)secretPrivateMethod {
+    return @72;
+}
+[self secretPrivateMethod]; // Calls private method.
+
+// Methods declared into MyProtocol
+- (void)myProtocolMethod
+{
+    // statements
+}
+
+@end // States the end of the implementation. 
+
+/*
+ * A protocol declares methods that can be implemented by any class.
+ * Protocols are not classes themselves. They simply define an interface
+ * that other objects are responsible for implementing.
+ */
+@protocol MyProtocol
+    - (void)myProtocolMethod;
+@end
+
+
+///////////////////////////////////////
+// Memory Management
+///////////////////////////////////////
+/* 
+For each object used in an application, memory must be allocated for that object. When the application
+is done using that object, memory must be deallocated to ensure application efficiency. 
+Objective-C does not use garbage collection and instead uses reference counting. As long as 
+there is at least one reference to an object (also called "owning" an object), then the object
+will be available to use (known as "ownership"). 
+
+When an instance owns an object, its reference counter is increments by one. When the
+object is released, the reference counter decrements by one. When reference count is zero,
+the object is removed from memory. 
+
+With all object interactions, follow the pattern of: 
+(1) create the object, (2) use the object, (3) then free the object from memory. 
+*/
+
+MyClass *classVar = [MyClass alloc]; // 'alloc' sets classVar's reference count to one. Returns pointer to object.
+[classVar release]; // Decrements classVar's reference count.  
+// 'retain' claims ownership of existing object instance and increments reference count. Returns pointer to object.
+MyClass *newVar = [classVar retain]; // If classVar is released, object is still in memory because newVar is owner.
+[classVar autorelease]; // Removes ownership of object at end of @autoreleasepool block. Returns pointer to object.
+
+// @property can use 'retain' and 'assign' as well for small convenient definitions. 
+@property (retain) MyClass *instance; // Release old value and retain a new one (strong reference).
+@property (assign) NSSet *set; // Pointer to new value without retaining/releasing old (weak reference).
+
+// Automatic Reference Counting (ARC)
+// Because memory management can be a pain, Xcode 4.2 and iOS 4 introduced Automatic Reference Counting (ARC).
+// ARC is a compiler feature that inserts retain, release, and autorelease automatically for you, so when using ARC, 
+// you must not use retain, relase, or autorelease.
+MyClass *arcMyClass = [[MyClass alloc] init]; 
+// ... code using arcMyClass
+// Without ARC, you will need to call: [arcMyClass release] after you're done using arcMyClass. But with ARC, 
+// there is no need. It will insert this release statement for you. 
+
+// As for the 'assign' and 'retain' @property attributes, with ARC you use 'weak' and 'strong'. 
+@property (weak) MyClass *weakVar; // 'weak' does not take ownership of object. If original instance's reference count
+// is set to zero, weakVar will automatically receive value of nil to avoid application crashing.
+@property (strong) MyClass *strongVar; // 'strong' takes ownership of object. Ensures object will stay in memory to use.
+
+// For regular variables (not @property declared variables), use the following:
+__strong NSString *strongString; // Default. Variable is retained in memory until it leaves it's scope. 
+__weak NSSet *weakSet; // Weak reference to existing object. When existing object is released, weakSet is set to nil.
+__unsafe_unretained NSArray *unsafeArray; // Like __weak, but unsafeArray not set to nil when existing object is released.
+
+```
+## Further Reading
+
+[La Page Wikipedia de l'Objective-C](http://fr.wikipedia.org/wiki/Objective-C)
+
+[Programming with Objective-C. Apple PDF book](https://developer.apple.com/library/ios/documentation/cocoa/conceptual/ProgrammingWithObjectiveC/ProgrammingWithObjectiveC.pdf)
+
+[iOS For High School Students: Getting Started](http://www.raywenderlich.com/5600/ios-for-high-school-students-getting-started)
-- 
cgit v1.2.3


From 42a5b7d305610a98d57c7ad9d576b22f33aeff75 Mon Sep 17 00:00:00 2001
From: Yannick <yannick.loriot@gmail.com>
Date: Sun, 12 Jan 2014 22:43:53 +0100
Subject: [NEW] french translation

---
 fr-fr/objective-c.html.markdown | 73 ++++++++++++++++++++---------------------
 1 file changed, 36 insertions(+), 37 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/objective-c.html.markdown b/fr-fr/objective-c.html.markdown
index b6567382..730687db 100644
--- a/fr-fr/objective-c.html.markdown
+++ b/fr-fr/objective-c.html.markdown
@@ -375,80 +375,79 @@ distance = 18;
 // accésseurs :
 @synthesize roString = _roString; // _roString est disponible dans l'@implementation
 
-// Première méthode appelé
-+ (void)initialize 
-{
-    if (self == [MaClasse class]) {
-        distance = 0;
-    }
-}
-
-// Counterpart to initialize method. Called when an object's reference count is zero.
+// En contre-partie de l'initialisation, la fonction dealloc est appelé quand l'objet est n'est plus
+// utilisé
 - (void)dealloc
 {
-    [height release]; // If not using ARC, make sure to release class variable objects 
-    [super dealloc];  // and call parent class dealloc. 
+    [hauteur release]; // Si vous n'utilisez par l'ARC, pensez bien à supprimer l'objet 
+    [super dealloc];  // et à appeler la méthode de la classe parent 
 }
 
-// Constructors are a way of creating instances of a class.
-// This is a default constructor which is called when the object is initialized. 
+// Les constructeurs sont une manière de créer des instances de classes
+// Ceci est le constructeur par défaut; il est appelé quand l'objet est créé
 - (id)init
 {
-    if ((self = [super init])) // 'super' used to access methods from parent class.
+    if ((self = [super init])) // 'super' est utilisé pour appeler la méthode de la classe parent
     {
-        self.count = 1; // 'self' used for object to call itself.
+        self.count = 1; // 'self' est utilisé pour appeler la méthodes de l'objet courrant
     }
     return self;
 }
-// Can create constructors that contain arguments:
-- (id)initWithDistance:(int)defaultDistance 
+
+// Vous pouvez créer des constructeurs qui possèdent des arguments :
+- (id)initAvecUneDistance:(int)distanceParDefault 
 {
-    distance = defaultDistance;
-    return self;
+    if ((self = [super init]))
+    {
+        distance = distanceParDefault;
+        return self;
+    }
 }
 
-+ (NSString *)classMethod
++ (NSString *)methodDeClasse
 {
     return [[self alloc] init];
 }
 
-+ (MyClass *)myClassFromHeight:(NSNumber *)defaultHeight 
++ (MaClasse *)maClasseDepuisUneHauteur:(NSNumber *)hauteurParDefaut
 {
-    height = defaultHeight;
+    hauteur = hauteurParDefaut;
     return [[self alloc] init];
 }
 
-- (NSString *)instanceMethodWithParameter:(NSString *)string
+- (NSString *)methodeInstanceAvecUnParametre:(NSString *)string
 {
-    return @"New string";
+    return @"Ma chaine de charactère";
 }
 
-- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number
+- (NSNumber *)methodeInstanceAvecUnParametre:(NSString*)string puisUnDeuxieme:(NSNumber *)number
 {
     return @42;
 }
 
-// To create a private method, create the method in the @implementation but not in the @interface.
-- (NSNumber *)secretPrivateMethod {
+// Pour créer une méthode privée, il faut la définir dans l'@implementation et non pas dans 
+// l'@interface
+- (NSNumber *)methodePrivee
+{
     return @72;
 }
-[self secretPrivateMethod]; // Calls private method.
 
-// Methods declared into MyProtocol
-- (void)myProtocolMethod
+[self methodePrivee]; // Appel de la méthode privée
+
+// Méthode déclarée dans MonProtocole
+- (void)methodeDuProtocole
 {
-    // statements
+    // expressions
 }
 
-@end // States the end of the implementation. 
+@end // Fin de l'implémentation
 
 /*
- * A protocol declares methods that can be implemented by any class.
- * Protocols are not classes themselves. They simply define an interface
- * that other objects are responsible for implementing.
+ * Un protocole déclare les méthodes qu'ils doivent implémenter afin de se conformer celui-ci
+ * Un protocole n'est pas une classe, c'est juste une interface
  */
-@protocol MyProtocol
-    - (void)myProtocolMethod;
+@protocol MonProtocole
+    - (void)methodeDuProtocole;
 @end
 
 
-- 
cgit v1.2.3


From a35126f22e481fa154c6cc7252bf4d91dced2607 Mon Sep 17 00:00:00 2001
From: Yannick <yannick.loriot@gmail.com>
Date: Mon, 20 Jan 2014 22:42:23 +0100
Subject: [UPDATE] MRC section

---
 fr-fr/objective-c.html.markdown | 44 ++++++++++++++++++++---------------------
 1 file changed, 22 insertions(+), 22 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/objective-c.html.markdown b/fr-fr/objective-c.html.markdown
index 730687db..610283aa 100644
--- a/fr-fr/objective-c.html.markdown
+++ b/fr-fr/objective-c.html.markdown
@@ -452,32 +452,32 @@ distance = 18;
 
 
 ///////////////////////////////////////
-// Memory Management
+// Gestion de la mémoire
 ///////////////////////////////////////
 /* 
-For each object used in an application, memory must be allocated for that object. When the application
-is done using that object, memory must be deallocated to ensure application efficiency. 
-Objective-C does not use garbage collection and instead uses reference counting. As long as 
-there is at least one reference to an object (also called "owning" an object), then the object
-will be available to use (known as "ownership"). 
-
-When an instance owns an object, its reference counter is increments by one. When the
-object is released, the reference counter decrements by one. When reference count is zero,
-the object is removed from memory. 
-
-With all object interactions, follow the pattern of: 
-(1) create the object, (2) use the object, (3) then free the object from memory. 
+Pour chaque objet utilisé dans une application, la mémoire doit être alloué pour chacun d'entre eux.
+Quand l'application en a fini avec cet objet, la mémoire doit être libéré pour assurer la performane.
+Il n'y a pas de ramasse-miettes en Objective-C, il utilise à la place le comptage de référence à la
+place. Tant que le compteur de référence est supérieur à 1 sur un objet, l'objet ne sera pas supprimé.
+
+Quand une instance détient un objet, le compteur de référence est incrémenté de un. Quand l'objet est
+libéré, le compteur est décrémenté de un. Quand le compteur est égale à zéro, l'objet est supprimé de
+la mémoire.
+
+Une bonne pratique à suivre quand on travaille avec des objets est la suivante :
+(1) créer un objet, (2) utiliser l'objet, (3) supprimer l'objet de la mémoire.
 */
 
-MyClass *classVar = [MyClass alloc]; // 'alloc' sets classVar's reference count to one. Returns pointer to object.
-[classVar release]; // Decrements classVar's reference count.  
-// 'retain' claims ownership of existing object instance and increments reference count. Returns pointer to object.
-MyClass *newVar = [classVar retain]; // If classVar is released, object is still in memory because newVar is owner.
-[classVar autorelease]; // Removes ownership of object at end of @autoreleasepool block. Returns pointer to object.
+MaClasse *classeVar = [MyClass alloc]; // 'alloc' incrémente le compteur de référence
+[classeVar release]; // Décrémente le compteur de rérence
+// 'retain' incrémente le compteur de référence
+// Si 'classeVar' est libéré, l'objet reste en mémoire car le compteur de référence est non nulle
+MaClasse *nouvelleVar = [classVar retain];
+[classeVar autorelease]; // Supprime l'appartenance de l'objet à la fin du block
 
-// @property can use 'retain' and 'assign' as well for small convenient definitions. 
-@property (retain) MyClass *instance; // Release old value and retain a new one (strong reference).
-@property (assign) NSSet *set; // Pointer to new value without retaining/releasing old (weak reference).
+// @property peuvent utiliser 'retain' et 'assign' 
+@property (retain) MaClasse *instance; // Libère l'ancienne valeur et retient la nouvelle
+@property (assign) NSSet *set; // Pointeur vers la valeur sans retenir/libérer l'ancienne valeur
 
 // Automatic Reference Counting (ARC)
 // Because memory management can be a pain, Xcode 4.2 and iOS 4 introduced Automatic Reference Counting (ARC).
@@ -499,7 +499,7 @@ __weak NSSet *weakSet; // Weak reference to existing object. When existing objec
 __unsafe_unretained NSArray *unsafeArray; // Like __weak, but unsafeArray not set to nil when existing object is released.
 
 ```
-## Further Reading
+##  Lectures Complémentaires
 
 [La Page Wikipedia de l'Objective-C](http://fr.wikipedia.org/wiki/Objective-C)
 
-- 
cgit v1.2.3


From 15dcc4a6ce1d7df54292925f4d0af4a8af87eea8 Mon Sep 17 00:00:00 2001
From: Yannick <yannick.loriot@gmail.com>
Date: Fri, 24 Jan 2014 18:36:30 +0100
Subject: [UPDATE] French Translation

---
 fr-fr/objective-c.html.markdown | 46 +++++++++++++++++++++--------------------
 1 file changed, 24 insertions(+), 22 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/objective-c.html.markdown b/fr-fr/objective-c.html.markdown
index 610283aa..e6a8abfb 100644
--- a/fr-fr/objective-c.html.markdown
+++ b/fr-fr/objective-c.html.markdown
@@ -458,14 +458,14 @@ distance = 18;
 Pour chaque objet utilisé dans une application, la mémoire doit être alloué pour chacun d'entre eux.
 Quand l'application en a fini avec cet objet, la mémoire doit être libéré pour assurer la performane.
 Il n'y a pas de ramasse-miettes en Objective-C, il utilise à la place le comptage de référence à la
-place. Tant que le compteur de référence est supérieur à 1 sur un objet, l'objet ne sera pas supprimé.
+place. Tant que le compteur de référence est supérieur à 1 sur un objet, l'objet ne sera pas supprimé
 
 Quand une instance détient un objet, le compteur de référence est incrémenté de un. Quand l'objet est
 libéré, le compteur est décrémenté de un. Quand le compteur est égale à zéro, l'objet est supprimé de
-la mémoire.
+la mémoire
 
 Une bonne pratique à suivre quand on travaille avec des objets est la suivante :
-(1) créer un objet, (2) utiliser l'objet, (3) supprimer l'objet de la mémoire.
+(1) créer un objet, (2) utiliser l'objet, (3) supprimer l'objet de la mémoire
 */
 
 MaClasse *classeVar = [MyClass alloc]; // 'alloc' incrémente le compteur de référence
@@ -480,29 +480,31 @@ MaClasse *nouvelleVar = [classVar retain];
 @property (assign) NSSet *set; // Pointeur vers la valeur sans retenir/libérer l'ancienne valeur
 
 // Automatic Reference Counting (ARC)
-// Because memory management can be a pain, Xcode 4.2 and iOS 4 introduced Automatic Reference Counting (ARC).
-// ARC is a compiler feature that inserts retain, release, and autorelease automatically for you, so when using ARC, 
-// you must not use retain, relase, or autorelease.
-MyClass *arcMyClass = [[MyClass alloc] init]; 
-// ... code using arcMyClass
-// Without ARC, you will need to call: [arcMyClass release] after you're done using arcMyClass. But with ARC, 
-// there is no need. It will insert this release statement for you. 
-
-// As for the 'assign' and 'retain' @property attributes, with ARC you use 'weak' and 'strong'. 
-@property (weak) MyClass *weakVar; // 'weak' does not take ownership of object. If original instance's reference count
-// is set to zero, weakVar will automatically receive value of nil to avoid application crashing.
-@property (strong) MyClass *strongVar; // 'strong' takes ownership of object. Ensures object will stay in memory to use.
-
-// For regular variables (not @property declared variables), use the following:
-__strong NSString *strongString; // Default. Variable is retained in memory until it leaves it's scope. 
-__weak NSSet *weakSet; // Weak reference to existing object. When existing object is released, weakSet is set to nil.
-__unsafe_unretained NSArray *unsafeArray; // Like __weak, but unsafeArray not set to nil when existing object is released.
+// La gestion de la mémoire étant pénible, depuis iOS 4 et Xcode 4.2, Apple a introduit le comptage de référence
+// automatique (Automatic Reference Counting en anglais).
+// ARC est une fonctionnalité du compilateur qui lui permet d'ajouter les 'retain', 'release' et 'autorelease'
+// automatiquement. Donc quand utilisez ARC vous de devez plus utiliser ces mots clés
+MaClasse *arcMaClasse = [[MaClasse alloc] init]; 
+// ... code utilisant arcMaClasse
+// Sans ARC, vous auriez dû appeler [arcMaClasse release] après avoir utilisé l'objet. Mais avec ARC il n'y a plus
+// besoin car le compilateur ajoutera l'expréssion automatiquement pour vous
+
+// Les mots clés 'assign' et 'retain', avec ARC sont respectivement remplacé par 'weak' et 'strong'
+@property (weak) MaClasse *weakVar; // 'weak' ne retient pas l'objet. Si l'instance original descend à zero, weakVar
+// sera automatiquement mis à nil
+@property (strong) MaClasse *strongVar; // 'strong' prend posséssion de l'objet comme le ferai le mot clé 'retain'
+
+// Pour l'instanciation des variables (en dehors de @property), vous pouvez utiliser les instructions suivantes :
+__strong NSString *strongString; // Par defaut. La variable est retenu en mémoire jusqu'à la fin de sa portée
+__weak NSSet *weakSet; // Réfère la variable en utilisant le mot clé '__weak'
+__unsafe_unretained NSArray *unsafeArray; // Comme __weak, mais quand la variable n'est pas mis à nil quand l'objet
+// est supprimé ailleurs
 
 ```
 ##  Lectures Complémentaires
 
 [La Page Wikipedia de l'Objective-C](http://fr.wikipedia.org/wiki/Objective-C)
 
-[Programming with Objective-C. Apple PDF book](https://developer.apple.com/library/ios/documentation/cocoa/conceptual/ProgrammingWithObjectiveC/ProgrammingWithObjectiveC.pdf)
+[iOS pour les écoliers : Votre première app iOS](http://www.raywenderlich.com/fr/39272/ios-pour-les-ecoliers-votre-premiere-app-ios-partie-12)
 
-[iOS For High School Students: Getting Started](http://www.raywenderlich.com/5600/ios-for-high-school-students-getting-started)
+[Programming with Objective-C. Apple PDF book](https://developer.apple.com/library/ios/documentation/cocoa/conceptual/ProgrammingWithObjectiveC/ProgrammingWithObjectiveC.pdf)
\ No newline at end of file
-- 
cgit v1.2.3


From 3dae1ab745c2f3e5eae0a9d47c0b848f3ed44730 Mon Sep 17 00:00:00 2001
From: Yannick <yannick.loriot@gmail.com>
Date: Fri, 24 Jan 2014 18:43:22 +0100
Subject: [FIX] Objective-C French Translation Filename

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

(limited to 'fr-fr')

diff --git a/fr-fr/objective-c-fr.html.markdown b/fr-fr/objective-c-fr.html.markdown
new file mode 100644
index 00000000..e6a8abfb
--- /dev/null
+++ b/fr-fr/objective-c-fr.html.markdown
@@ -0,0 +1,510 @@
+---
+
+language: Objective-C
+contributors:
+    - ["Eugene Yagrushkin", "www.about.me/yagrushkin"]
+    - ["Yannick Loriot", "https://github.com/YannickL"]
+    - ["Levi Bostian", "https://github.com/levibostian"]
+translators:
+    - ["Yannick Loriot", "https://github.com/YannickL"]
+filename: LearnObjectiveC.m
+
+---
+
+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 framworks respectifs, Cocoa et Cocoa Touch.
+
+```objective-c
+// Les commentaires unilignes commencent par //
+
+/*
+Les commentaires multilignes ressemblent à ça
+*/
+
+// Importe les en-têtes en utilisant #import
+// Utilisez <> pour importer des fichiers globaux (en général des frameworks)
+// Utilisez "" pour importer des fichiers locaux (du projet)
+#import <Foundation/Foundation.h>
+#import "MaClasse.h"
+
+// Si vous activez les modules pour les projects iOS >= 7 ou Mac OS X >= 10.9
+// dans Xcode 5 vous pouvez importer les frameworks comme cela :
+@import Foundation;
+
+// Le point d'entrée de votre programme est une fonction qui s'appelle main
+// et qui return un entier comme type
+int main (int argc, const char * argv[])
+{
+    // Créer un groupe de libération automatique de la mémoire pour l'ensemble
+    // du programme
+    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
+    // Si vous utilisez le comptage de référence automatique (ARC), utilisez
+    // @autoreleasepool à la place :
+    @autoreleasepool {
+
+    // Utilisez NSLog pour afficher les lignes sur la console
+    // Affiche la chaine de caractères "Bonjour Tous Le Monde !"
+    NSLog(@"Bonjour tous le Monde !"); 
+ 
+    ///////////////////////////////////////
+    // Les Types & Les Variables
+    ///////////////////////////////////////
+    
+    // Déclarations de primitive
+    int maPrimitive1  = 1;
+    long maPrimitive2 = 234554664565;
+    
+    // Declarations d'objets
+    // Il faut mettre l'* devant la déclaration d'objets fortement typés
+    MaClasse *monObject1 = nil;  // Typage fort
+    id       monObject2  = nil;  // Typage faible
+    // %@ est un objet
+    // 'description' est une convention pour afficher la valeur des objets
+    NSLog(@"%@ and %@", monObject1, [monObject2 description]); // Affiche "(null) et (null)"
+    
+    // Chaines de caractères
+    NSString *chaineMonde = @"Monde";
+    NSLog(@"Bonjour tous le %@ !", chaineMonde); // affiche => "Bonjour Tous Le Monde !" 
+    // NSMutableString est une chaine mutable
+    NSMutableString *chaineMutable = [NSMutableString stringWithString:@"Bonjour tous le"];
+    [chaineMutable appendString:@" Monde !"];
+    NSLog(@"%@", chaineMutable); // affiche => "Bonjour Tous Le Monde !"
+    
+    // Les littéraux pour les caratères
+    NSNumber *laLettreZSousFormeDeNombre = @'Z';
+    char laLettreZ                       = [laLettreZSousFormeDeNombre charValue]; // ou 'Z'
+    NSLog(@"%c", laLettreZ);
+
+    // Les littéraux pour les nombres
+    NSNumber *nombreQuaranteDeux = @42;
+    int quaranteDeux             = [nombreQuaranteDeux intValue]; // ou 42
+    NSLog(@"%i", quaranteDeux);
+    
+    NSNumber *nombreQuaranteDeuxnonSigne = @42U;
+    unsigned int quaranteDeuxnonSigne    = [nombreQuaranteDeuxnonSigne unsignedIntValue];
+    NSLog(@"%u", fortyTwoUnsigned);
+    
+    NSNumber *nombreQuaranteDeuxCourt = [NSNumber numberWithShort:42];
+    short quaranteDeuxCourt           = [nombreQuaranteDeuxCourt shortValue]; // ou 42
+    NSLog(@"%hi", fortyTwoShort);
+    
+    NSNumber *nombreQuaranteDeuxLong = @42L;
+    long quaranteDeuxLong            = [nombreQuaranteDeuxLong longValue]; // ou 42
+    NSLog(@"%li", fortyTwoLong);
+
+    // Les littéraux pour les flottans
+    NSNumber *nombrePiFlottan = @3.141592654F;
+    float piFlottan           = [nombrePiFlottan floatValue]; // ou 3.141592654f
+    NSLog(@"%f", piFlottan); // affiche => 3.141592654
+    NSLog(@"%5.2f", piFlottan); // affiche => " 3.14"
+    
+    NSNumber *nombrePiDouble = @3.1415926535;
+    double piDouble          = [nombrePiDouble doubleValue]; // ou 3.1415926535
+    NSLog(@"%f", piDouble);
+    NSLog(@"%4.2f", piDouble); // affiche => "3.14"
+
+    // NSDecimalNumber est une classe pour avoir plus de précision sur les flottans
+    // et les doubles
+    NSDecimalNumber *decNumUn   = [NSDecimalNumber decimalNumberWithString:@"10.99"];
+    NSDecimalNumber *decNumDeux = [NSDecimalNumber decimalNumberWithString:@"5.002"];
+    // NSDecimalNumber n'est pas capable d'utiliser les opérations standards : 
+    // +, -, *, /, il utilise donc ses propres fonctions :
+    [decNumUn decimalNumberByAdding:decNumDeux]; 
+    [decNumUn decimalNumberBySubtracting:decNumDeux];
+    [decNumUn decimalNumberByMultiplyingBy:decNumDeux];
+    [decNumUn decimalNumberByDividingBy:decNumDeux];
+    NSLog(@"%@", decNumUn); // affiche => 10.99 comme NSDecimalNumber is immuable
+
+    // Les littéraux pour les booléens
+    NSNumber *ouiNumber = @YES;
+    NSNumber *nonNumber = @NO;
+    // ou
+    BOOL ouiBool = YES;
+    BOOL nonBool  = NO;
+    NSLog(@"%i", ouiBool); // affiche => 1
+
+    // Les listes
+    // Ils peuvent contenir différents types de données, mais ils doivent absolument 
+    // être des objets
+    NSArray *uneListe         = @[@1, @2, @3, @4];
+    NSNumber *troisiemeNombre = uneListe[2];
+    NSLog(@"Troisième nombre = %@", troisiemeNombre); // affiche "Troisième nombre = 3"
+    // NSMutableArray est une version mutable de NSArray qui permet de changer les
+    // objets dans la liste et l'étendre ou  la réduire
+    // C'est très pratique, mais pas aussi performant que l'utilsation de la classe
+    // NSArray
+    NSMutableArray *listeMutable = [NSMutableArray arrayWithCapacity:2];
+    [listeMutable addObject:@"Bonjour tous le"];
+    [listeMutable addObject:@"Monde"];
+    [listeMutable removeObjectAtIndex:0];
+    NSLog(@"%@", [listeMutable objectAtIndex:0]); // affiche => "Monde"
+
+    // Les dictionnaires
+    NSDictionary *unDictionnaire = @{ @"cle1" : @"valeur1", @"cle2" : @"valeur2" };
+    NSObject *valeur             = unDictionnaire[@"Une clé"];
+    NSLog(@"Objet = %@", valeur); // affiche "Objet = (null)"
+    // NSMutableDictionary est un dictionnaire mutable
+    NSMutableDictionary *dictionnaireMutable = [NSMutableDictionary dictionaryWithCapacity:2];
+    [dictionnaireMutable setObject:@"valeur1" forKey:@"cle1"];
+    [dictionnaireMutable setObject:@"valeur2" forKey:@"cle2"];
+    [dictionnaireMutable removeObjectForKey:@"cle1"];
+
+    // Les ensembles
+    NSSet *ensemble = [NSSet setWithObjects:@"Salut", @"Salut", @"Monde", nil];
+    NSLog(@"%@", ensemble); // affiche => {(Salut, Monde)} (peut être dans un ordre différente)
+    // NSMutableSet est un ensemble mutable 
+    NSMutableSet *ensembleMutable = [NSMutableSet setWithCapacity:2];
+    [ensembleMutable addObject:@"Salut"];
+    [ensembleMutable addObject:@"Salut"];
+    NSLog(@"%@", ensembleMutable); // affiche => {(Salut)}
+
+    ///////////////////////////////////////
+    // Operateurs
+    ///////////////////////////////////////
+    
+    // Les opérateurs sont les mêmes que ceux du langage C
+    // Par exemple :
+    2 + 5; // => 7
+    4.2f + 5.1f; // => 9.3f
+    3 == 2; // => 0 (NO)
+    3 != 2; // => 1 (YES)
+    1 && 1; // => 1 (et logique)
+    0 || 1; // => 1 (ou logique)
+    ~0x0F; // => 0xF0 (négation bit à bit)
+    0x0F & 0xF0; // => 0x00 (et bit à bit)
+    0x01 << 1; // => 0x02 (décale à gauche (par 1))
+
+    ///////////////////////////////////////
+    // Structures de controle
+    ///////////////////////////////////////
+
+    // Expression If-Else 
+    if (NO)
+    {
+        NSLog(@"Je ne suis jamais affiché");
+    } else if (0)
+    {
+        NSLog(@"Je ne suis jamais affiché aussi");
+    } else
+    {
+        NSLog(@"Je suis affiché");
+    }
+
+    // Expression Switch
+    switch (2)
+    {
+        case 0:
+        {
+            NSLog(@"Je ne suis jamais affiché");
+        } break;
+        case 1:
+        {
+            NSLog(@"Je ne suis jamais affiché aussi");
+        } break;
+        default:
+        {
+            NSLog(@"Je suis affiché");
+        } break;
+    }
+    
+    // Expression de boucle While
+    int ii = 0;
+    while (ii < 4)
+    {
+        NSLog(@"%d,", ii++); // ii++ incrémente ii après avoir utilisé sa valeure
+    } // => affiche "0," 
+      //            "1,"
+      //            "2,"
+      //            "3,"
+
+    // Expression de boucle For loops
+    int jj;
+    for (jj=0; jj < 4; jj++)
+    {
+        NSLog(@"%d,", jj);
+    } // => affiche "0," 
+      //            "1,"
+      //            "2,"
+      //            "3,"
+     
+    // Expression de boucle Foreach
+    NSArray *valeurs = @[@0, @1, @2, @3];
+    for (NSNumber *valeur in valeurs)
+    {
+        NSLog(@"%@,", valeur);
+    } // => affiche "0," 
+      //            "1,"
+      //            "2,"
+      //            "3,"
+
+    // Expressions Try-Catch-Finally
+    @try
+    {
+        @throw [NSException exceptionWithName:@"FileNotFoundException"
+                            reason:@"Fichier non trouvé" userInfo:nil];
+    } @catch (NSException * e)
+    {
+        NSLog(@"Exception : %@", e);
+    } @finally
+    {
+        NSLog(@"Finalement");
+    } // => affiche "Exceptio : Fichier non trouvé"
+      //            "Finalement"
+ 
+    ///////////////////////////////////////
+    // Objets
+    ///////////////////////////////////////
+    
+    // Créez une instance d'objet en allouant un espace mémoire puis en l'initialisant
+    // Un objet n'est pas complétement fonctionnel jusqu'à ce que les deux étapes précédente
+    // ne sont pas fini
+    MaClass *monObjet = [[MaClass alloc] init];
+        
+    // Le modèle Objective-C est basé sur l'envoie de message et non sur les appels de
+    // méthodes comme la plupart des autres langage de programmation
+    [myObject instanceMethodWithParameter:@"Steve Jobs"];
+
+    // Nettoie la mémoire que vous avez utilisé dans votre programme
+    [pool drain];
+
+    // Fin the l'@autoreleasepool
+    }
+    
+    // Fin du programme
+    return 0;
+}
+
+///////////////////////////////////////
+// Classes et Fonctions
+///////////////////////////////////////
+
+// Déclarez votre classe dans une en-tête de fichier (MaClasse.h) :
+// La syntaxe de déclaration :
+// @interface NomDeLaClasse : NomDeLaClasseParent <ProtocolesImplemente>
+// {
+//    type nom; <= declarations de variable;
+// }
+// @property type nom; <= declarations de propriété.
+// -/+ (type) Methode declarations; <= Declarations de methodes. 
+// @end
+// NSObject est la classe de base de l'Objective-C
+@interface MaClasse : NSObject <MonProtocole>
+{
+    // Déclaration des variables d'instances (peut existé soit dans l'interface soir dans 
+    // l'implémentation)
+    int nombre; // Accès protégé par défaut
+    @private id donnee; // Accès privé (il est plus pratique de le faire dans l'implémentation)
+    NSString *nom; 
+}
+// Notation pratique pour l'accès aux variable public et pour générrer les 
+// accésseurs/affecteurs
+// Par défaut, le nom de l'affecteur vaut 'set' suivi par le nom de la @property
+@property int propInt; // Nom du setter = 'setPropInt'
+@property (copy) id copyId; // (copy) => Copie l'objet pendant l'affectation
+// (readonly) => Ne peut pas affecté la variable en dehors de l'@interface
+// Utilisez @synthesize dans l'@implementation pour créer l'accésseur
+@property (readonly) NSString *roString;
+// Vous pouvez personnaliser les noms des accésseurs et des affecteurs au lieu d'utiliser les
+// noms par défauts
+@property (getter=longeurGet, setter=longeurSet:) int longeur;
+ 
+// Methodes
++/- (type de retour)signatureDeLaMethode:(Type Du Parametre *)nomDuParametre;
+
+// + pour les méthodes de classe :
++ (NSString *)methodeDeClasse;
++ (MaClasse *)maClasseDepuisLaHauteur:(NSNumber *)hauteurParDefaut;
+
+// - pour les méthodes d'instances :
+- (NSString *)methodeInstanceAvecUnParametre:(NSString *)string;
+- (NSNumber *)methodeInstanceAvecUnParametre:(NSString*)string puisUnDeuxieme:(NSNumber *)number;
+
+// Contructeur avec des arguments :
+- (id)initAvecDistance:(int)distanceParDefault;
+// Les méthodes en Objective-C sont très descriptive
+
+@end // Définit la fin de l'interface
+
+
+// Exemple d'utilisation de MaClasse
+MaClasse *maClasse = [[MaClasse alloc] init]; // créer une instance de MaClasse
+[maClasse setNombre:10]; 
+NSLog(@"%d", [maClasse nombre]); // affiche => 10
+[myClass longeurSet:32];
+NSLog(@"%i", [maClasse longeurGet]); // affiche => 32
+// Pour des raisons pratiques vous pouvez aussi utiliser la notation en point pour accéder aux 
+// variables d'instances :
+maClasse.nombre = 45;
+NSLog(@"%i", maClasse.nombre); // maClasse => 45
+
+// Appeler un méthode de classe :
+NSString *s1 = [MaClasse methodeDeClasse];
+MaClasse *m2 = [MaClasse maClasseDepuisLaHauteur:38];
+
+// Appeler un méthode d'instance :
+MaClasse *maClasse = [[MaClasse alloc] init]; // Créer une instance de MaClasse
+NSString *stringDepuisUneInstanceDeMethode = [maClasse methodeInstanceAvecUnParametre:@"Salut"];
+
+// Sélecteurs sont un moyen de représenté les méthodes dynamiquement
+// Ils sont utilisé pour appeller des méthodes de classe, passer des methodes au travers de fonctions
+// pour notifier les autres classes qu'elle peuvent les appellé, et pour sauvegarder les méthodes en
+// tant que variables
+// SEL est un type de donnée. @selected retourne un selecteur à partir d'un nom de methode
+SEL selecteur = @selector(methodeInstanceAvecUnParametre:puisUnDeuxieme:); 
+if ([maClasse respondsToSelector:selecteur]) { // Vérifie si la classe contient la méthode
+    // Doit mettre tous les arguments de la méthode dans un seul objet pour l'envoyer via la fonction
+    // performSelector:withObject: 
+    NSArray *arguments = [NSArray arrayWithObjects:@"Hello", @4, nil];
+    [myClass performSelector:selectorVar withObject:arguments]; // Appele la méthode
+} else {
+    // NSStringFromSelector() retourne une chaine de charactères à partir d'un sélecteur
+    NSLog(@"MaClasse ne possède pas de méthode : %@", NSStringFromSelector(selecteur));
+}
+
+// Implement la méthode dans le fichier d'impémentation (MaClasse.m)
+@implementation MaClasse {
+    long distance; // Variable d'instance privé
+    NSNumber hauteur;
+}
+
+// Pour accéder à une variable depuis le fichier d'implémentation on peut utiliser le _ devant le nom
+// de la variable :
+_nombre = 5;
+// Accès d'une variable définit dans le fichier d'implémentation :
+distance = 18;
+// Pour utiliser la varible @property dans l'implémentation, utiliser @synthesize qui créer les 
+// accésseurs :
+@synthesize roString = _roString; // _roString est disponible dans l'@implementation
+
+// En contre-partie de l'initialisation, la fonction dealloc est appelé quand l'objet est n'est plus
+// utilisé
+- (void)dealloc
+{
+    [hauteur release]; // Si vous n'utilisez par l'ARC, pensez bien à supprimer l'objet 
+    [super dealloc];  // et à appeler la méthode de la classe parent 
+}
+
+// Les constructeurs sont une manière de créer des instances de classes
+// Ceci est le constructeur par défaut; il est appelé quand l'objet est créé
+- (id)init
+{
+    if ((self = [super init])) // 'super' est utilisé pour appeler la méthode de la classe parent
+    {
+        self.count = 1; // 'self' est utilisé pour appeler la méthodes de l'objet courrant
+    }
+    return self;
+}
+
+// Vous pouvez créer des constructeurs qui possèdent des arguments :
+- (id)initAvecUneDistance:(int)distanceParDefault 
+{
+    if ((self = [super init]))
+    {
+        distance = distanceParDefault;
+        return self;
+    }
+}
+
++ (NSString *)methodDeClasse
+{
+    return [[self alloc] init];
+}
+
++ (MaClasse *)maClasseDepuisUneHauteur:(NSNumber *)hauteurParDefaut
+{
+    hauteur = hauteurParDefaut;
+    return [[self alloc] init];
+}
+
+- (NSString *)methodeInstanceAvecUnParametre:(NSString *)string
+{
+    return @"Ma chaine de charactère";
+}
+
+- (NSNumber *)methodeInstanceAvecUnParametre:(NSString*)string puisUnDeuxieme:(NSNumber *)number
+{
+    return @42;
+}
+
+// Pour créer une méthode privée, il faut la définir dans l'@implementation et non pas dans 
+// l'@interface
+- (NSNumber *)methodePrivee
+{
+    return @72;
+}
+
+[self methodePrivee]; // Appel de la méthode privée
+
+// Méthode déclarée dans MonProtocole
+- (void)methodeDuProtocole
+{
+    // expressions
+}
+
+@end // Fin de l'implémentation
+
+/*
+ * Un protocole déclare les méthodes qu'ils doivent implémenter afin de se conformer celui-ci
+ * Un protocole n'est pas une classe, c'est juste une interface
+ */
+@protocol MonProtocole
+    - (void)methodeDuProtocole;
+@end
+
+
+///////////////////////////////////////
+// Gestion de la mémoire
+///////////////////////////////////////
+/* 
+Pour chaque objet utilisé dans une application, la mémoire doit être alloué pour chacun d'entre eux.
+Quand l'application en a fini avec cet objet, la mémoire doit être libéré pour assurer la performane.
+Il n'y a pas de ramasse-miettes en Objective-C, il utilise à la place le comptage de référence à la
+place. Tant que le compteur de référence est supérieur à 1 sur un objet, l'objet ne sera pas supprimé
+
+Quand une instance détient un objet, le compteur de référence est incrémenté de un. Quand l'objet est
+libéré, le compteur est décrémenté de un. Quand le compteur est égale à zéro, l'objet est supprimé de
+la mémoire
+
+Une bonne pratique à suivre quand on travaille avec des objets est la suivante :
+(1) créer un objet, (2) utiliser l'objet, (3) supprimer l'objet de la mémoire
+*/
+
+MaClasse *classeVar = [MyClass alloc]; // 'alloc' incrémente le compteur de référence
+[classeVar release]; // Décrémente le compteur de rérence
+// 'retain' incrémente le compteur de référence
+// Si 'classeVar' est libéré, l'objet reste en mémoire car le compteur de référence est non nulle
+MaClasse *nouvelleVar = [classVar retain];
+[classeVar autorelease]; // Supprime l'appartenance de l'objet à la fin du block
+
+// @property peuvent utiliser 'retain' et 'assign' 
+@property (retain) MaClasse *instance; // Libère l'ancienne valeur et retient la nouvelle
+@property (assign) NSSet *set; // Pointeur vers la valeur sans retenir/libérer l'ancienne valeur
+
+// Automatic Reference Counting (ARC)
+// La gestion de la mémoire étant pénible, depuis iOS 4 et Xcode 4.2, Apple a introduit le comptage de référence
+// automatique (Automatic Reference Counting en anglais).
+// ARC est une fonctionnalité du compilateur qui lui permet d'ajouter les 'retain', 'release' et 'autorelease'
+// automatiquement. Donc quand utilisez ARC vous de devez plus utiliser ces mots clés
+MaClasse *arcMaClasse = [[MaClasse alloc] init]; 
+// ... code utilisant arcMaClasse
+// Sans ARC, vous auriez dû appeler [arcMaClasse release] après avoir utilisé l'objet. Mais avec ARC il n'y a plus
+// besoin car le compilateur ajoutera l'expréssion automatiquement pour vous
+
+// Les mots clés 'assign' et 'retain', avec ARC sont respectivement remplacé par 'weak' et 'strong'
+@property (weak) MaClasse *weakVar; // 'weak' ne retient pas l'objet. Si l'instance original descend à zero, weakVar
+// sera automatiquement mis à nil
+@property (strong) MaClasse *strongVar; // 'strong' prend posséssion de l'objet comme le ferai le mot clé 'retain'
+
+// Pour l'instanciation des variables (en dehors de @property), vous pouvez utiliser les instructions suivantes :
+__strong NSString *strongString; // Par defaut. La variable est retenu en mémoire jusqu'à la fin de sa portée
+__weak NSSet *weakSet; // Réfère la variable en utilisant le mot clé '__weak'
+__unsafe_unretained NSArray *unsafeArray; // Comme __weak, mais quand la variable n'est pas mis à nil quand l'objet
+// est supprimé ailleurs
+
+```
+##  Lectures Complémentaires
+
+[La Page Wikipedia de l'Objective-C](http://fr.wikipedia.org/wiki/Objective-C)
+
+[iOS pour les écoliers : Votre première app iOS](http://www.raywenderlich.com/fr/39272/ios-pour-les-ecoliers-votre-premiere-app-ios-partie-12)
+
+[Programming with Objective-C. Apple PDF book](https://developer.apple.com/library/ios/documentation/cocoa/conceptual/ProgrammingWithObjectiveC/ProgrammingWithObjectiveC.pdf)
\ No newline at end of file
diff --git a/fr-fr/objective-c.html.markdown b/fr-fr/objective-c.html.markdown
deleted file mode 100644
index e6a8abfb..00000000
--- a/fr-fr/objective-c.html.markdown
+++ /dev/null
@@ -1,510 +0,0 @@
----
-
-language: Objective-C
-contributors:
-    - ["Eugene Yagrushkin", "www.about.me/yagrushkin"]
-    - ["Yannick Loriot", "https://github.com/YannickL"]
-    - ["Levi Bostian", "https://github.com/levibostian"]
-translators:
-    - ["Yannick Loriot", "https://github.com/YannickL"]
-filename: LearnObjectiveC.m
-
----
-
-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 framworks respectifs, Cocoa et Cocoa Touch.
-
-```objective-c
-// Les commentaires unilignes commencent par //
-
-/*
-Les commentaires multilignes ressemblent à ça
-*/
-
-// Importe les en-têtes en utilisant #import
-// Utilisez <> pour importer des fichiers globaux (en général des frameworks)
-// Utilisez "" pour importer des fichiers locaux (du projet)
-#import <Foundation/Foundation.h>
-#import "MaClasse.h"
-
-// Si vous activez les modules pour les projects iOS >= 7 ou Mac OS X >= 10.9
-// dans Xcode 5 vous pouvez importer les frameworks comme cela :
-@import Foundation;
-
-// Le point d'entrée de votre programme est une fonction qui s'appelle main
-// et qui return un entier comme type
-int main (int argc, const char * argv[])
-{
-    // Créer un groupe de libération automatique de la mémoire pour l'ensemble
-    // du programme
-    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
-    // Si vous utilisez le comptage de référence automatique (ARC), utilisez
-    // @autoreleasepool à la place :
-    @autoreleasepool {
-
-    // Utilisez NSLog pour afficher les lignes sur la console
-    // Affiche la chaine de caractères "Bonjour Tous Le Monde !"
-    NSLog(@"Bonjour tous le Monde !"); 
- 
-    ///////////////////////////////////////
-    // Les Types & Les Variables
-    ///////////////////////////////////////
-    
-    // Déclarations de primitive
-    int maPrimitive1  = 1;
-    long maPrimitive2 = 234554664565;
-    
-    // Declarations d'objets
-    // Il faut mettre l'* devant la déclaration d'objets fortement typés
-    MaClasse *monObject1 = nil;  // Typage fort
-    id       monObject2  = nil;  // Typage faible
-    // %@ est un objet
-    // 'description' est une convention pour afficher la valeur des objets
-    NSLog(@"%@ and %@", monObject1, [monObject2 description]); // Affiche "(null) et (null)"
-    
-    // Chaines de caractères
-    NSString *chaineMonde = @"Monde";
-    NSLog(@"Bonjour tous le %@ !", chaineMonde); // affiche => "Bonjour Tous Le Monde !" 
-    // NSMutableString est une chaine mutable
-    NSMutableString *chaineMutable = [NSMutableString stringWithString:@"Bonjour tous le"];
-    [chaineMutable appendString:@" Monde !"];
-    NSLog(@"%@", chaineMutable); // affiche => "Bonjour Tous Le Monde !"
-    
-    // Les littéraux pour les caratères
-    NSNumber *laLettreZSousFormeDeNombre = @'Z';
-    char laLettreZ                       = [laLettreZSousFormeDeNombre charValue]; // ou 'Z'
-    NSLog(@"%c", laLettreZ);
-
-    // Les littéraux pour les nombres
-    NSNumber *nombreQuaranteDeux = @42;
-    int quaranteDeux             = [nombreQuaranteDeux intValue]; // ou 42
-    NSLog(@"%i", quaranteDeux);
-    
-    NSNumber *nombreQuaranteDeuxnonSigne = @42U;
-    unsigned int quaranteDeuxnonSigne    = [nombreQuaranteDeuxnonSigne unsignedIntValue];
-    NSLog(@"%u", fortyTwoUnsigned);
-    
-    NSNumber *nombreQuaranteDeuxCourt = [NSNumber numberWithShort:42];
-    short quaranteDeuxCourt           = [nombreQuaranteDeuxCourt shortValue]; // ou 42
-    NSLog(@"%hi", fortyTwoShort);
-    
-    NSNumber *nombreQuaranteDeuxLong = @42L;
-    long quaranteDeuxLong            = [nombreQuaranteDeuxLong longValue]; // ou 42
-    NSLog(@"%li", fortyTwoLong);
-
-    // Les littéraux pour les flottans
-    NSNumber *nombrePiFlottan = @3.141592654F;
-    float piFlottan           = [nombrePiFlottan floatValue]; // ou 3.141592654f
-    NSLog(@"%f", piFlottan); // affiche => 3.141592654
-    NSLog(@"%5.2f", piFlottan); // affiche => " 3.14"
-    
-    NSNumber *nombrePiDouble = @3.1415926535;
-    double piDouble          = [nombrePiDouble doubleValue]; // ou 3.1415926535
-    NSLog(@"%f", piDouble);
-    NSLog(@"%4.2f", piDouble); // affiche => "3.14"
-
-    // NSDecimalNumber est une classe pour avoir plus de précision sur les flottans
-    // et les doubles
-    NSDecimalNumber *decNumUn   = [NSDecimalNumber decimalNumberWithString:@"10.99"];
-    NSDecimalNumber *decNumDeux = [NSDecimalNumber decimalNumberWithString:@"5.002"];
-    // NSDecimalNumber n'est pas capable d'utiliser les opérations standards : 
-    // +, -, *, /, il utilise donc ses propres fonctions :
-    [decNumUn decimalNumberByAdding:decNumDeux]; 
-    [decNumUn decimalNumberBySubtracting:decNumDeux];
-    [decNumUn decimalNumberByMultiplyingBy:decNumDeux];
-    [decNumUn decimalNumberByDividingBy:decNumDeux];
-    NSLog(@"%@", decNumUn); // affiche => 10.99 comme NSDecimalNumber is immuable
-
-    // Les littéraux pour les booléens
-    NSNumber *ouiNumber = @YES;
-    NSNumber *nonNumber = @NO;
-    // ou
-    BOOL ouiBool = YES;
-    BOOL nonBool  = NO;
-    NSLog(@"%i", ouiBool); // affiche => 1
-
-    // Les listes
-    // Ils peuvent contenir différents types de données, mais ils doivent absolument 
-    // être des objets
-    NSArray *uneListe         = @[@1, @2, @3, @4];
-    NSNumber *troisiemeNombre = uneListe[2];
-    NSLog(@"Troisième nombre = %@", troisiemeNombre); // affiche "Troisième nombre = 3"
-    // NSMutableArray est une version mutable de NSArray qui permet de changer les
-    // objets dans la liste et l'étendre ou  la réduire
-    // C'est très pratique, mais pas aussi performant que l'utilsation de la classe
-    // NSArray
-    NSMutableArray *listeMutable = [NSMutableArray arrayWithCapacity:2];
-    [listeMutable addObject:@"Bonjour tous le"];
-    [listeMutable addObject:@"Monde"];
-    [listeMutable removeObjectAtIndex:0];
-    NSLog(@"%@", [listeMutable objectAtIndex:0]); // affiche => "Monde"
-
-    // Les dictionnaires
-    NSDictionary *unDictionnaire = @{ @"cle1" : @"valeur1", @"cle2" : @"valeur2" };
-    NSObject *valeur             = unDictionnaire[@"Une clé"];
-    NSLog(@"Objet = %@", valeur); // affiche "Objet = (null)"
-    // NSMutableDictionary est un dictionnaire mutable
-    NSMutableDictionary *dictionnaireMutable = [NSMutableDictionary dictionaryWithCapacity:2];
-    [dictionnaireMutable setObject:@"valeur1" forKey:@"cle1"];
-    [dictionnaireMutable setObject:@"valeur2" forKey:@"cle2"];
-    [dictionnaireMutable removeObjectForKey:@"cle1"];
-
-    // Les ensembles
-    NSSet *ensemble = [NSSet setWithObjects:@"Salut", @"Salut", @"Monde", nil];
-    NSLog(@"%@", ensemble); // affiche => {(Salut, Monde)} (peut être dans un ordre différente)
-    // NSMutableSet est un ensemble mutable 
-    NSMutableSet *ensembleMutable = [NSMutableSet setWithCapacity:2];
-    [ensembleMutable addObject:@"Salut"];
-    [ensembleMutable addObject:@"Salut"];
-    NSLog(@"%@", ensembleMutable); // affiche => {(Salut)}
-
-    ///////////////////////////////////////
-    // Operateurs
-    ///////////////////////////////////////
-    
-    // Les opérateurs sont les mêmes que ceux du langage C
-    // Par exemple :
-    2 + 5; // => 7
-    4.2f + 5.1f; // => 9.3f
-    3 == 2; // => 0 (NO)
-    3 != 2; // => 1 (YES)
-    1 && 1; // => 1 (et logique)
-    0 || 1; // => 1 (ou logique)
-    ~0x0F; // => 0xF0 (négation bit à bit)
-    0x0F & 0xF0; // => 0x00 (et bit à bit)
-    0x01 << 1; // => 0x02 (décale à gauche (par 1))
-
-    ///////////////////////////////////////
-    // Structures de controle
-    ///////////////////////////////////////
-
-    // Expression If-Else 
-    if (NO)
-    {
-        NSLog(@"Je ne suis jamais affiché");
-    } else if (0)
-    {
-        NSLog(@"Je ne suis jamais affiché aussi");
-    } else
-    {
-        NSLog(@"Je suis affiché");
-    }
-
-    // Expression Switch
-    switch (2)
-    {
-        case 0:
-        {
-            NSLog(@"Je ne suis jamais affiché");
-        } break;
-        case 1:
-        {
-            NSLog(@"Je ne suis jamais affiché aussi");
-        } break;
-        default:
-        {
-            NSLog(@"Je suis affiché");
-        } break;
-    }
-    
-    // Expression de boucle While
-    int ii = 0;
-    while (ii < 4)
-    {
-        NSLog(@"%d,", ii++); // ii++ incrémente ii après avoir utilisé sa valeure
-    } // => affiche "0," 
-      //            "1,"
-      //            "2,"
-      //            "3,"
-
-    // Expression de boucle For loops
-    int jj;
-    for (jj=0; jj < 4; jj++)
-    {
-        NSLog(@"%d,", jj);
-    } // => affiche "0," 
-      //            "1,"
-      //            "2,"
-      //            "3,"
-     
-    // Expression de boucle Foreach
-    NSArray *valeurs = @[@0, @1, @2, @3];
-    for (NSNumber *valeur in valeurs)
-    {
-        NSLog(@"%@,", valeur);
-    } // => affiche "0," 
-      //            "1,"
-      //            "2,"
-      //            "3,"
-
-    // Expressions Try-Catch-Finally
-    @try
-    {
-        @throw [NSException exceptionWithName:@"FileNotFoundException"
-                            reason:@"Fichier non trouvé" userInfo:nil];
-    } @catch (NSException * e)
-    {
-        NSLog(@"Exception : %@", e);
-    } @finally
-    {
-        NSLog(@"Finalement");
-    } // => affiche "Exceptio : Fichier non trouvé"
-      //            "Finalement"
- 
-    ///////////////////////////////////////
-    // Objets
-    ///////////////////////////////////////
-    
-    // Créez une instance d'objet en allouant un espace mémoire puis en l'initialisant
-    // Un objet n'est pas complétement fonctionnel jusqu'à ce que les deux étapes précédente
-    // ne sont pas fini
-    MaClass *monObjet = [[MaClass alloc] init];
-        
-    // Le modèle Objective-C est basé sur l'envoie de message et non sur les appels de
-    // méthodes comme la plupart des autres langage de programmation
-    [myObject instanceMethodWithParameter:@"Steve Jobs"];
-
-    // Nettoie la mémoire que vous avez utilisé dans votre programme
-    [pool drain];
-
-    // Fin the l'@autoreleasepool
-    }
-    
-    // Fin du programme
-    return 0;
-}
-
-///////////////////////////////////////
-// Classes et Fonctions
-///////////////////////////////////////
-
-// Déclarez votre classe dans une en-tête de fichier (MaClasse.h) :
-// La syntaxe de déclaration :
-// @interface NomDeLaClasse : NomDeLaClasseParent <ProtocolesImplemente>
-// {
-//    type nom; <= declarations de variable;
-// }
-// @property type nom; <= declarations de propriété.
-// -/+ (type) Methode declarations; <= Declarations de methodes. 
-// @end
-// NSObject est la classe de base de l'Objective-C
-@interface MaClasse : NSObject <MonProtocole>
-{
-    // Déclaration des variables d'instances (peut existé soit dans l'interface soir dans 
-    // l'implémentation)
-    int nombre; // Accès protégé par défaut
-    @private id donnee; // Accès privé (il est plus pratique de le faire dans l'implémentation)
-    NSString *nom; 
-}
-// Notation pratique pour l'accès aux variable public et pour générrer les 
-// accésseurs/affecteurs
-// Par défaut, le nom de l'affecteur vaut 'set' suivi par le nom de la @property
-@property int propInt; // Nom du setter = 'setPropInt'
-@property (copy) id copyId; // (copy) => Copie l'objet pendant l'affectation
-// (readonly) => Ne peut pas affecté la variable en dehors de l'@interface
-// Utilisez @synthesize dans l'@implementation pour créer l'accésseur
-@property (readonly) NSString *roString;
-// Vous pouvez personnaliser les noms des accésseurs et des affecteurs au lieu d'utiliser les
-// noms par défauts
-@property (getter=longeurGet, setter=longeurSet:) int longeur;
- 
-// Methodes
-+/- (type de retour)signatureDeLaMethode:(Type Du Parametre *)nomDuParametre;
-
-// + pour les méthodes de classe :
-+ (NSString *)methodeDeClasse;
-+ (MaClasse *)maClasseDepuisLaHauteur:(NSNumber *)hauteurParDefaut;
-
-// - pour les méthodes d'instances :
-- (NSString *)methodeInstanceAvecUnParametre:(NSString *)string;
-- (NSNumber *)methodeInstanceAvecUnParametre:(NSString*)string puisUnDeuxieme:(NSNumber *)number;
-
-// Contructeur avec des arguments :
-- (id)initAvecDistance:(int)distanceParDefault;
-// Les méthodes en Objective-C sont très descriptive
-
-@end // Définit la fin de l'interface
-
-
-// Exemple d'utilisation de MaClasse
-MaClasse *maClasse = [[MaClasse alloc] init]; // créer une instance de MaClasse
-[maClasse setNombre:10]; 
-NSLog(@"%d", [maClasse nombre]); // affiche => 10
-[myClass longeurSet:32];
-NSLog(@"%i", [maClasse longeurGet]); // affiche => 32
-// Pour des raisons pratiques vous pouvez aussi utiliser la notation en point pour accéder aux 
-// variables d'instances :
-maClasse.nombre = 45;
-NSLog(@"%i", maClasse.nombre); // maClasse => 45
-
-// Appeler un méthode de classe :
-NSString *s1 = [MaClasse methodeDeClasse];
-MaClasse *m2 = [MaClasse maClasseDepuisLaHauteur:38];
-
-// Appeler un méthode d'instance :
-MaClasse *maClasse = [[MaClasse alloc] init]; // Créer une instance de MaClasse
-NSString *stringDepuisUneInstanceDeMethode = [maClasse methodeInstanceAvecUnParametre:@"Salut"];
-
-// Sélecteurs sont un moyen de représenté les méthodes dynamiquement
-// Ils sont utilisé pour appeller des méthodes de classe, passer des methodes au travers de fonctions
-// pour notifier les autres classes qu'elle peuvent les appellé, et pour sauvegarder les méthodes en
-// tant que variables
-// SEL est un type de donnée. @selected retourne un selecteur à partir d'un nom de methode
-SEL selecteur = @selector(methodeInstanceAvecUnParametre:puisUnDeuxieme:); 
-if ([maClasse respondsToSelector:selecteur]) { // Vérifie si la classe contient la méthode
-    // Doit mettre tous les arguments de la méthode dans un seul objet pour l'envoyer via la fonction
-    // performSelector:withObject: 
-    NSArray *arguments = [NSArray arrayWithObjects:@"Hello", @4, nil];
-    [myClass performSelector:selectorVar withObject:arguments]; // Appele la méthode
-} else {
-    // NSStringFromSelector() retourne une chaine de charactères à partir d'un sélecteur
-    NSLog(@"MaClasse ne possède pas de méthode : %@", NSStringFromSelector(selecteur));
-}
-
-// Implement la méthode dans le fichier d'impémentation (MaClasse.m)
-@implementation MaClasse {
-    long distance; // Variable d'instance privé
-    NSNumber hauteur;
-}
-
-// Pour accéder à une variable depuis le fichier d'implémentation on peut utiliser le _ devant le nom
-// de la variable :
-_nombre = 5;
-// Accès d'une variable définit dans le fichier d'implémentation :
-distance = 18;
-// Pour utiliser la varible @property dans l'implémentation, utiliser @synthesize qui créer les 
-// accésseurs :
-@synthesize roString = _roString; // _roString est disponible dans l'@implementation
-
-// En contre-partie de l'initialisation, la fonction dealloc est appelé quand l'objet est n'est plus
-// utilisé
-- (void)dealloc
-{
-    [hauteur release]; // Si vous n'utilisez par l'ARC, pensez bien à supprimer l'objet 
-    [super dealloc];  // et à appeler la méthode de la classe parent 
-}
-
-// Les constructeurs sont une manière de créer des instances de classes
-// Ceci est le constructeur par défaut; il est appelé quand l'objet est créé
-- (id)init
-{
-    if ((self = [super init])) // 'super' est utilisé pour appeler la méthode de la classe parent
-    {
-        self.count = 1; // 'self' est utilisé pour appeler la méthodes de l'objet courrant
-    }
-    return self;
-}
-
-// Vous pouvez créer des constructeurs qui possèdent des arguments :
-- (id)initAvecUneDistance:(int)distanceParDefault 
-{
-    if ((self = [super init]))
-    {
-        distance = distanceParDefault;
-        return self;
-    }
-}
-
-+ (NSString *)methodDeClasse
-{
-    return [[self alloc] init];
-}
-
-+ (MaClasse *)maClasseDepuisUneHauteur:(NSNumber *)hauteurParDefaut
-{
-    hauteur = hauteurParDefaut;
-    return [[self alloc] init];
-}
-
-- (NSString *)methodeInstanceAvecUnParametre:(NSString *)string
-{
-    return @"Ma chaine de charactère";
-}
-
-- (NSNumber *)methodeInstanceAvecUnParametre:(NSString*)string puisUnDeuxieme:(NSNumber *)number
-{
-    return @42;
-}
-
-// Pour créer une méthode privée, il faut la définir dans l'@implementation et non pas dans 
-// l'@interface
-- (NSNumber *)methodePrivee
-{
-    return @72;
-}
-
-[self methodePrivee]; // Appel de la méthode privée
-
-// Méthode déclarée dans MonProtocole
-- (void)methodeDuProtocole
-{
-    // expressions
-}
-
-@end // Fin de l'implémentation
-
-/*
- * Un protocole déclare les méthodes qu'ils doivent implémenter afin de se conformer celui-ci
- * Un protocole n'est pas une classe, c'est juste une interface
- */
-@protocol MonProtocole
-    - (void)methodeDuProtocole;
-@end
-
-
-///////////////////////////////////////
-// Gestion de la mémoire
-///////////////////////////////////////
-/* 
-Pour chaque objet utilisé dans une application, la mémoire doit être alloué pour chacun d'entre eux.
-Quand l'application en a fini avec cet objet, la mémoire doit être libéré pour assurer la performane.
-Il n'y a pas de ramasse-miettes en Objective-C, il utilise à la place le comptage de référence à la
-place. Tant que le compteur de référence est supérieur à 1 sur un objet, l'objet ne sera pas supprimé
-
-Quand une instance détient un objet, le compteur de référence est incrémenté de un. Quand l'objet est
-libéré, le compteur est décrémenté de un. Quand le compteur est égale à zéro, l'objet est supprimé de
-la mémoire
-
-Une bonne pratique à suivre quand on travaille avec des objets est la suivante :
-(1) créer un objet, (2) utiliser l'objet, (3) supprimer l'objet de la mémoire
-*/
-
-MaClasse *classeVar = [MyClass alloc]; // 'alloc' incrémente le compteur de référence
-[classeVar release]; // Décrémente le compteur de rérence
-// 'retain' incrémente le compteur de référence
-// Si 'classeVar' est libéré, l'objet reste en mémoire car le compteur de référence est non nulle
-MaClasse *nouvelleVar = [classVar retain];
-[classeVar autorelease]; // Supprime l'appartenance de l'objet à la fin du block
-
-// @property peuvent utiliser 'retain' et 'assign' 
-@property (retain) MaClasse *instance; // Libère l'ancienne valeur et retient la nouvelle
-@property (assign) NSSet *set; // Pointeur vers la valeur sans retenir/libérer l'ancienne valeur
-
-// Automatic Reference Counting (ARC)
-// La gestion de la mémoire étant pénible, depuis iOS 4 et Xcode 4.2, Apple a introduit le comptage de référence
-// automatique (Automatic Reference Counting en anglais).
-// ARC est une fonctionnalité du compilateur qui lui permet d'ajouter les 'retain', 'release' et 'autorelease'
-// automatiquement. Donc quand utilisez ARC vous de devez plus utiliser ces mots clés
-MaClasse *arcMaClasse = [[MaClasse alloc] init]; 
-// ... code utilisant arcMaClasse
-// Sans ARC, vous auriez dû appeler [arcMaClasse release] après avoir utilisé l'objet. Mais avec ARC il n'y a plus
-// besoin car le compilateur ajoutera l'expréssion automatiquement pour vous
-
-// Les mots clés 'assign' et 'retain', avec ARC sont respectivement remplacé par 'weak' et 'strong'
-@property (weak) MaClasse *weakVar; // 'weak' ne retient pas l'objet. Si l'instance original descend à zero, weakVar
-// sera automatiquement mis à nil
-@property (strong) MaClasse *strongVar; // 'strong' prend posséssion de l'objet comme le ferai le mot clé 'retain'
-
-// Pour l'instanciation des variables (en dehors de @property), vous pouvez utiliser les instructions suivantes :
-__strong NSString *strongString; // Par defaut. La variable est retenu en mémoire jusqu'à la fin de sa portée
-__weak NSSet *weakSet; // Réfère la variable en utilisant le mot clé '__weak'
-__unsafe_unretained NSArray *unsafeArray; // Comme __weak, mais quand la variable n'est pas mis à nil quand l'objet
-// est supprimé ailleurs
-
-```
-##  Lectures Complémentaires
-
-[La Page Wikipedia de l'Objective-C](http://fr.wikipedia.org/wiki/Objective-C)
-
-[iOS pour les écoliers : Votre première app iOS](http://www.raywenderlich.com/fr/39272/ios-pour-les-ecoliers-votre-premiere-app-ios-partie-12)
-
-[Programming with Objective-C. Apple PDF book](https://developer.apple.com/library/ios/documentation/cocoa/conceptual/ProgrammingWithObjectiveC/ProgrammingWithObjectiveC.pdf)
\ No newline at end of file
-- 
cgit v1.2.3


From a759407f0b0da9784cf6c0f3865452d546c03da7 Mon Sep 17 00:00:00 2001
From: Yannick <yannick.loriot@gmail.com>
Date: Fri, 24 Jan 2014 20:00:45 +0100
Subject: [FIX] Typing Errors In The First Part

---
 fr-fr/objective-c-fr.html.markdown | 174 ++++++++++++++++++-------------------
 1 file changed, 87 insertions(+), 87 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/objective-c-fr.html.markdown b/fr-fr/objective-c-fr.html.markdown
index e6a8abfb..ca0b2391 100644
--- a/fr-fr/objective-c-fr.html.markdown
+++ b/fr-fr/objective-c-fr.html.markdown
@@ -11,27 +11,32 @@ filename: LearnObjectiveC.m
 
 ---
 
-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 framworks respectifs, Cocoa et Cocoa Touch.
+L'Objective-C est un langage de programmation orienté objet réflexif principalement utilisé par Apple pour les systèmes d'exploitations Mac OS X et iOS et leurs frameworks respectifs, Cocoa et Cocoa Touch.
 
 ```objective-c
-// Les commentaires unilignes commencent par //
+// Les commentaires sur une seule ligne commencent par //
 
 /*
-Les commentaires multilignes ressemblent à ça
+Les
+commentaires
+multi-lignes
+ressemblent
+à
+ceci
 */
 
-// Importe les en-têtes en utilisant #import
+// #import permet d'importer les en-têtes d'autres fichiers
 // Utilisez <> pour importer des fichiers globaux (en général des frameworks)
 // Utilisez "" pour importer des fichiers locaux (du projet)
 #import <Foundation/Foundation.h>
 #import "MaClasse.h"
 
-// Si vous activez les modules pour les projects iOS >= 7 ou Mac OS X >= 10.9
-// dans Xcode 5 vous pouvez importer les frameworks comme cela :
+// Si vous activez les modules dans les projets iOS >= 7 ou Mac OS X >= 10.9
+// dans Xcode 5, vous pouvez importer les frameworks comme cela :
 @import Foundation;
 
 // Le point d'entrée de votre programme est une fonction qui s'appelle main
-// et qui return un entier comme type
+// et qui retourne un entier comme type
 int main (int argc, const char * argv[])
 {
     // Créer un groupe de libération automatique de la mémoire pour l'ensemble
@@ -41,7 +46,7 @@ int main (int argc, const char * argv[])
     // @autoreleasepool à la place :
     @autoreleasepool {
 
-    // Utilisez NSLog pour afficher les lignes sur la console
+    // NSLog() permet d'afficher une chaine de caractères dans la console
     // Affiche la chaine de caractères "Bonjour Tous Le Monde !"
     NSLog(@"Bonjour tous le Monde !"); 
  
@@ -49,19 +54,19 @@ int main (int argc, const char * argv[])
     // Les Types & Les Variables
     ///////////////////////////////////////
     
-    // Déclarations de primitive
+    // La déclaration de primitive
     int maPrimitive1  = 1;
     long maPrimitive2 = 234554664565;
     
-    // Declarations d'objets
-    // Il faut mettre l'* devant la déclaration d'objets fortement typés
+    // La déclaration d'objet
+    // Il faut mettre un astérisque devant la déclaration d'objet fortement typé
     MaClasse *monObject1 = nil;  // Typage fort
     id       monObject2  = nil;  // Typage faible
-    // %@ est un objet
-    // 'description' est une convention pour afficher la valeur des objets
+    // 'description' est une méthode qui permet d'afficher un aperçut de l'objet
+    // La méthode 'description' est appelée par défaut quand on utilise le paramètre '%@'
     NSLog(@"%@ and %@", monObject1, [monObject2 description]); // Affiche "(null) et (null)"
     
-    // Chaines de caractères
+    // Les chaines de caractères
     NSString *chaineMonde = @"Monde";
     NSLog(@"Bonjour tous le %@ !", chaineMonde); // affiche => "Bonjour Tous Le Monde !" 
     // NSMutableString est une chaine mutable
@@ -69,12 +74,12 @@ int main (int argc, const char * argv[])
     [chaineMutable appendString:@" Monde !"];
     NSLog(@"%@", chaineMutable); // affiche => "Bonjour Tous Le Monde !"
     
-    // Les littéraux pour les caratères
+    // Les caractères
     NSNumber *laLettreZSousFormeDeNombre = @'Z';
     char laLettreZ                       = [laLettreZSousFormeDeNombre charValue]; // ou 'Z'
     NSLog(@"%c", laLettreZ);
 
-    // Les littéraux pour les nombres
+    // Les nombres
     NSNumber *nombreQuaranteDeux = @42;
     int quaranteDeux             = [nombreQuaranteDeux intValue]; // ou 42
     NSLog(@"%i", quaranteDeux);
@@ -91,7 +96,7 @@ int main (int argc, const char * argv[])
     long quaranteDeuxLong            = [nombreQuaranteDeuxLong longValue]; // ou 42
     NSLog(@"%li", fortyTwoLong);
 
-    // Les littéraux pour les flottans
+    // Les nombres flottans
     NSNumber *nombrePiFlottan = @3.141592654F;
     float piFlottan           = [nombrePiFlottan floatValue]; // ou 3.141592654f
     NSLog(@"%f", piFlottan); // affiche => 3.141592654
@@ -102,19 +107,19 @@ int main (int argc, const char * argv[])
     NSLog(@"%f", piDouble);
     NSLog(@"%4.2f", piDouble); // affiche => "3.14"
 
-    // NSDecimalNumber est une classe pour avoir plus de précision sur les flottans
-    // et les doubles
+    // NSDecimalNumber est une classe pour avoir plus de précision sur les nombres
+    // flottans et les doubles
     NSDecimalNumber *decNumUn   = [NSDecimalNumber decimalNumberWithString:@"10.99"];
     NSDecimalNumber *decNumDeux = [NSDecimalNumber decimalNumberWithString:@"5.002"];
-    // NSDecimalNumber n'est pas capable d'utiliser les opérations standards : 
-    // +, -, *, /, il utilise donc ses propres fonctions :
+    // NSDecimalNumber n'est pas capable d'utiliser les opérations standards (+, -, *, /)
+    // Il faut utiliser les méthodes suivantes :
     [decNumUn decimalNumberByAdding:decNumDeux]; 
     [decNumUn decimalNumberBySubtracting:decNumDeux];
     [decNumUn decimalNumberByMultiplyingBy:decNumDeux];
     [decNumUn decimalNumberByDividingBy:decNumDeux];
-    NSLog(@"%@", decNumUn); // affiche => 10.99 comme NSDecimalNumber is immuable
+    NSLog(@"%@", decNumUn); // affiche => 10.99 comme NSDecimalNumber est immuable
 
-    // Les littéraux pour les booléens
+    // Les booléens
     NSNumber *ouiNumber = @YES;
     NSNumber *nonNumber = @NO;
     // ou
@@ -123,15 +128,13 @@ int main (int argc, const char * argv[])
     NSLog(@"%i", ouiBool); // affiche => 1
 
     // Les listes
-    // Ils peuvent contenir différents types de données, mais ils doivent absolument 
-    // être des objets
+    // Une liste peut contenir uniquement des objets
     NSArray *uneListe         = @[@1, @2, @3, @4];
     NSNumber *troisiemeNombre = uneListe[2];
     NSLog(@"Troisième nombre = %@", troisiemeNombre); // affiche "Troisième nombre = 3"
-    // NSMutableArray est une version mutable de NSArray qui permet de changer les
-    // objets dans la liste et l'étendre ou  la réduire
-    // C'est très pratique, mais pas aussi performant que l'utilsation de la classe
-    // NSArray
+    // NSMutableArray est une version mutable de NSArray
+    // Cela permet de modifier la liste en ajoutant/supprimant/modifiant des objets
+    // C'est très pratique, mais pas aussi performant que l'utilisation de la classe NSArray
     NSMutableArray *listeMutable = [NSMutableArray arrayWithCapacity:2];
     [listeMutable addObject:@"Bonjour tous le"];
     [listeMutable addObject:@"Monde"];
@@ -139,18 +142,20 @@ int main (int argc, const char * argv[])
     NSLog(@"%@", [listeMutable objectAtIndex:0]); // affiche => "Monde"
 
     // Les dictionnaires
+    // Un dictionnaire est un ensemble de { clé: valeur }
     NSDictionary *unDictionnaire = @{ @"cle1" : @"valeur1", @"cle2" : @"valeur2" };
     NSObject *valeur             = unDictionnaire[@"Une clé"];
     NSLog(@"Objet = %@", valeur); // affiche "Objet = (null)"
-    // NSMutableDictionary est un dictionnaire mutable
+    // NSMutableDictionary est un dictionnaire mutable, c-à-d que l'on peut modifier
     NSMutableDictionary *dictionnaireMutable = [NSMutableDictionary dictionaryWithCapacity:2];
     [dictionnaireMutable setObject:@"valeur1" forKey:@"cle1"];
     [dictionnaireMutable setObject:@"valeur2" forKey:@"cle2"];
     [dictionnaireMutable removeObjectForKey:@"cle1"];
 
     // Les ensembles
+    // Un ensemble peut ne peut contenir que des objets uniques contrairement aux NSArray
     NSSet *ensemble = [NSSet setWithObjects:@"Salut", @"Salut", @"Monde", nil];
-    NSLog(@"%@", ensemble); // affiche => {(Salut, Monde)} (peut être dans un ordre différente)
+    NSLog(@"%@", ensemble); // affiche => {(Salut, Monde)} (Pas forcément dans le même ordre)
     // NSMutableSet est un ensemble mutable 
     NSMutableSet *ensembleMutable = [NSMutableSet setWithCapacity:2];
     [ensembleMutable addObject:@"Salut"];
@@ -158,7 +163,7 @@ int main (int argc, const char * argv[])
     NSLog(@"%@", ensembleMutable); // affiche => {(Salut)}
 
     ///////////////////////////////////////
-    // Operateurs
+    // Les Operateurs
     ///////////////////////////////////////
     
     // Les opérateurs sont les mêmes que ceux du langage C
@@ -174,10 +179,10 @@ int main (int argc, const char * argv[])
     0x01 << 1; // => 0x02 (décale à gauche (par 1))
 
     ///////////////////////////////////////
-    // Structures de controle
+    // Les Structures de Controle
     ///////////////////////////////////////
 
-    // Expression If-Else 
+    // Expression "Si-Sinon" (If-Else) 
     if (NO)
     {
         NSLog(@"Je ne suis jamais affiché");
@@ -189,7 +194,7 @@ int main (int argc, const char * argv[])
         NSLog(@"Je suis affiché");
     }
 
-    // Expression Switch
+    // Expression "Selon" (Switch)
     switch (2)
     {
         case 0:
@@ -206,17 +211,17 @@ int main (int argc, const char * argv[])
         } break;
     }
     
-    // Expression de boucle While
+    // Expression de boucle "Tant Que" (While)
     int ii = 0;
     while (ii < 4)
     {
-        NSLog(@"%d,", ii++); // ii++ incrémente ii après avoir utilisé sa valeure
+        NSLog(@"%d,", ii++); // ii++ incrémente ii après avoir utilisé sa valeur
     } // => affiche "0," 
       //            "1,"
       //            "2,"
       //            "3,"
 
-    // Expression de boucle For loops
+    // Expression de boucle "Pour" (For)
     int jj;
     for (jj=0; jj < 4; jj++)
     {
@@ -226,7 +231,7 @@ int main (int argc, const char * argv[])
       //            "2,"
       //            "3,"
      
-    // Expression de boucle Foreach
+    // Expression de boucle "Pour Chaque" (Foreach)
     NSArray *valeurs = @[@0, @1, @2, @3];
     for (NSNumber *valeur in valeurs)
     {
@@ -236,37 +241,37 @@ int main (int argc, const char * argv[])
       //            "2,"
       //            "3,"
 
-    // Expressions Try-Catch-Finally
+    // Expression "Essayer-Attraper-Finalement" (Try-Catch-Finally)
     @try
     {
         @throw [NSException exceptionWithName:@"FileNotFoundException"
                             reason:@"Fichier non trouvé" userInfo:nil];
     } @catch (NSException * e)
     {
-        NSLog(@"Exception : %@", e);
+        NSLog(@"Une exception est survenue : %@", e);
     } @finally
     {
         NSLog(@"Finalement");
-    } // => affiche "Exceptio : Fichier non trouvé"
+    } // => affiche "Une exception est survenue : Fichier non trouvé"
       //            "Finalement"
  
     ///////////////////////////////////////
-    // Objets
+    // Les Objets
     ///////////////////////////////////////
     
-    // Créez une instance d'objet en allouant un espace mémoire puis en l'initialisant
-    // Un objet n'est pas complétement fonctionnel jusqu'à ce que les deux étapes précédente
-    // ne sont pas fini
+    // Définis et créé une instance d'objet en allouant un espace mémoire puis en
+    // l'initialisant. Un objet n'est pas complétement fonctionnel tant que les deux
+    // étapes précédentes ne sont pas terminées
     MaClass *monObjet = [[MaClass alloc] init];
         
-    // Le modèle Objective-C est basé sur l'envoie de message et non sur les appels de
-    // méthodes comme la plupart des autres langage de programmation
+    // L'Objective-C est basé sur le principe d'envoie de message et non sur celui
+    // d'appel de méthode comme la plupart des autres langages de programmation
     [myObject instanceMethodWithParameter:@"Steve Jobs"];
 
-    // Nettoie la mémoire que vous avez utilisé dans votre programme
+    // Nettoie la mémoire qui a été utilisée dans le programme
     [pool drain];
 
-    // Fin the l'@autoreleasepool
+    // Fin de l'@autoreleasepool
     }
     
     // Fin du programme
@@ -274,58 +279,54 @@ int main (int argc, const char * argv[])
 }
 
 ///////////////////////////////////////
-// Classes et Fonctions
+// Les Classes et Les Fonctions
 ///////////////////////////////////////
 
-// Déclarez votre classe dans une en-tête de fichier (MaClasse.h) :
-// La syntaxe de déclaration :
-// @interface NomDeLaClasse : NomDeLaClasseParent <ProtocolesImplemente>
+// Déclaration d'une classe dans un en-tête de fichier (MaClasse.h) :
+// La déclaration d'une classe en Objective-C commence par la déclaration de son interface :
+// @interface NomDeLaClasse : NomDeLaClasseParent <ListeDesProtocoles>
 // {
-//    type nom; <= declarations de variable;
+//    type nom; // declaration d'une variable;
 // }
-// @property type nom; <= declarations de propriété.
-// -/+ (type) Methode declarations; <= Declarations de methodes. 
-// @end
-// NSObject est la classe de base de l'Objective-C
+// @property type nom; // declaration d'une propriété
+// -/+ (type)nomDeLaMethode; // Declaration d'une methode
+// @end // Termine la déclaration
+// NSObject est la classe de base (super classe) en Objective-C
 @interface MaClasse : NSObject <MonProtocole>
 {
-    // Déclaration des variables d'instances (peut existé soit dans l'interface soir dans 
-    // l'implémentation)
-    int nombre; // Accès protégé par défaut
+    int nombre; // Accès protégé par défaut (équivalent à '@protected int nombre;')
     @private id donnee; // Accès privé (il est plus pratique de le faire dans l'implémentation)
     NSString *nom; 
 }
-// Notation pratique pour l'accès aux variable public et pour générrer les 
-// accésseurs/affecteurs
-// Par défaut, le nom de l'affecteur vaut 'set' suivi par le nom de la @property
-@property int propInt; // Nom du setter = 'setPropInt'
+// Les propriétés permettent de générrer les accésseurs/affecteurs publiques à la compilation
+// Par défaut, le nom de l'affecteur est la chaine 'set' suivi par le nom de la @property
+@property int propInt; // Nom de l'affecteur = 'setPropInt'
 @property (copy) id copyId; // (copy) => Copie l'objet pendant l'affectation
 // (readonly) => Ne peut pas affecté la variable en dehors de l'@interface
-// Utilisez @synthesize dans l'@implementation pour créer l'accésseur
+// Il faut utiliser le mot clé '@synthesize' dans l'@implementation pour créer l'accésseur
 @property (readonly) NSString *roString;
-// Vous pouvez personnaliser les noms des accésseurs et des affecteurs au lieu d'utiliser les
-// noms par défauts
+// Vous pouvez aussi personnaliser les noms des accésseurs ou des affecteurs
 @property (getter=longeurGet, setter=longeurSet:) int longeur;
  
 // Methodes
-+/- (type de retour)signatureDeLaMethode:(Type Du Parametre *)nomDuParametre;
++/- (TypeDeRetour)signatureDeLaMethode:(TypeDuParametre *)nomDuParametre;
 
-// + pour les méthodes de classe :
+// '+' signifie que c'est une méthode de classe (statique) :
 + (NSString *)methodeDeClasse;
 + (MaClasse *)maClasseDepuisLaHauteur:(NSNumber *)hauteurParDefaut;
 
-// - pour les méthodes d'instances :
+// '-' pour les méthodes d'instances (classe) :
 - (NSString *)methodeInstanceAvecUnParametre:(NSString *)string;
 - (NSNumber *)methodeInstanceAvecUnParametre:(NSString*)string puisUnDeuxieme:(NSNumber *)number;
 
 // Contructeur avec des arguments :
 - (id)initAvecDistance:(int)distanceParDefault;
-// Les méthodes en Objective-C sont très descriptive
+// Les méthodes en Objective-C sont très descriptives
 
-@end // Définit la fin de l'interface
+@end // Fin de l'interface
 
 
-// Exemple d'utilisation de MaClasse
+// Voici un exemple d'utilisation de MaClasse
 MaClasse *maClasse = [[MaClasse alloc] init]; // créer une instance de MaClasse
 [maClasse setNombre:10]; 
 NSLog(@"%d", [maClasse nombre]); // affiche => 10
@@ -336,27 +337,26 @@ NSLog(@"%i", [maClasse longeurGet]); // affiche => 32
 maClasse.nombre = 45;
 NSLog(@"%i", maClasse.nombre); // maClasse => 45
 
-// Appeler un méthode de classe :
+// Pour appeler une méthode de classe :
 NSString *s1 = [MaClasse methodeDeClasse];
 MaClasse *m2 = [MaClasse maClasseDepuisLaHauteur:38];
 
-// Appeler un méthode d'instance :
+// Pour appeler une méthode d'instance :
 MaClasse *maClasse = [[MaClasse alloc] init]; // Créer une instance de MaClasse
 NSString *stringDepuisUneInstanceDeMethode = [maClasse methodeInstanceAvecUnParametre:@"Salut"];
 
-// Sélecteurs sont un moyen de représenté les méthodes dynamiquement
-// Ils sont utilisé pour appeller des méthodes de classe, passer des methodes au travers de fonctions
-// pour notifier les autres classes qu'elle peuvent les appellé, et pour sauvegarder les méthodes en
-// tant que variables
-// SEL est un type de donnée. @selected retourne un selecteur à partir d'un nom de methode
+// les sélecteurs sont un moyen de décrire les méthodes dynamiquement
+// Ils sont utilisés pour appeler des méthodes de classe et avoir des pointeurs de fonctions
+// facilement manipulable
+// SEL est un type de donnée et @selector retourne un selecteur à partir d'un nom de methode
 SEL selecteur = @selector(methodeInstanceAvecUnParametre:puisUnDeuxieme:); 
-if ([maClasse respondsToSelector:selecteur]) { // Vérifie si la classe contient la méthode
-    // Doit mettre tous les arguments de la méthode dans un seul objet pour l'envoyer via la fonction
+if ([maClasse respondsToSelector:selecteur]) { // Vérifie si la classe possède la méthode
+    // Met les arguments de la méthode dans un seul objet pour l'envoyer via la fonction
     // performSelector:withObject: 
     NSArray *arguments = [NSArray arrayWithObjects:@"Hello", @4, nil];
-    [myClass performSelector:selectorVar withObject:arguments]; // Appele la méthode
+    [myClass performSelector:selectorVar withObject:arguments]; // Appele la méthode via le sélecteur
 } else {
-    // NSStringFromSelector() retourne une chaine de charactères à partir d'un sélecteur
+    // NSStringFromSelector() retourne une chaine de caractères à partir d'un sélecteur
     NSLog(@"MaClasse ne possède pas de méthode : %@", NSStringFromSelector(selecteur));
 }
 
@@ -417,7 +417,7 @@ distance = 18;
 
 - (NSString *)methodeInstanceAvecUnParametre:(NSString *)string
 {
-    return @"Ma chaine de charactère";
+    return @"Ma chaine de caractère";
 }
 
 - (NSNumber *)methodeInstanceAvecUnParametre:(NSString*)string puisUnDeuxieme:(NSNumber *)number
-- 
cgit v1.2.3


From 409317cf25c28dc9a034e0b23b7e284d73dd97e6 Mon Sep 17 00:00:00 2001
From: Yannick <yannick.loriot@gmail.com>
Date: Fri, 24 Jan 2014 20:19:22 +0100
Subject: [FIX] Typing Errors In The Second Part

---
 fr-fr/objective-c-fr.html.markdown | 63 +++++++++++++++++++++-----------------
 1 file changed, 35 insertions(+), 28 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/objective-c-fr.html.markdown b/fr-fr/objective-c-fr.html.markdown
index ca0b2391..d0e6f3eb 100644
--- a/fr-fr/objective-c-fr.html.markdown
+++ b/fr-fr/objective-c-fr.html.markdown
@@ -315,7 +315,7 @@ int main (int argc, const char * argv[])
 + (NSString *)methodeDeClasse;
 + (MaClasse *)maClasseDepuisLaHauteur:(NSNumber *)hauteurParDefaut;
 
-// '-' pour les méthodes d'instances (classe) :
+// '-' pour les méthodes d'instances :
 - (NSString *)methodeInstanceAvecUnParametre:(NSString *)string;
 - (NSNumber *)methodeInstanceAvecUnParametre:(NSString*)string puisUnDeuxieme:(NSNumber *)number;
 
@@ -355,46 +355,48 @@ if ([maClasse respondsToSelector:selecteur]) { // Vérifie si la classe possède
     // performSelector:withObject: 
     NSArray *arguments = [NSArray arrayWithObjects:@"Hello", @4, nil];
     [myClass performSelector:selectorVar withObject:arguments]; // Appele la méthode via le sélecteur
-} else {
+}
+else {
     // NSStringFromSelector() retourne une chaine de caractères à partir d'un sélecteur
     NSLog(@"MaClasse ne possède pas de méthode : %@", NSStringFromSelector(selecteur));
 }
 
-// Implement la méthode dans le fichier d'impémentation (MaClasse.m)
+// Le fichier d'implémentation de la classe MaClasse (MaClasse.m) doit commencer comme ceci :
 @implementation MaClasse {
-    long distance; // Variable d'instance privé
+    long distance; // Variable d'instance privé (équivalent à @private dans l'interface)
     NSNumber hauteur;
 }
 
-// Pour accéder à une variable depuis le fichier d'implémentation on peut utiliser le _ devant le nom
+// Pour accéder à une variable depuis l'implémentation on peut utiliser le _ (tiret bas) devant le nom
 // de la variable :
 _nombre = 5;
-// Accès d'une variable définit dans le fichier d'implémentation :
+// Accès d'une variable défini dans le fichier d'implémentation :
 distance = 18;
-// Pour utiliser la varible @property dans l'implémentation, utiliser @synthesize qui créer les 
-// accésseurs :
-@synthesize roString = _roString; // _roString est disponible dans l'@implementation
+// Pour utiliser la variable défini par l'intermédiaire de @property, il faut utiliser @synthesize 
+// qui permet de créer les affecteurs et les accésseurs :
+@synthesize roString = _roString; // _roString est maintenant disponible dans l'implementation
 
-// En contre-partie de l'initialisation, la fonction dealloc est appelé quand l'objet est n'est plus
-// utilisé
+// En contre-partie de l'appel de la fonction 'init' lors de la création d'un objet, la fonction 
+// 'dealloc' est appelée quand l'objet est supprimé
 - (void)dealloc
 {
-    [hauteur release]; // Si vous n'utilisez par l'ARC, pensez bien à supprimer l'objet 
-    [super dealloc];  // et à appeler la méthode de la classe parent 
+    [hauteur release]; // Si vous n'utilisez pas ARC, pensez bien à supprimer l'objet 
+    [super dealloc];   // et à appeler la méthode 'dealloc' de la classe parent 
 }
 
 // Les constructeurs sont une manière de créer des instances de classes
-// Ceci est le constructeur par défaut; il est appelé quand l'objet est créé
+// 'init' est le constructeur par défaut; il est appelé quand l'objet est créé
 - (id)init
 {
     if ((self = [super init])) // 'super' est utilisé pour appeler la méthode de la classe parent
     {
-        self.count = 1; // 'self' est utilisé pour appeler la méthodes de l'objet courrant
+        self.count = 1; // 'self' est utilisé pour appeler la méthodes de l'instance courante
     }
     return self;
 }
 
-// Vous pouvez créer des constructeurs qui possèdent des arguments :
+// Vous pouvez aussi créer des constructeurs qui possèdent des arguments
+// Attention : chaque nom de constructeur doit absolument commencer par 'init'
 - (id)initAvecUneDistance:(int)distanceParDefault 
 {
     if ((self = [super init]))
@@ -404,6 +406,7 @@ distance = 18;
     }
 }
 
+// Implémentation d'une méthode de classe
 + (NSString *)methodDeClasse
 {
     return [[self alloc] init];
@@ -415,6 +418,7 @@ distance = 18;
     return [[self alloc] init];
 }
 
+// Implémentation d'une méthode d'instance
 - (NSString *)methodeInstanceAvecUnParametre:(NSString *)string
 {
     return @"Ma chaine de caractère";
@@ -425,8 +429,8 @@ distance = 18;
     return @42;
 }
 
-// Pour créer une méthode privée, il faut la définir dans l'@implementation et non pas dans 
-// l'@interface
+// Pour créer une méthode privée, il faut la définir dans l'implementation et non pas dans 
+// l'interface
 - (NSNumber *)methodePrivee
 {
     return @72;
@@ -434,7 +438,7 @@ distance = 18;
 
 [self methodePrivee]; // Appel de la méthode privée
 
-// Méthode déclarée dans MonProtocole
+// Implémentation d'une méthode qui est déclarée dans <MonProtocole>
 - (void)methodeDuProtocole
 {
     // expressions
@@ -443,7 +447,8 @@ distance = 18;
 @end // Fin de l'implémentation
 
 /*
- * Un protocole déclare les méthodes qu'ils doivent implémenter afin de se conformer celui-ci
+ * Un protocole déclare des méthodes que chaque objet respectant celui-ci doit implémenter
+ * afin de se conformer celui-ci
  * Un protocole n'est pas une classe, c'est juste une interface
  */
 @protocol MonProtocole
@@ -455,14 +460,16 @@ distance = 18;
 // Gestion de la mémoire
 ///////////////////////////////////////
 /* 
-Pour chaque objet utilisé dans une application, la mémoire doit être alloué pour chacun d'entre eux.
-Quand l'application en a fini avec cet objet, la mémoire doit être libéré pour assurer la performane.
-Il n'y a pas de ramasse-miettes en Objective-C, il utilise à la place le comptage de référence à la
-place. Tant que le compteur de référence est supérieur à 1 sur un objet, l'objet ne sera pas supprimé
-
-Quand une instance détient un objet, le compteur de référence est incrémenté de un. Quand l'objet est
-libéré, le compteur est décrémenté de un. Quand le compteur est égale à zéro, l'objet est supprimé de
-la mémoire
+A chaque fois qu'un objet est créé dans l'application, un bloque mémoire doit être alloué.
+Quand l'application en a fini avec cet objet, la mémoire doit être libéré pour assurer la bonne 
+réactivité du programme (éviter les fuites mémoires)
+Il n'y a pas de ramasse-miettes en Objective-C contrairement à Java par example. L'Objective-C repose
+sur le comptage de référence. A chaque objet est assigné un compteur qui permet de connaitre son état.
+
+Le principe est le suivant :
+Lorsque l'objet est créé, le compteur est initialisé à 1. Quand une instance détient un objet, le
+compteur est incrémenté de un. Quand l'objet est libéré, le compteur est décrémenté de un. Enfin 
+quand le compteur arrive à zéro, l'objet est supprimé de la mémoire
 
 Une bonne pratique à suivre quand on travaille avec des objets est la suivante :
 (1) créer un objet, (2) utiliser l'objet, (3) supprimer l'objet de la mémoire
-- 
cgit v1.2.3


From dc8f3cbe30a8271f4be809ce17d68d146ee53f88 Mon Sep 17 00:00:00 2001
From: Yannick <yannick.loriot@gmail.com>
Date: Fri, 24 Jan 2014 22:07:09 +0100
Subject: [FIX] typo with the help of @Nami-Doc

---
 fr-fr/objective-c-fr.html.markdown | 138 ++++++++++++++++++++-----------------
 1 file changed, 74 insertions(+), 64 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/objective-c-fr.html.markdown b/fr-fr/objective-c-fr.html.markdown
index d0e6f3eb..b14b3a52 100644
--- a/fr-fr/objective-c-fr.html.markdown
+++ b/fr-fr/objective-c-fr.html.markdown
@@ -62,7 +62,7 @@ int main (int argc, const char * argv[])
     // Il faut mettre un astérisque devant la déclaration d'objet fortement typé
     MaClasse *monObject1 = nil;  // Typage fort
     id       monObject2  = nil;  // Typage faible
-    // 'description' est une méthode qui permet d'afficher un aperçut de l'objet
+    // 'description' est une méthode qui permet de retourner un aperçut de l'objet sous forme textuelle
     // La méthode 'description' est appelée par défaut quand on utilise le paramètre '%@'
     NSLog(@"%@ and %@", monObject1, [monObject2 description]); // Affiche "(null) et (null)"
     
@@ -96,11 +96,11 @@ int main (int argc, const char * argv[])
     long quaranteDeuxLong            = [nombreQuaranteDeuxLong longValue]; // ou 42
     NSLog(@"%li", fortyTwoLong);
 
-    // Les nombres flottans
-    NSNumber *nombrePiFlottan = @3.141592654F;
-    float piFlottan           = [nombrePiFlottan floatValue]; // ou 3.141592654f
-    NSLog(@"%f", piFlottan); // affiche => 3.141592654
-    NSLog(@"%5.2f", piFlottan); // affiche => " 3.14"
+    // Les nombres flottants
+    NSNumber *nombrePiFlottant = @3.141592654F;
+    float piFlottant           = [nombrePiFlottant floatValue]; // ou 3.141592654f
+    NSLog(@"%f", piFlottant); // affiche => 3.141592654
+    NSLog(@"%5.2f", piFlottant); // affiche => " 3.14"
     
     NSNumber *nombrePiDouble = @3.1415926535;
     double piDouble          = [nombrePiDouble doubleValue]; // ou 3.1415926535
@@ -108,11 +108,11 @@ int main (int argc, const char * argv[])
     NSLog(@"%4.2f", piDouble); // affiche => "3.14"
 
     // NSDecimalNumber est une classe pour avoir plus de précision sur les nombres
-    // flottans et les doubles
+    // flottants et les doubles
     NSDecimalNumber *decNumUn   = [NSDecimalNumber decimalNumberWithString:@"10.99"];
     NSDecimalNumber *decNumDeux = [NSDecimalNumber decimalNumberWithString:@"5.002"];
-    // NSDecimalNumber n'est pas capable d'utiliser les opérations standards (+, -, *, /)
-    // Il faut utiliser les méthodes suivantes :
+    // NSDecimalNumber ne permet pas d'utiliser les opérations standards (+, -, *, /)
+    // Il faut utiliser les méthodes suivantes à la place :
     [decNumUn decimalNumberByAdding:decNumDeux]; 
     [decNumUn decimalNumberBySubtracting:decNumDeux];
     [decNumUn decimalNumberByMultiplyingBy:decNumDeux];
@@ -133,7 +133,8 @@ int main (int argc, const char * argv[])
     NSNumber *troisiemeNombre = uneListe[2];
     NSLog(@"Troisième nombre = %@", troisiemeNombre); // affiche "Troisième nombre = 3"
     // NSMutableArray est une version mutable de NSArray
-    // Cela permet de modifier la liste en ajoutant/supprimant/modifiant des objets
+    // Cela permet de modifier la liste en ajoutant de nouveaux éléments et en supprimant ou
+    // changeant de place des objets déjà présent
     // C'est très pratique, mais pas aussi performant que l'utilisation de la classe NSArray
     NSMutableArray *listeMutable = [NSMutableArray arrayWithCapacity:2];
     [listeMutable addObject:@"Bonjour tous le"];
@@ -142,7 +143,7 @@ int main (int argc, const char * argv[])
     NSLog(@"%@", [listeMutable objectAtIndex:0]); // affiche => "Monde"
 
     // Les dictionnaires
-    // Un dictionnaire est un ensemble de { clé: valeur }
+    // Un dictionnaire est un ensemble de clés : valeurs
     NSDictionary *unDictionnaire = @{ @"cle1" : @"valeur1", @"cle2" : @"valeur2" };
     NSObject *valeur             = unDictionnaire[@"Une clé"];
     NSLog(@"Objet = %@", valeur); // affiche "Objet = (null)"
@@ -153,7 +154,7 @@ int main (int argc, const char * argv[])
     [dictionnaireMutable removeObjectForKey:@"cle1"];
 
     // Les ensembles
-    // Un ensemble peut ne peut contenir que des objets uniques contrairement aux NSArray
+    // Un ensemble ne peut contenir de duplicatas contrairement aux NSArray
     NSSet *ensemble = [NSSet setWithObjects:@"Salut", @"Salut", @"Monde", nil];
     NSLog(@"%@", ensemble); // affiche => {(Salut, Monde)} (Pas forcément dans le même ordre)
     // NSMutableSet est un ensemble mutable 
@@ -166,7 +167,7 @@ int main (int argc, const char * argv[])
     // Les Operateurs
     ///////////////////////////////////////
     
-    // Les opérateurs sont les mêmes que ceux du langage C
+    // Les opérateurs sont pareil qu'en C
     // Par exemple :
     2 + 5; // => 7
     4.2f + 5.1f; // => 9.3f
@@ -176,13 +177,13 @@ int main (int argc, const char * argv[])
     0 || 1; // => 1 (ou logique)
     ~0x0F; // => 0xF0 (négation bit à bit)
     0x0F & 0xF0; // => 0x00 (et bit à bit)
-    0x01 << 1; // => 0x02 (décale à gauche (par 1))
+    0x01 << 1; // => 0x02 (décalage à gauche (par 1))
 
     ///////////////////////////////////////
-    // Les Structures de Controle
+    // Les Structures de Contrôle
     ///////////////////////////////////////
 
-    // Expression "Si-Sinon" (If-Else) 
+    // Structure "Si-Sinon" (If-Else) 
     if (NO)
     {
         NSLog(@"Je ne suis jamais affiché");
@@ -194,7 +195,7 @@ int main (int argc, const char * argv[])
         NSLog(@"Je suis affiché");
     }
 
-    // Expression "Selon" (Switch)
+    // Structure "Selon" (Switch)
     switch (2)
     {
         case 0:
@@ -211,7 +212,7 @@ int main (int argc, const char * argv[])
         } break;
     }
     
-    // Expression de boucle "Tant Que" (While)
+    // Structure de boucle "Tant Que" (While)
     int ii = 0;
     while (ii < 4)
     {
@@ -221,7 +222,7 @@ int main (int argc, const char * argv[])
       //            "2,"
       //            "3,"
 
-    // Expression de boucle "Pour" (For)
+    // Structure de boucle "Pour" (For)
     int jj;
     for (jj=0; jj < 4; jj++)
     {
@@ -231,7 +232,7 @@ int main (int argc, const char * argv[])
       //            "2,"
       //            "3,"
      
-    // Expression de boucle "Pour Chaque" (Foreach)
+    // Structure de boucle "Pour Chaque" (Foreach)
     NSArray *valeurs = @[@0, @1, @2, @3];
     for (NSNumber *valeur in valeurs)
     {
@@ -241,7 +242,7 @@ int main (int argc, const char * argv[])
       //            "2,"
       //            "3,"
 
-    // Expression "Essayer-Attraper-Finalement" (Try-Catch-Finally)
+    // Structure "Essayer-Attraper-Finalement" (Try-Catch-Finally)
     @try
     {
         @throw [NSException exceptionWithName:@"FileNotFoundException"
@@ -264,8 +265,11 @@ int main (int argc, const char * argv[])
     // étapes précédentes ne sont pas terminées
     MaClass *monObjet = [[MaClass alloc] init];
         
-    // L'Objective-C est basé sur le principe d'envoie de message et non sur celui
-    // d'appel de méthode comme la plupart des autres langages de programmation
+    // L'Objet en Objective-C est basé sur le principe d'envoie de message et non sur
+    // celui d'appel de méthode comme la plupart des autres langages
+    // C'est un détail important car cela veut dire que l'on peut envoyer un message
+    // à un objet qui ne possède pas la méthode demandée sans aucune incidence sur le
+    // fonctionnement du programme (aucune exception ne sera levée)
     [myObject instanceMethodWithParameter:@"Steve Jobs"];
 
     // Nettoie la mémoire qui a été utilisée dans le programme
@@ -286,10 +290,10 @@ int main (int argc, const char * argv[])
 // La déclaration d'une classe en Objective-C commence par la déclaration de son interface :
 // @interface NomDeLaClasse : NomDeLaClasseParent <ListeDesProtocoles>
 // {
-//    type nom; // declaration d'une variable;
+//    type nom; // Déclaration d'une variable;
 // }
-// @property type nom; // declaration d'une propriété
-// -/+ (type)nomDeLaMethode; // Declaration d'une methode
+// @property type nom; // Déclaration d'une propriété
+// -/+ (type)nomDeLaMethode; // Déclaration d'une methode
 // @end // Termine la déclaration
 // NSObject est la classe de base (super classe) en Objective-C
 @interface MaClasse : NSObject <MonProtocole>
@@ -298,7 +302,7 @@ int main (int argc, const char * argv[])
     @private id donnee; // Accès privé (il est plus pratique de le faire dans l'implémentation)
     NSString *nom; 
 }
-// Les propriétés permettent de générrer les accésseurs/affecteurs publiques à la compilation
+// Les propriétés permettent de générer les accésseurs/affecteurs publiques à la compilation
 // Par défaut, le nom de l'affecteur est la chaine 'set' suivi par le nom de la @property
 @property int propInt; // Nom de l'affecteur = 'setPropInt'
 @property (copy) id copyId; // (copy) => Copie l'objet pendant l'affectation
@@ -345,7 +349,7 @@ MaClasse *m2 = [MaClasse maClasseDepuisLaHauteur:38];
 MaClasse *maClasse = [[MaClasse alloc] init]; // Créer une instance de MaClasse
 NSString *stringDepuisUneInstanceDeMethode = [maClasse methodeInstanceAvecUnParametre:@"Salut"];
 
-// les sélecteurs sont un moyen de décrire les méthodes dynamiquement
+// Les sélecteurs sont un moyen de décrire les méthodes dynamiquement
 // Ils sont utilisés pour appeler des méthodes de classe et avoir des pointeurs de fonctions
 // facilement manipulable
 // SEL est un type de donnée et @selector retourne un selecteur à partir d'un nom de methode
@@ -363,20 +367,20 @@ else {
 
 // Le fichier d'implémentation de la classe MaClasse (MaClasse.m) doit commencer comme ceci :
 @implementation MaClasse {
-    long distance; // Variable d'instance privé (équivalent à @private dans l'interface)
+    long distance; // Variable d'instance privée (équivalent à @private dans l'interface)
     NSNumber hauteur;
 }
 
 // Pour accéder à une variable depuis l'implémentation on peut utiliser le _ (tiret bas) devant le nom
 // de la variable :
 _nombre = 5;
-// Accès d'une variable défini dans le fichier d'implémentation :
+// Accès d'une variable définie dans le fichier d'implémentation :
 distance = 18;
-// Pour utiliser la variable défini par l'intermédiaire de @property, il faut utiliser @synthesize 
-// qui permet de créer les affecteurs et les accésseurs :
+// Pour utiliser la variable définie par l'intermédiaire de @property, il faut utiliser @synthesize 
+// qui permet de créer les affecteurs et les accésseurs correspondants :
 @synthesize roString = _roString; // _roString est maintenant disponible dans l'implementation
 
-// En contre-partie de l'appel de la fonction 'init' lors de la création d'un objet, la fonction 
+// A l'inverse dela méthode 'init' qui est appelée lors de la création d'un objet, la fonction 
 // 'dealloc' est appelée quand l'objet est supprimé
 - (void)dealloc
 {
@@ -384,18 +388,18 @@ distance = 18;
     [super dealloc];   // et à appeler la méthode 'dealloc' de la classe parent 
 }
 
-// Les constructeurs sont une manière de créer des instances de classes
-// 'init' est le constructeur par défaut; il est appelé quand l'objet est créé
+// Les constructeurs sont des fonctions qui permettent d'instancier un objet
+// 'init' est le constructeur par défaut en Objective-C
 - (id)init
 {
     if ((self = [super init])) // 'super' est utilisé pour appeler la méthode de la classe parent
     {
-        self.count = 1; // 'self' est utilisé pour appeler la méthodes de l'instance courante
+        self.count = 1; // 'self' permet d'appeler la méthode de l'instance courante
     }
     return self;
 }
 
-// Vous pouvez aussi créer des constructeurs qui possèdent des arguments
+// Vous pouvez aussi créer des constructeurs avec des arguments
 // Attention : chaque nom de constructeur doit absolument commencer par 'init'
 - (id)initAvecUneDistance:(int)distanceParDefault 
 {
@@ -447,8 +451,8 @@ distance = 18;
 @end // Fin de l'implémentation
 
 /*
- * Un protocole déclare des méthodes que chaque objet respectant celui-ci doit implémenter
- * afin de se conformer celui-ci
+ * Un protocole déclare des méthodes et propriétés que chaque implémentation doit avoir afin de se
+ * conformer à celui-ci
  * Un protocole n'est pas une classe, c'est juste une interface
  */
 @protocol MonProtocole
@@ -460,16 +464,17 @@ distance = 18;
 // Gestion de la mémoire
 ///////////////////////////////////////
 /* 
-A chaque fois qu'un objet est créé dans l'application, un bloque mémoire doit être alloué.
-Quand l'application en a fini avec cet objet, la mémoire doit être libéré pour assurer la bonne 
-réactivité du programme (éviter les fuites mémoires)
-Il n'y a pas de ramasse-miettes en Objective-C contrairement à Java par example. L'Objective-C repose
-sur le comptage de référence. A chaque objet est assigné un compteur qui permet de connaitre son état.
+À chaque fois qu'un objet est créé dans l'application, un bloc mémoire doit être alloué.
+Quand l'application en a fini avec cet objet, la mémoire doit être libérée afin d'éviter les fuites
+mémoires
+Il n'y a pas de ramasse-miettes en Objective-C contrairement à Java par exemple. La gestion de la
+mémoire repose sur le comptage de référence qui, pour chaque objet, assigne un compteur qui permet
+de connaitre le nombre de référence qui l'utilise.
 
 Le principe est le suivant :
 Lorsque l'objet est créé, le compteur est initialisé à 1. Quand une instance détient un objet, le
-compteur est incrémenté de un. Quand l'objet est libéré, le compteur est décrémenté de un. Enfin 
-quand le compteur arrive à zéro, l'objet est supprimé de la mémoire
+compteur est incrémenté de un. Quand l'objet est libéré, le compteur est décrémenté de un.  Au moment
+où le compteur arrive à zéro, l'objet est supprimé de la mémoire
 
 Une bonne pratique à suivre quand on travaille avec des objets est la suivante :
 (1) créer un objet, (2) utiliser l'objet, (3) supprimer l'objet de la mémoire
@@ -478,34 +483,39 @@ Une bonne pratique à suivre quand on travaille avec des objets est la suivante
 MaClasse *classeVar = [MyClass alloc]; // 'alloc' incrémente le compteur de référence
 [classeVar release]; // Décrémente le compteur de rérence
 // 'retain' incrémente le compteur de référence
-// Si 'classeVar' est libéré, l'objet reste en mémoire car le compteur de référence est non nulle
+// Si 'classeVar' est libéré, l'objet reste en mémoire car le compteur de référence est non nul
 MaClasse *nouvelleVar = [classVar retain];
-[classeVar autorelease]; // Supprime l'appartenance de l'objet à la fin du block
+[classeVar autorelease]; // Supprime l'appartenance de l'objet à la fin du bloc
 
-// @property peuvent utiliser 'retain' et 'assign' 
+// Les @property peuvent utiliser 'retain' et 'assign' 
 @property (retain) MaClasse *instance; // Libère l'ancienne valeur et retient la nouvelle
 @property (assign) NSSet *set; // Pointeur vers la valeur sans retenir/libérer l'ancienne valeur
 
 // Automatic Reference Counting (ARC)
-// La gestion de la mémoire étant pénible, depuis iOS 4 et Xcode 4.2, Apple a introduit le comptage de référence
-// automatique (Automatic Reference Counting en anglais).
-// ARC est une fonctionnalité du compilateur qui lui permet d'ajouter les 'retain', 'release' et 'autorelease'
-// automatiquement. Donc quand utilisez ARC vous de devez plus utiliser ces mots clés
+// La gestion de la mémoire étant pénible, depuis iOS 4 et Xcode 4.2, Apple a introduit le comptage de
+// référence automatique (Automatic Reference Counting en anglais)
+// ARC est une fonctionnalité du compilateur qui permet d'ajouter les 'retain', 'release' et 'autorelease'
+// automatiquement. Cela veut dire que lorsque vous utilisez ARC vous ne devez plus utiliser ces mot-clés
 MaClasse *arcMaClasse = [[MaClasse alloc] init]; 
 // ... code utilisant arcMaClasse
-// Sans ARC, vous auriez dû appeler [arcMaClasse release] après avoir utilisé l'objet. Mais avec ARC il n'y a plus
-// besoin car le compilateur ajoutera l'expréssion automatiquement pour vous
+// Sans ARC, vous auriez dû appeler [arcMaClasse release] après avoir utilisé l'objet. Mais avec ARC
+// activé il n'est plus nécessaire de le faire car le compilateur ajoutera l'expréssion automatiquement
+// pour vous
 
 // Les mots clés 'assign' et 'retain', avec ARC sont respectivement remplacé par 'weak' et 'strong'
-@property (weak) MaClasse *weakVar; // 'weak' ne retient pas l'objet. Si l'instance original descend à zero, weakVar
-// sera automatiquement mis à nil
-@property (strong) MaClasse *strongVar; // 'strong' prend posséssion de l'objet comme le ferai le mot clé 'retain'
-
-// Pour l'instanciation des variables (en dehors de @property), vous pouvez utiliser les instructions suivantes :
-__strong NSString *strongString; // Par defaut. La variable est retenu en mémoire jusqu'à la fin de sa portée
-__weak NSSet *weakSet; // Réfère la variable en utilisant le mot clé '__weak'
-__unsafe_unretained NSArray *unsafeArray; // Comme __weak, mais quand la variable n'est pas mis à nil quand l'objet
-// est supprimé ailleurs
+@property (weak) MaClasse *weakVar; // 'weak' ne retient pas l'objet. Si le compteur de référence
+// descend à zero, weakVar sera automatiquement mis à nil
+@property (strong) MaClasse *strongVar; // 'strong' prend possession de l'objet comme le ferait avec
+// le mot-clé 'retain'
+
+// Pour l'instanciation des variables (en dehors de @property), vous pouvez utiliser les instructions
+// suivantes :
+__strong NSString *strongString; // Par défaut. La variable est retenue en mémoire jusqu'à la fin
+//  de sa portée
+__weak NSSet *weakSet; // Maintient une référence vers l'objet sans incrémenter son compteur de référence :
+// Lorsque l'objet sera supprimé, weakSet sera mis à nil automatiquement
+__unsafe_unretained NSArray *unsafeArray; // Comme __weak, mais la variable n'est pas mis à nil quand
+// l'objet est supprimé
 
 ```
 ##  Lectures Complémentaires
-- 
cgit v1.2.3


From 5ab214be7270c9b0d0b7d394ebf05f8b75457a76 Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Wed, 29 Jan 2014 22:01:30 -0800
Subject: Added lang to objc fr

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

(limited to 'fr-fr')

diff --git a/fr-fr/objective-c-fr.html.markdown b/fr-fr/objective-c-fr.html.markdown
index b14b3a52..0aeb5082 100644
--- a/fr-fr/objective-c-fr.html.markdown
+++ b/fr-fr/objective-c-fr.html.markdown
@@ -8,6 +8,7 @@ contributors:
 translators:
     - ["Yannick Loriot", "https://github.com/YannickL"]
 filename: LearnObjectiveC.m
+lang: fr-fr
 
 ---
 
@@ -524,4 +525,4 @@ __unsafe_unretained NSArray *unsafeArray; // Comme __weak, mais la variable n'es
 
 [iOS pour les écoliers : Votre première app iOS](http://www.raywenderlich.com/fr/39272/ios-pour-les-ecoliers-votre-premiere-app-ios-partie-12)
 
-[Programming with Objective-C. Apple PDF book](https://developer.apple.com/library/ios/documentation/cocoa/conceptual/ProgrammingWithObjectiveC/ProgrammingWithObjectiveC.pdf)
\ No newline at end of file
+[Programming with Objective-C. Apple PDF book](https://developer.apple.com/library/ios/documentation/cocoa/conceptual/ProgrammingWithObjectiveC/ProgrammingWithObjectiveC.pdf)
-- 
cgit v1.2.3


From 4a9b80d5f5a0b2618bf7b7f5b4a6b603f6f7d7f0 Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Wed, 29 Jan 2014 22:05:08 -0800
Subject: No objc highlighting, use cpp to fix errors

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

(limited to 'fr-fr')

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


From 0b2a283db4bc622aaca3c23daa3c39dfd9297db1 Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Wed, 29 Jan 2014 23:30:28 -0800
Subject: Updated a lot of filenames

---
 fr-fr/haskell.html.markdown        | 1 +
 fr-fr/objective-c-fr.html.markdown | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

(limited to 'fr-fr')

diff --git a/fr-fr/haskell.html.markdown b/fr-fr/haskell.html.markdown
index 9d0cec99..989db1d5 100644
--- a/fr-fr/haskell.html.markdown
+++ b/fr-fr/haskell.html.markdown
@@ -5,6 +5,7 @@ contributors:
 translators:
     - ["David Baumgartner", "http://davidbaumgartner.ch"]    
 lang: fr-fr
+filename: learnhaskell-fr.hs
 ---
 
 Haskell a été conçu pour être un langage fonctionnel pur et maniable. Il est connu pour ses monades et son système de types, mais je n'ai cesse d'y revenir pour son élégance. Pour moi, Haskell fait de la programmation une joie.
diff --git a/fr-fr/objective-c-fr.html.markdown b/fr-fr/objective-c-fr.html.markdown
index d48bcc5e..b98d161e 100644
--- a/fr-fr/objective-c-fr.html.markdown
+++ b/fr-fr/objective-c-fr.html.markdown
@@ -7,7 +7,7 @@ contributors:
     - ["Levi Bostian", "https://github.com/levibostian"]
 translators:
     - ["Yannick Loriot", "https://github.com/YannickL"]
-filename: LearnObjectiveC.m
+filename: LearnObjectiveC-fr.m
 lang: fr-fr
 
 ---
-- 
cgit v1.2.3


From 4803b3aa262f2abf0ae69945135c0cefe2e7bc47 Mon Sep 17 00:00:00 2001
From: olwaro <hoarau.olivier@gmail.com>
Date: Fri, 14 Feb 2014 15:06:56 +0100
Subject: First version of csharp french translation

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

(limited to 'fr-fr')

diff --git a/fr-fr/csharp-fr.html.markdown b/fr-fr/csharp-fr.html.markdown
new file mode 100644
index 00000000..d85dcfc6
--- /dev/null
+++ b/fr-fr/csharp-fr.html.markdown
@@ -0,0 +1,801 @@
+---
+language: c#
+contributors:
+    - ["Irfan Charania", "https://github.com/irfancharania"]
+    - ["Max Yankov", "https://github.com/golergka"]
+    - ["Melvyn Laïly", "http://x2a.yt"]
+    - ["Shaun McCarthy", "http://www.shaunmccarthy.com"]
+translators:
+    - ["Olivier Hoarau", "https://github.com/Olwaro"]
+filename: LearnCSharp.cs
+lang: fr-fr
+---
+
+C# est un langage de programmation orienté objet à typage fort qui permet aux développeurs de créer une grande variété d'applications fiables et robustes s'appuyant sur le framework .NET.
+
+[Plus d'infos](http://msdn.microsoft.com/fr-fr/library/67ef8sbd.aspx)
+
+```c#
+// Les commentaires sur une seule ligne commencent par //
+/*
+Les
+commentaires
+multi-lignes
+ressemblent
+à
+ceci
+*/
+/// <summary>
+/// Ceci est un commentaire de documentation XML
+/// </summary>
+
+// Utilisez des namespaces avec l'instruction 'using'
+using System;
+using System.Collections.Generic;
+using System.Data.Entity;
+using System.Dynamic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Net;
+using System.Threading.Tasks;
+
+// Définit la portée du code pour une meilleure organisation
+namespace Learning
+{
+    // Chaque fichier .cs devrait au moins contenir une classe avec le même nom 
+    // que celui du fichier. Ce n'est pas une obligation mais c'est mieux ! 
+    public class LearnCSharp
+    {
+        // LES BASES - si vous avez déjà une expérience en Java ou C++
+        // passez directement à la partie FONCTIONNALITÉS INTERESSANTES 
+        public static void Syntax() 
+        {
+            // Utilisez Console.WriteLine pour écrire sur la sortie
+            Console.WriteLine("Hello World");
+            Console.WriteLine(
+                "Entier: " + 10 +
+                " Double: " + 3.14 +
+                " Booleen: " + true);
+
+            // Pour omettre le retour à la ligne : Console.Write
+            Console.Write("Hello ");
+            Console.Write("World");
+
+            ///////////////////////////////////////////////////
+            // Types et Variables
+            // Déclarez une variable avec la syntaxe <type> <nom>
+            ///////////////////////////////////////////////////
+
+            // Sbyte - Entier signé sur 8 bits
+            // (-128 <= sbyte <= 127)
+            sbyte fooSbyte = 100;
+
+            // Byte - Entier non-signé sur 8 bits
+            // (0 <= byte <= 255)
+            byte fooByte = 100;
+
+            // Short - Entier sur 16 bits
+            // Signé - (-32,768 <= short <= 32,767)
+            // Non-signé - (0 <= ushort <= 65,535)
+            short fooShort = 10000;
+            ushort fooUshort = 10000;
+
+            // Int - Entier sur 32 bits
+            int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647)
+            uint fooUint = 1; // (0 <= uint <= 4,294,967,295)
+
+            // Long - Entier sur 64 bits
+            long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+            ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615)
+            // Par défaut le type d'un littéral entier est int ou uint
+            // on ajoute 'L' pour spécifier la création d'un long
+
+            // Double - Réel sur 64 bits en virgule flottante (norme IEEE 754) 
+            double fooDouble = 123.4; // Precision: 15-16 chiffres
+
+            // Float - Réel sur 32 bits en virgule flottante (norme IEEE 754) 
+            float fooFloat = 234.5f; // Precision: 7 chiffres
+            // Par défaut le type d'un littéral réel est double
+            // on ajoute 'f' pour spécifier la création d'un float
+
+            // Decimal - Type de donnée numérique sur 128 bits, fournit une plus 
+            // grande précision et une plage de valeurs réduite
+            // approprié aux calculs financiers et monétaires
+            decimal fooDecimal = 150.3m;
+
+            // Booléen - vrai / faux
+            bool fooBoolean = true; // ou false
+
+            // Char - Un unique caractère Unicode sur 16 bits
+            char fooChar = 'A';
+
+            // String -- contrairement au types précédents qui sont des types valeurs,
+            // string est un type référence. Il peut donc avoir la valeur null
+            string fooString = "\"échappement\" de guillemets et ajout de \n (nouvelle ligne) et  de \t (tabulation)";
+            Console.WriteLine(fooString);
+
+            // Il est possible d'accéder à chaque caractère d'une string via un indexeur
+            char charFromString = fooString[1]; // 'é'
+            // Une string est immuable: impossible de faire fooString[1] = 'X';
+
+            // Comparaison de strings avec la culture courrante en ignorant la casse
+            string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase);
+
+            // Formatage
+            string fooFs = string.Format("Check Check, {0} {1}, {0} {1:0.0}", 1, 2);
+
+            // Dates et formatage
+            DateTime fooDate = DateTime.Now;
+            Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy"));
+
+            // Il est possible d'étaler une string sur plusieurs lignes avec le symbole @.
+            // Pour échapper " utilisez ""
+            string bazString = @"Voici quelques trucs
+sur une nouvelle ligne! ""Wow!"", quel style";
+
+            // Utilisez const ou read-only pour rendre une variable immuable
+            // les valeurs constantes sont calculées au moment de la compilation
+            const int HEURES_PAR_SEMAINE = 9001;
+
+            ///////////////////////////////////////////////////
+            // Structures de données
+            ///////////////////////////////////////////////////
+
+            // Tableaux - indexé à partir de zéro
+            // La taille d'un tableau doit être décidée à la déclaration
+            // La syntaxe pour déclarer un tableau est la suivante :
+            // <type>[] <nom> = new <type>[<taille>]
+            int[] intArray = new int[10];
+
+            // Une autre méthode de déclaration et d'initialisation
+            int[] y = { 9000, 1000, 1337 };
+
+            // Indexer un tableau - Accéder à un élément
+            Console.WriteLine("intArray à 0: " + intArray[0]);
+            // Les tableaux sont muable.
+            intArray[1] = 1;
+
+            // Listes
+            // Elles sont plus souvent utilisées que les tableaux car plus souples
+            // La syntaxe pour déclarer une liste est la suivante :
+            // List<type> <nom> = new List<type>();
+            List<int> intList = new List<int>();
+            List<string> stringList = new List<string>();
+            List<int> z = new List<int> { 9000, 1000, 1337 }; // intialisation
+            // Les <> indiquent un type générique 
+            // Pus d'info dans la partie FONCTIONNALITÉS INTERESSANTES
+
+            // Les éléments d'une liste ne sont pas null par défaut
+            // Il faut ajouter une valeur avant d'y accéder par index
+            intList.Add(1);
+            Console.WriteLine("intList à 0: " + intList[0]);
+
+            // Autres structures de données à étudier:
+            // Stack/Queue (Pile/File)
+            // Dictionary (une implémentation de hash map)
+            // HashSet (représente un ensemble)
+            // Collections en lecture seule
+            // Tuple (.Net 4+)
+
+            ///////////////////////////////////////
+            // Opérateurs
+            ///////////////////////////////////////
+            Console.WriteLine("\n->Opérateurs");
+
+            int i1 = 1, i2 = 2; // Raccourci pour des déclarations multiples
+
+            // Arithmétique classique
+            Console.WriteLine(i1 + i2 - i1 * 3 / 7); // => 3
+
+            // Modulo
+            Console.WriteLine("11%3 = " + (11 % 3)); // => 2
+
+            // Opérateurs de comparaison
+            Console.WriteLine("3 == 2? " + (3 == 2)); // => False
+            Console.WriteLine("3 != 2? " + (3 != 2)); // => True
+            Console.WriteLine("3 > 2? " + (3 > 2)); // => True
+            Console.WriteLine("3 < 2? " + (3 < 2)); // => False
+            Console.WriteLine("2 <= 2? " + (2 <= 2)); // => True
+            Console.WriteLine("2 >= 2? " + (2 >= 2)); // => True
+
+            // Opérateurs bit à bit !
+            /*
+            ~       Compément unaire
+            <<      Décalage à gauche
+            >>      Décalage à droite
+            &       ET logique
+            ^       OU exclusif
+            |       OU inclusif
+            */
+
+            // Incrémentations
+            int i = 0;
+            Console.WriteLine("\n->Inc/Dec-rementation");
+            Console.WriteLine(i++); //i = 1. Post-Incrémentation
+            Console.WriteLine(++i); //i = 2. Pre-Incrémentation
+            Console.WriteLine(i--); //i = 1. Post-Decrémentation
+            Console.WriteLine(--i); //i = 0. Pre-Decrémentation
+
+            ///////////////////////////////////////
+            // Structure de contrôle
+            ///////////////////////////////////////
+            Console.WriteLine("\n->Structure de contrôle");
+
+            // Clause 'if' à la C
+            int j = 10;
+            if (j == 10)
+            {
+                Console.WriteLine("Je serais affiché");
+            }
+            else if (j > 10)
+            {
+                Console.WriteLine("Pas moi");
+            }
+            else
+            {
+                Console.WriteLine("Moi non plus");
+            }
+
+            // Opérateur ternaire
+            // Un simple if/else peut s'écrire :
+            // <condition> ? <valeur si true> : <valeur si false>
+            string isTrue = (true) ? "True" : "False";
+
+            // Boucle while
+            int fooWhile = 0;
+            while (fooWhile < 100)
+            {
+                // 100 passages, de 0 à 99
+                fooWhile++;
+            }
+
+            // Boucle Do While
+            int fooDoWhile = 0;
+            do
+            {
+                // 100 passages, de 0 à 99
+                fooDoWhile++;
+            } while (fooDoWhile < 100);
+
+            // Boucle for 
+            // Structure : for(<etat_initial>; <condition>; <pas>)
+            for (int fooFor = 0; fooFor < 10; fooFor++)
+            {
+                // 10 passages, de 0 à 9
+            }
+
+            // La boucle foreach
+            // Structure : foreach(<type_iterateur> <nom_iterateur> in <enumerable>)
+            // Cette boucle est utilisable sur des objets implémentant IEnumerable ou IEnumerable<T>
+            // Toutes les collections du framework .NET (Tableaux, Listes, ...) implémentent ces interfaces.
+            // (Notez que dans l'exemple suivant .ToCharArray() peut être omit car
+            //  string implémente IEnumerable)
+            foreach (char character in "Hello World".ToCharArray())
+            {
+                //Itération sur chaque caractère
+            }
+
+            // La structure Switch Case
+            // Un switch fonctionne avec les types : byte, short, char, et int.
+            // Les enums sont aussi supportés ainsi que les strings et quelques
+            // classes spéciales basées sur les types primitifs : Character, Byte, Short, et Integer.
+            int mois = 3;
+            string moisString;
+            switch (mois)
+            {
+                case 1:
+                    moisString = "Janvier";
+                    break;
+                case 2:
+                    moisString = "Février";
+                    break;
+                case 3:
+                    moisString = "Mars";
+                    break;
+
+                // Vous pouvez assigné plus d'un 'case' à une action
+                // Mais vous ne pouvez pas ajouter une action sans 'break' avant un 'case'
+                // (pour ce faire, il faudrait ajouter explicitement un 'goto case x')
+                case 6:
+                case 7:
+                case 8:
+                    moisString = "C'est l'été!";
+                    break;
+                default:
+                    moisString = "Un autre mois oO";
+                    break;
+            }
+
+            ///////////////////////////////////////
+            // Convertion de type de donnée et transtypage
+            ///////////////////////////////////////
+
+            // Convertion de string vers int
+            // lève une exception en cas d'erreur
+            int.Parse("123"); //retourne la valeur entière de "123"
+
+            // TryParse affecte la valeur par défaut du type en cas d'erreur
+            // dans ce cas : 0
+            int tryInt;
+            if (int.TryParse("123", out tryInt)) // La fonction retourne un booléen
+                Console.WriteLine(tryInt);       // => 123
+
+            // Convertion d'un entier vers une string
+            // La classe Convert possède plusieur méthodes pour faciliter la convertion
+            Convert.ToString(123);
+            // ou
+            tryInt.ToString();
+        }
+
+        ///////////////////////////////////////
+        // CLASSES - voir les définitions à la fin du fichier
+        ///////////////////////////////////////
+
+        public static void Classes()
+        {
+            // voir les déclarations à la fin du fichier
+
+            // Utilisez 'new' pour instancier une classe
+            Bicycle trek = new Bicycle();
+
+            // Appel des méthodes de l'objet
+            trek.SpeedUp(3); // Il est toujours bon d'utiliser des accesseurs
+            trek.Cadence = 100;
+
+            // Affichage de la valeur de retour d'une méthode.
+            Console.WriteLine("trek info: " + trek.Info());
+
+            // Instanciation d'un nouveau PennyFarthing
+            PennyFarthing funbike = new PennyFarthing(1, 10);
+            Console.WriteLine("funbike info: " + funbike.Info());
+
+            Console.Read();
+        }
+
+        // POINT D'ENTREE Une application console doit avoir une méthode main comme point d'entrée
+        public static void Main(string[] args)
+        {
+            OtherInterestingFeatures();
+        }
+
+        //
+        // FONCTIONNALITÉS INTERESSANTES
+        //
+        
+        // SIGNATURE DE METHODE
+        public // Visibilité
+        static // Permet un appel direct par la classe (sans instanciation) 
+        int // Type de retour,
+        MethodSignatures(
+            int maxCount, // Premier paramètre, de type int
+            int count = 0, // Valeur par défaut si aucun argument n'est passé
+            int another = 3,
+            params string[] otherParams // Capture tous les arguments passés à la méthode
+        )
+        { 
+            return -1;
+        }
+
+        // Des méthodes peuvent avoir le même nom tant que leur signature est unique
+        public static void MethodSignature(string maxCount)
+        {
+        }
+
+        // TYPE GENERIQUE
+        
+        // Les types TKey et TValue sont spécifiés par l'utilisateur lors de l'appel de la fonction
+        // Cette méthode émule SetDefaut de Python
+        public static TValue SetDefault<TKey, TValue>(
+            IDictionary<TKey, TValue> dictionary, 
+            TKey key, 
+            TValue defaultItem)
+        {
+            TValue result;
+            if (!dictionary.TryGetValue(key, out result))
+                return dictionary[key] = defaultItem;
+            return result;
+        }
+
+        // Vous pouvez limiter les types autorisés
+        public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int>
+        {
+            // Nous somme sûr de pouvoir itérer, car T implémente IEnumerable<int>
+            foreach (var item in toPrint)
+                // Item sera de type int
+                Console.WriteLine(item.ToString());
+        }
+
+        public static void OtherInterestingFeatures()
+        {
+            // PARAMÈTERES OPTIONNELS
+            MethodSignatures(3, 1, 3, "Des", "Paramètres", "En plus");
+            MethodSignatures(3, another: 3); // affectation explicite, les autres 
+                                             // paramètres ont la valeur par défaut
+
+            // MÉTHODE D'EXTENSION
+            int i = 3;
+            i.Print(); // Défini plus bas
+
+            // TYPES NULLABLE - idéal pour les interactions avec une base de données ou pour les valeurs de retour
+            // Tous les types valeurs peuvent être rendu nullable en les suffixant par '?'
+            // <type>? <nom> = <value>
+            int? nullable = null; // raccourci pour Nullable<int>
+            Console.WriteLine("Nullable variable: " + nullable);
+            bool hasValue = nullable.HasValue; // retourne vrai si la valeur n'est pas null
+
+            // ?? est un sucre de syntaxe pour spécifier une valeur par défaut
+            // au cas ou une autre valleur serait nulle
+            int notNullable = nullable ?? 0; // 0
+
+            // VARIABLES IMPLICITEMENT TYPÉE - vous pouvez laisser le compilateur deviner le type d'une variable
+            var magic = "magic est de type string à la compilation, on a toujours un typage fort !";
+            // magic = 9; // ne fonctionnera pas car magic est désormais une string
+
+            // TYPES GÉNÉRIQUES
+            var agenda = new Dictionary<string, string>() { 
+                {"Sarah", "212 555 5555"} // Ajout d'une entrée à notre agenda
+            };
+
+            // Appel de la fonction SetDefault (défini plus haut)
+            Console.WriteLine(SetDefault<string,string>(agenda, "Shaun", "Pas de numéro")); // => Pas de numéro
+            // Notez que vous n'avez pas à spécifier TKey et TValue car le compilateur saura les inférer.
+            Console.WriteLine(SetDefault(agenda, "Sarah", "No Phone")); // => 212 555 5555
+
+            // EXPRESSION LAMBDA - permet d'écrire une fonction en tant qu'expression
+            Func<int, int> square = (x) => x * x; // Le dernier élément est la valeur de retour
+            Console.WriteLine(square(3)); // => 9
+
+            // BIBLIOTHÈQUE DE TÂCHES PARALLÈLE (TPL)
+            // http://msdn.microsoft.com/fr-fr/library/dd460717.aspx
+            var websites = new string[] { 
+                "http://www.google.com", "http://www.reddit.com", 
+                "http://www.shaunmccarthy.com"
+            };
+            var responses = new Dictionary<string, string>();
+            
+            // L'exemple suivant executera chaque requête dans un thread séparé,
+            // et attendera la fin de chacun d'entre eux avant de continuer
+            Parallel.ForEach(websites, 
+                new ParallelOptions() {MaxDegreeOfParallelism = 3}, // maximum de 3 threads
+                website =>
+            {
+                // Faire quelque chose de long sur le fichier
+                using (var r = WebRequest.Create(new Uri(website)).GetResponse())
+                {
+                    responses[website] = r.ContentType;
+                }
+            });
+
+            // Ceci ne s'exécutera pas tant que les threads n'auront pas fini leur travail
+            foreach (var key in responses.Keys)
+                Console.WriteLine("{0}:{1}", key, responses[key]);
+
+            // TYPE DYNAMIQUE - idéal pour travailler avec d'autres langages
+            dynamic student = new ExpandoObject();
+            student.FirstName = "Mon prénom"; // Pas besoin de définir l'objet
+
+            // Vous pouvez même ajouter des méthodes (dans ce cas: qui prend une string et retourne une string)
+            student.Introduce = new Func<string, string>(
+                (introduceTo) => string.Format("Hey {0}, c'est {1}", student.FirstName, introduceTo));
+            Console.WriteLine(student.Introduce("Beth"));
+
+            // IQUERYABLE<T> - quasiment toutes les collections implémentent cette interface
+            // ce qui permet d'utiliser des méthodes de style Filter / Map / Reduce 
+            var bikes = new List<Bicycle>();
+            bikes.Sort(); // Trie le tableau sur place
+            bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels)); // Trie en se basant sur la propriété Wheels
+            var result = bikes
+                .Where(b => b.Wheels > 3) // 'Filter' - enchaînable (retourne un IQueryable du type précédent)
+                .Where(b => b.IsBroken && b.HasTassles)
+                .Select(b => b.ToString()); // 'Map' - on retourne le .ToString() de chaque élément filtré,
+                                            // le résultat est un IQueryable<string>
+
+            var sum = bikes.Sum(b => b.Wheels); // 'Reduce' - fait la somme de tous les Wheels de la liste
+
+            // Creation d'une liste d'objet anonymes basés sur des paramètres de la classe Bike
+            var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles });
+            // Le compilateur peut inférer le type de ces objets annonymes, permettant à certain IDE d'effectuer 
+            // des autos-complétion.
+            foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome))
+                Console.WriteLine(bikeSummary.Name);
+
+
+            // ASPARALLEL
+            // C'est ici que les choses se compliquent - un mélange de LINQ et de TPL
+            var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name);
+            // La ligne précédente s'exécute en parallèle ! Des threads seront gérés automatiquement
+            // et les données y seront réparties. Idéal sur de grosses données (et si votre 
+            // machine dispose de plusieurs coeurs)
+
+
+            // LINQ - lie une source de donnée à des objets IQueryable<T>
+            // ex: LindToSql => liaison avec une base de donnée, LinqToXml => liaison avec un document xml
+            var db = new BikeRespository();
+
+            // l'execution est décalée, ce qui est préférable quand on  travail sur une base données
+            var fitler = db.Bikes.Where(b => b.HasTassles); // pas de requête exécutée
+            if (42 > 6) //  Vous pouvez continuez à affiner la recherche
+                fitler = fitler.Where(b => b.IsBroken); // pas de requête exécutée
+
+            var query = fitler
+                .OrderBy(b => b.Wheels)
+                .ThenBy(b => b.Name)
+                .Select(b => b.Name); // toujours pas de requête exécutée
+
+            // Maintenant la requête est exécutée, mais retourne des données uniquement au fil de l'itération
+            foreach (string bike in query) 
+                Console.WriteLine(result);
+            
+        }
+
+    } // Fin de la classe LearnCSharp
+
+    // Il est possible d'inclure plusieur classes dans un fichier .cs
+
+    public static class Extensions
+    {
+        // EXTENSION DE FONCTIONS
+        public static void Print(this object obj)
+        {
+            Console.WriteLine(obj.ToString());
+        }
+    }
+
+    // Syntaxe de déclaration de classe :
+    // <public/private/protected/internal> class <class name>{
+    //    // champs, constructeurs, fonctions
+    //    // tout est déclaré et implémenté à l'intérieur
+    // }
+
+    public class Bicycle
+    {
+        // Propriétés et variable de la classe
+        public int Cadence // Public: peut être accédé de partout
+        {
+            get // get - définit une méthode pour lire la propriété
+            {
+                return _cadence;
+            }
+            set // set - définit une méthode pour affecté une valeur à la propriété
+            {
+                _cadence = value; // 'value' est la valeur passée en argument au setteur
+            }
+        }
+        private int _cadence;
+
+        protected virtual int Gear // Protected: accessible depuis la classe et ses classes filles
+        {
+            get; // crée une propriété automatique, pas besoin de créer une variable de stockage
+            set;
+        }
+
+        internal int Wheels // Internal: accessible depuis l'assembly
+        {
+            get;
+            private set; // Il est possible de choisir la portée d'un accesseur
+        }
+
+        int _speed; // Par défaut tout est privé au sein d'une classe : accessible uniquement depuis la classe
+                    // on peut ajouter explicitement le mot clé 'private'
+
+        public string Name { get; set; }
+
+
+        // Enum est un type valeur formé par un ensemble de constantes nommées
+        // C'est simplement une manière de mettre un nom sur une valeur (int par défaut).
+        // Les types compatibles pour un enum sont : byte, sbyte, short, ushort, int, uint, long, et ulong.
+        // Un enum ne peut pas contenir deux fois la même valeur
+        public enum BikeBrand
+        {
+            AIST,
+            BMC,
+            Electra = 42, // il est possible de donner explicitement une valeur
+            Gitane // 43
+        }
+        // Nous avons défini cet enum à l'intérieur de la classe Bicycle, c'est donc un type imbriqué
+        // Pour le référencer à l'extérieur, il faudra utiliser Bicycle.BikeBrand
+
+        public BikeBrand Brand; // Après avoir déclaré notre type enum, on peut créer un champ de ce type
+
+        // Les membres statiques appartiennent à une classe plutôt qu'à une instance particulière
+        // Il est possible d'y accéder sans passer par un objet:
+        // ex: Console.WriteLine("Bicycles créés: " + Bicycle.bicyclesCreated);
+        static public int BicyclesCreated = 0;
+
+        // Les valeurs en lecture seule sont affectées lors de l'exécution
+        // Elles ne peuvent être assignées que lors de leur déclaration ou dans un constructeur
+        readonly bool _hasCardsInSpokes = false; // variable en lecture et privée
+
+        // Les contructeurs sont un moyen de créer des objets
+        // Voici un constructeur par défaut (pas d'arguments)
+        public Bicycle() 
+        {
+            this.Gear = 1; // accès aux membres de la classe via le mot clé this
+            Cadence = 50;  // qui est souvent implicite
+            _speed = 5;
+            Name = "Bontrager";
+            Brand = BikeBrand.AIST;
+            BicyclesCreated++;
+        }
+
+        // Voici un constructeur spécifique (qui prends des arguments)
+        public Bicycle(int startCadence, int startSpeed, int startGear,
+                       string name, bool hasCardsInSpokes, BikeBrand brand) 
+            : base() // possibilité d'appeler le constructeur de la classe mère (ici Object)
+        {
+            Gear = startGear; 
+            Cadence = startCadence;
+            _speed = startSpeed;
+            Name = name; 
+            _hasCardsInSpokes = hasCardsInSpokes;
+            Brand = brand;
+        }
+
+        // Les constructeur peuvent s'enchaîner
+        public Bicycle(int startCadence, int startSpeed, BikeBrand brand) :
+            this(startCadence, startSpeed, 0, "big wheels", true, brand)
+        {
+        }
+
+        // Syntaxe de méthode:
+        // <public/private/protected> <type de retour> <nom de methode>(<args>)
+
+        // Les classes peuvent implémenter des accesseurs pour leur champs
+        // ou implémenter des propriétés (c'est la méthode dominante en C#)
+
+        // Les paramètres de méthodes peuvent avoir des valeur par défaut
+        // Dans ce cas, la méthode peut être appelée sans arguments
+        public void SpeedUp(int increment = 1)
+        {
+            _speed += increment;
+        }
+
+        public void SlowDown(int decrement = 1)
+        {
+            _speed -= decrement;
+        }
+
+        // Les propriétés se chargent de lire/modifier des valeurs
+        // elles peuvent être en lecture(get), en écriture(set) ou les deux
+        private bool _hasTassles; // variable privée
+        public bool HasTassles // propriété publique
+        {
+            get { return _hasTassles; }
+            set { _hasTassles = value; }
+        }
+
+        // Il est possible de définir une propriété automatique sur une ligne
+        // cette syntaxe créera une variable de stockage automatiquement.
+        // Il est possible de modifier l'accèsibilité des getter/setter pour limiter leur utilisation
+        public bool IsBroken { get; private set; }
+
+        // La même chose sur plusieurs lignes
+        public int FrameSize
+        {
+            get;
+            // Notez que seule la classe Bicycle peut changer la valeur de FrameSize
+            private set;
+        }
+
+        // Méthode qui affiche les valeurs des champs de cet objet
+        public virtual string Info()
+        {
+            return "Gear: " + Gear +
+                    " Cadence: " + Cadence +
+                    " Speed: " + _speed +
+                    " Name: " + Name +
+                    " Cards in Spokes: " + (_hasCardsInSpokes ? "yes" : "no") +
+                    "\n------------------------------\n"
+                    ;
+        }
+
+        // Les méthodes peuvent aussi être statiques. Utile pour les méthode d'aide.
+        public static bool DidWeCreateEnoughBycles()
+        {
+            // A l'intérieur d'une méthode statique on ne peut que référencer des membres statiques !
+            return BicyclesCreated > 9000;
+        } // Si votre classe n'a que des membres statiques, marquez la comme statique 
+
+    } // fin de la classe Bicycle
+
+    // PennyFarthing est une classe dérivée de Bicycle
+    class PennyFarthing : Bicycle
+    {
+        // Appel au constructeur de la classe mère
+        public PennyFarthing(int startCadence, int startSpeed) :
+            base(startCadence, startSpeed, 0, "PennyFarthing", true, BikeBrand.Electra)
+        {
+        }
+
+        protected override int Gear
+        {
+            get
+            {
+                return 0;
+            }
+            set
+            {
+                // Lève une exception
+                throw new ArgumentException("Impossible de modifier Gear sur un PennyFarthing");
+            }
+        }
+
+        public override string Info()
+        {
+            string result = "PennyFarthing bicycle ";
+            result += base.ToString(); // Appel à la version de base de cette méthode
+            return result;
+        }
+    }
+
+    // Les interfaces contiennent uniquement la signature de leurs membres, sans implémentation.
+    interface IJumpable
+    {
+        void Jump(int meters); // Tout les membres d'interface sont publique par défaut
+    }
+
+    interface IBreakable
+    {
+        bool Broken { get; } // Les interfaces peuvent contenir des propriétés, 
+                             // des méthodes et des évènements
+    }
+
+    // Une classe ne peut hériter que d'une seule autre classe, mais peut implémenter plusieur interfaces
+    class MountainBike : Bicycle, IJumpable, IBreakable
+    {
+        int damage = 0;
+
+        public void Jump(int meters)
+        {
+            damage += meters;
+        }
+
+        public bool Broken
+        {
+            get
+            {
+                return damage > 100;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Utilisé pour illustrer la connexion à une base donnée dans l'exemple LinqToSql
+    /// L'approche code first d'EntityFramework est très pratique (un peu comme ActiveRecord de Ruby) 
+    /// http://msdn.microsoft.com/fr-fr/data/jj193542.aspx
+    /// </summary>
+    public class BikeRespository : DbSet
+    {
+        public BikeRespository()
+            : base()
+        {
+        }
+
+        public DbSet<Bicycle> Bikes { get; set; }
+    }
+} // Fin du namespace
+```
+
+## Sujets non-abordés
+
+ * Flags
+ * Attribus
+ * Propriétés statiques
+ * Exceptions, Abstraction
+ * ASP.NET (Web Forms/MVC/WebMatrix)
+ * Winforms
+ * Windows Presentation Foundation (WPF)
+
+## Lectures Complémentaires
+
+ * [DotNetPerls](http://www.dotnetperls.com)
+ * [C# in Depth](http://manning.com/skeet2)
+ * [Programming C#](http://shop.oreilly.com/product/0636920024064.do)
+ * [LINQ](http://shop.oreilly.com/product/9780596519254.do)
+ * [MSDN Library](http://msdn.microsoft.com/en-us/library/618ayhy6.aspx)
+ * [ASP.NET MVC Tutorials](http://www.asp.net/mvc/tutorials)
+ * [ASP.NET Web Matrix Tutorials](http://www.asp.net/web-pages/tutorials)
+ * [ASP.NET Web Forms Tutorials](http://www.asp.net/web-forms/tutorials)
+ * [Windows Forms Programming in C#](http://www.amazon.com/Windows-Forms-Programming-Chris-Sells/dp/0321116208)
+
+[Convention de codage C#](http://msdn.microsoft.com/library/vstudio/ff926074)
-- 
cgit v1.2.3


From 5c19094fb080653f0bf733997ad5241ee9f69d84 Mon Sep 17 00:00:00 2001
From: olwaro <hoarau.olivier@gmail.com>
Date: Fri, 14 Feb 2014 21:33:43 +0100
Subject: A bunch of typo fix

---
 fr-fr/csharp-fr.html.markdown | 62 +++++++++++++++++++++----------------------
 1 file changed, 31 insertions(+), 31 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/csharp-fr.html.markdown b/fr-fr/csharp-fr.html.markdown
index d85dcfc6..032d94a6 100644
--- a/fr-fr/csharp-fr.html.markdown
+++ b/fr-fr/csharp-fr.html.markdown
@@ -109,7 +109,7 @@ namespace Learning
             // Char - Un unique caractère Unicode sur 16 bits
             char fooChar = 'A';
 
-            // String -- contrairement au types précédents qui sont des types valeurs,
+            // String -- contrairement aux types précédents qui sont des types valeurs,
             // string est un type référence. Il peut donc avoir la valeur null
             string fooString = "\"échappement\" de guillemets et ajout de \n (nouvelle ligne) et  de \t (tabulation)";
             Console.WriteLine(fooString);
@@ -152,7 +152,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
 
             // Indexer un tableau - Accéder à un élément
             Console.WriteLine("intArray à 0: " + intArray[0]);
-            // Les tableaux sont muable.
+            // Les tableaux sont muables.
             intArray[1] = 1;
 
             // Listes
@@ -268,7 +268,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
             // Structure : foreach(<type_iterateur> <nom_iterateur> in <enumerable>)
             // Cette boucle est utilisable sur des objets implémentant IEnumerable ou IEnumerable<T>
             // Toutes les collections du framework .NET (Tableaux, Listes, ...) implémentent ces interfaces.
-            // (Notez que dans l'exemple suivant .ToCharArray() peut être omit car
+            // (Notez que dans l'exemple suivant .ToCharArray() peut être omit car,
             //  string implémente IEnumerable)
             foreach (char character in "Hello World".ToCharArray())
             {
@@ -276,9 +276,9 @@ sur une nouvelle ligne! ""Wow!"", quel style";
             }
 
             // La structure Switch Case
-            // Un switch fonctionne avec les types : byte, short, char, et int.
+            // Un switch fonctionne avec les types : byte, short, char et int.
             // Les enums sont aussi supportés ainsi que les strings et quelques
-            // classes spéciales basées sur les types primitifs : Character, Byte, Short, et Integer.
+            // classes spéciales basées sur les types primitifs : Character, Byte, Short et Integer.
             int mois = 3;
             string moisString;
             switch (mois)
@@ -293,7 +293,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
                     moisString = "Mars";
                     break;
 
-                // Vous pouvez assigné plus d'un 'case' à une action
+                // Vous pouvez assigner plus d'un 'case' à une action
                 // Mais vous ne pouvez pas ajouter une action sans 'break' avant un 'case'
                 // (pour ce faire, il faudrait ajouter explicitement un 'goto case x')
                 case 6:
@@ -307,10 +307,10 @@ sur une nouvelle ligne! ""Wow!"", quel style";
             }
 
             ///////////////////////////////////////
-            // Convertion de type de donnée et transtypage
+            // conversion de type de donnée et transtypage
             ///////////////////////////////////////
 
-            // Convertion de string vers int
+            // conversion de string vers int
             // lève une exception en cas d'erreur
             int.Parse("123"); //retourne la valeur entière de "123"
 
@@ -320,8 +320,8 @@ sur une nouvelle ligne! ""Wow!"", quel style";
             if (int.TryParse("123", out tryInt)) // La fonction retourne un booléen
                 Console.WriteLine(tryInt);       // => 123
 
-            // Convertion d'un entier vers une string
-            // La classe Convert possède plusieur méthodes pour faciliter la convertion
+            // conversion d'un entier vers une string
+            // La classe Convert possède plusieurs méthodes pour faciliter la conversion
             Convert.ToString(123);
             // ou
             tryInt.ToString();
@@ -399,7 +399,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
         // Vous pouvez limiter les types autorisés
         public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int>
         {
-            // Nous somme sûr de pouvoir itérer, car T implémente IEnumerable<int>
+            // Nous sommes sûrs de pouvoir itérer, car T implémente IEnumerable<int>
             foreach (var item in toPrint)
                 // Item sera de type int
                 Console.WriteLine(item.ToString());
@@ -417,14 +417,14 @@ sur une nouvelle ligne! ""Wow!"", quel style";
             i.Print(); // Défini plus bas
 
             // TYPES NULLABLE - idéal pour les interactions avec une base de données ou pour les valeurs de retour
-            // Tous les types valeurs peuvent être rendu nullable en les suffixant par '?'
+            // Tous les types valeurs peuvent être rendus nullable en les suffixant par '?'
             // <type>? <nom> = <value>
             int? nullable = null; // raccourci pour Nullable<int>
             Console.WriteLine("Nullable variable: " + nullable);
             bool hasValue = nullable.HasValue; // retourne vrai si la valeur n'est pas null
 
             // ?? est un sucre de syntaxe pour spécifier une valeur par défaut
-            // au cas ou une autre valleur serait nulle
+            // au cas ou une autre valeur serait nulle
             int notNullable = nullable ?? 0; // 0
 
             // VARIABLES IMPLICITEMENT TYPÉE - vous pouvez laisser le compilateur deviner le type d'une variable
@@ -445,7 +445,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
             Func<int, int> square = (x) => x * x; // Le dernier élément est la valeur de retour
             Console.WriteLine(square(3)); // => 9
 
-            // BIBLIOTHÈQUE DE TÂCHES PARALLÈLE (TPL)
+            // BIBLIOTHÈQUE DE TÂCHES PARALLÈLES (TPL)
             // http://msdn.microsoft.com/fr-fr/library/dd460717.aspx
             var websites = new string[] { 
                 "http://www.google.com", "http://www.reddit.com", 
@@ -453,8 +453,8 @@ sur une nouvelle ligne! ""Wow!"", quel style";
             };
             var responses = new Dictionary<string, string>();
             
-            // L'exemple suivant executera chaque requête dans un thread séparé,
-            // et attendera la fin de chacun d'entre eux avant de continuer
+            // L'exemple suivant exécutera chaque requête dans un thread séparé,
+            // et attendra la fin de chacun d'entre eux avant de continuer
             Parallel.ForEach(websites, 
                 new ParallelOptions() {MaxDegreeOfParallelism = 3}, // maximum de 3 threads
                 website =>
@@ -494,7 +494,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
 
             // Creation d'une liste d'objet anonymes basés sur des paramètres de la classe Bike
             var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles });
-            // Le compilateur peut inférer le type de ces objets annonymes, permettant à certain IDE d'effectuer 
+            // Le compilateur peut inférer le type de ces objets anonymes, permettant à certain IDE d'effectuer 
             // des autos-complétion.
             foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome))
                 Console.WriteLine(bikeSummary.Name);
@@ -509,12 +509,12 @@ sur une nouvelle ligne! ""Wow!"", quel style";
 
 
             // LINQ - lie une source de donnée à des objets IQueryable<T>
-            // ex: LindToSql => liaison avec une base de donnée, LinqToXml => liaison avec un document xml
+            // ex: LindToSql => liaison avec une base de données, LinqToXml => liaison avec un document xml
             var db = new BikeRespository();
 
-            // l'execution est décalée, ce qui est préférable quand on  travail sur une base données
+            // l'exécution est décalée, ce qui est préférable quand on travaille sur une base données
             var fitler = db.Bikes.Where(b => b.HasTassles); // pas de requête exécutée
-            if (42 > 6) //  Vous pouvez continuez à affiner la recherche
+            if (42 > 6) //  Vous pouvez continuer à affiner la recherche
                 fitler = fitler.Where(b => b.IsBroken); // pas de requête exécutée
 
             var query = fitler
@@ -530,7 +530,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
 
     } // Fin de la classe LearnCSharp
 
-    // Il est possible d'inclure plusieur classes dans un fichier .cs
+    // Il est possible d'inclure plusieurs classes dans un fichier .cs
 
     public static class Extensions
     {
@@ -556,7 +556,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
             {
                 return _cadence;
             }
-            set // set - définit une méthode pour affecté une valeur à la propriété
+            set // set - définit une méthode pour affecter une valeur à la propriété
             {
                 _cadence = value; // 'value' est la valeur passée en argument au setteur
             }
@@ -583,7 +583,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
 
         // Enum est un type valeur formé par un ensemble de constantes nommées
         // C'est simplement une manière de mettre un nom sur une valeur (int par défaut).
-        // Les types compatibles pour un enum sont : byte, sbyte, short, ushort, int, uint, long, et ulong.
+        // Les types compatibles pour un enum sont : byte, sbyte, short, ushort, int, uint, long et ulong.
         // Un enum ne peut pas contenir deux fois la même valeur
         public enum BikeBrand
         {
@@ -606,7 +606,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
         // Elles ne peuvent être assignées que lors de leur déclaration ou dans un constructeur
         readonly bool _hasCardsInSpokes = false; // variable en lecture et privée
 
-        // Les contructeurs sont un moyen de créer des objets
+        // Les constructeurs sont un moyen de créer des objets
         // Voici un constructeur par défaut (pas d'arguments)
         public Bicycle() 
         {
@@ -618,7 +618,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
             BicyclesCreated++;
         }
 
-        // Voici un constructeur spécifique (qui prends des arguments)
+        // Voici un constructeur spécifique (qui prend des arguments)
         public Bicycle(int startCadence, int startSpeed, int startGear,
                        string name, bool hasCardsInSpokes, BikeBrand brand) 
             : base() // possibilité d'appeler le constructeur de la classe mère (ici Object)
@@ -631,7 +631,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
             Brand = brand;
         }
 
-        // Les constructeur peuvent s'enchaîner
+        // Les constructeurs peuvent s'enchaîner
         public Bicycle(int startCadence, int startSpeed, BikeBrand brand) :
             this(startCadence, startSpeed, 0, "big wheels", true, brand)
         {
@@ -640,10 +640,10 @@ sur une nouvelle ligne! ""Wow!"", quel style";
         // Syntaxe de méthode:
         // <public/private/protected> <type de retour> <nom de methode>(<args>)
 
-        // Les classes peuvent implémenter des accesseurs pour leur champs
+        // Les classes peuvent implémenter des accesseurs pour leurs champs
         // ou implémenter des propriétés (c'est la méthode dominante en C#)
 
-        // Les paramètres de méthodes peuvent avoir des valeur par défaut
+        // Les paramètres de méthodes peuvent avoir des valeurs par défaut
         // Dans ce cas, la méthode peut être appelée sans arguments
         public void SpeedUp(int increment = 1)
         {
@@ -689,7 +689,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
                     ;
         }
 
-        // Les méthodes peuvent aussi être statiques. Utile pour les méthode d'aide.
+        // Les méthodes peuvent aussi être statiques. Utile pour les méthodes d'aide.
         public static bool DidWeCreateEnoughBycles()
         {
             // A l'intérieur d'une méthode statique on ne peut que référencer des membres statiques !
@@ -731,7 +731,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
     // Les interfaces contiennent uniquement la signature de leurs membres, sans implémentation.
     interface IJumpable
     {
-        void Jump(int meters); // Tout les membres d'interface sont publique par défaut
+        void Jump(int meters); // Tous les membres d'interface sont publics par défaut
     }
 
     interface IBreakable
@@ -740,7 +740,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
                              // des méthodes et des évènements
     }
 
-    // Une classe ne peut hériter que d'une seule autre classe, mais peut implémenter plusieur interfaces
+    // Une classe ne peut hériter que d'une seule autre classe, mais peut implémenter plusieurs interfaces
     class MountainBike : Bicycle, IJumpable, IBreakable
     {
         int damage = 0;
-- 
cgit v1.2.3


From 7350deb1035369453c0651ecd81c4e00cae04142 Mon Sep 17 00:00:00 2001
From: olwaro <hoarau.olivier@gmail.com>
Date: Mon, 24 Feb 2014 19:54:54 +0100
Subject: Adds loan pattern example to french translation.

---
 fr-fr/csharp-fr.html.markdown | 47 ++++++++++++++++++++++++++-----------------
 1 file changed, 29 insertions(+), 18 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/csharp-fr.html.markdown b/fr-fr/csharp-fr.html.markdown
index 032d94a6..cf95a881 100644
--- a/fr-fr/csharp-fr.html.markdown
+++ b/fr-fr/csharp-fr.html.markdown
@@ -99,8 +99,8 @@ namespace Learning
             // on ajoute 'f' pour spécifier la création d'un float
 
             // Decimal - Type de donnée numérique sur 128 bits, fournit une plus 
-            // grande précision et une plage de valeurs réduite
-            // approprié aux calculs financiers et monétaires
+            // grande précision et une plage de valeurs réduite.
+            // Approprié aux calculs financiers et monétaires
             decimal fooDecimal = 150.3m;
 
             // Booléen - vrai / faux
@@ -114,11 +114,11 @@ namespace Learning
             string fooString = "\"échappement\" de guillemets et ajout de \n (nouvelle ligne) et  de \t (tabulation)";
             Console.WriteLine(fooString);
 
-            // Il est possible d'accéder à chaque caractère d'une string via un indexeur
+            // Il est possible d'accéder à chaque caractère d'une chaîne de caractères via un indexeur
             char charFromString = fooString[1]; // 'é'
-            // Une string est immuable: impossible de faire fooString[1] = 'X';
+            // une chaîne de caractères est immuable: impossible de faire fooString[1] = 'X';
 
-            // Comparaison de strings avec la culture courrante en ignorant la casse
+            // Comparaison de chaînes de caractères avec la culture courrante en ignorant la casse
             string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase);
 
             // Formatage
@@ -128,14 +128,14 @@ namespace Learning
             DateTime fooDate = DateTime.Now;
             Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy"));
 
-            // Il est possible d'étaler une string sur plusieurs lignes avec le symbole @.
+            // Il est possible d'étaler une chaîne de caractères sur plusieurs lignes avec le symbole @.
             // Pour échapper " utilisez ""
             string bazString = @"Voici quelques trucs
 sur une nouvelle ligne! ""Wow!"", quel style";
 
-            // Utilisez const ou read-only pour rendre une variable immuable
-            // les valeurs constantes sont calculées au moment de la compilation
-            const int HEURES_PAR_SEMAINE = 9001;
+            // Utilisez const ou read-only pour rendre une variable immuable.
+            // Les valeurs constantes sont calculées au moment de la compilation
+            const int HOURS_I_WORK_PER_WEEK = 9001;
 
             ///////////////////////////////////////////////////
             // Structures de données
@@ -225,7 +225,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
             int j = 10;
             if (j == 10)
             {
-                Console.WriteLine("Je serais affiché");
+                Console.WriteLine("Je serai affiché");
             }
             else if (j > 10)
             {
@@ -277,7 +277,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
 
             // La structure Switch Case
             // Un switch fonctionne avec les types : byte, short, char et int.
-            // Les enums sont aussi supportés ainsi que les strings et quelques
+            // Les enums sont aussi supportés ainsi que les chaînes de caractères et quelques
             // classes spéciales basées sur les types primitifs : Character, Byte, Short et Integer.
             int mois = 3;
             string moisString;
@@ -320,7 +320,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
             if (int.TryParse("123", out tryInt)) // La fonction retourne un booléen
                 Console.WriteLine(tryInt);       // => 123
 
-            // conversion d'un entier vers une string
+            // conversion d'un entier vers une chaîne de caractères
             // La classe Convert possède plusieurs méthodes pour faciliter la conversion
             Convert.ToString(123);
             // ou
@@ -423,13 +423,13 @@ sur une nouvelle ligne! ""Wow!"", quel style";
             Console.WriteLine("Nullable variable: " + nullable);
             bool hasValue = nullable.HasValue; // retourne vrai si la valeur n'est pas null
 
-            // ?? est un sucre de syntaxe pour spécifier une valeur par défaut
+            // ?? est un sucre syntaxique pour spécifier une valeur par défaut
             // au cas ou une autre valeur serait nulle
             int notNullable = nullable ?? 0; // 0
 
             // VARIABLES IMPLICITEMENT TYPÉE - vous pouvez laisser le compilateur deviner le type d'une variable
-            var magic = "magic est de type string à la compilation, on a toujours un typage fort !";
-            // magic = 9; // ne fonctionnera pas car magic est désormais une string
+            var magic = "magic est de type string à la compilation. On a toujours un typage fort !";
+            // magic = 9; // ne fonctionnera pas car magic est désormais une chaîne de caractères
 
             // TYPES GÉNÉRIQUES
             var agenda = new Dictionary<string, string>() { 
@@ -445,6 +445,17 @@ sur une nouvelle ligne! ""Wow!"", quel style";
             Func<int, int> square = (x) => x * x; // Le dernier élément est la valeur de retour
             Console.WriteLine(square(3)); // => 9
 
+            // GESTION AUTOMATIQUE DES RESSOURCES - vous permet de manipuler facilement des resources non-managées
+            // La plus part des objets qui accèdent à des ressources non-managées (handle de fichier, périphérique, etc.)
+            // implémentent l'interface IDisposable. L'instruction using prends soin
+            // de libérer ses objets IDisposable proprement à votre place.
+            using (StreamWriter writer = new StreamWriter("log.txt"))
+            {
+                writer.WriteLine("Rien à signaler");
+                // À la fin de cette portée, les ressources seront libérées.
+                // Même si une exception est levée.
+            } 
+
             // BIBLIOTHÈQUE DE TÂCHES PARALLÈLES (TPL)
             // http://msdn.microsoft.com/fr-fr/library/dd460717.aspx
             var websites = new string[] { 
@@ -459,7 +470,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
                 new ParallelOptions() {MaxDegreeOfParallelism = 3}, // maximum de 3 threads
                 website =>
             {
-                // Faire quelque chose de long sur le fichier
+                // Fait quelque chose de long
                 using (var r = WebRequest.Create(new Uri(website)).GetResponse())
                 {
                     responses[website] = r.ContentType;
@@ -474,13 +485,13 @@ sur une nouvelle ligne! ""Wow!"", quel style";
             dynamic student = new ExpandoObject();
             student.FirstName = "Mon prénom"; // Pas besoin de définir l'objet
 
-            // Vous pouvez même ajouter des méthodes (dans ce cas: qui prend une string et retourne une string)
+            // Vous pouvez même ajouter des méthodes (dans cet exemple: la méthode prend une chaîne de caractères et retourne une chaîne de caractères)
             student.Introduce = new Func<string, string>(
                 (introduceTo) => string.Format("Hey {0}, c'est {1}", student.FirstName, introduceTo));
             Console.WriteLine(student.Introduce("Beth"));
 
             // IQUERYABLE<T> - quasiment toutes les collections implémentent cette interface
-            // ce qui permet d'utiliser des méthodes de style Filter / Map / Reduce 
+            // ce qui permet d'utiliser des méthodes de style 'Filter' / 'Map' / 'Reduce' 
             var bikes = new List<Bicycle>();
             bikes.Sort(); // Trie le tableau sur place
             bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels)); // Trie en se basant sur la propriété Wheels
-- 
cgit v1.2.3


From 9d7566d82edf776b5f52ec397cd06f8e24e54b86 Mon Sep 17 00:00:00 2001
From: olwaro <hoarau.olivier@gmail.com>
Date: Mon, 24 Feb 2014 21:39:05 +0100
Subject: Fix what Nami-Doc spotted.

---
 fr-fr/csharp-fr.html.markdown | 76 +++++++++++++++++++++----------------------
 1 file changed, 38 insertions(+), 38 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/csharp-fr.html.markdown b/fr-fr/csharp-fr.html.markdown
index cf95a881..c1641716 100644
--- a/fr-fr/csharp-fr.html.markdown
+++ b/fr-fr/csharp-fr.html.markdown
@@ -29,7 +29,7 @@ ceci
 /// Ceci est un commentaire de documentation XML
 /// </summary>
 
-// Utilisez des namespaces avec l'instruction 'using'
+// Importez des namespaces avec l'instruction 'using'
 using System;
 using System.Collections.Generic;
 using System.Data.Entity;
@@ -46,8 +46,8 @@ namespace Learning
     // que celui du fichier. Ce n'est pas une obligation mais c'est mieux ! 
     public class LearnCSharp
     {
-        // LES BASES - si vous avez déjà une expérience en Java ou C++
-        // passez directement à la partie FONCTIONNALITÉS INTERESSANTES 
+        // LES BASES - si vous avez déjà de l'expérience en Java ou C++
+        // passez directement à la partie FONCTIONNALITÉS INTERÉSSANTES 
         public static void Syntax() 
         {
             // Utilisez Console.WriteLine pour écrire sur la sortie
@@ -91,10 +91,10 @@ namespace Learning
             // on ajoute 'L' pour spécifier la création d'un long
 
             // Double - Réel sur 64 bits en virgule flottante (norme IEEE 754) 
-            double fooDouble = 123.4; // Precision: 15-16 chiffres
+            double fooDouble = 123.4; // Precision : 15-16 chiffres
 
             // Float - Réel sur 32 bits en virgule flottante (norme IEEE 754) 
-            float fooFloat = 234.5f; // Precision: 7 chiffres
+            float fooFloat = 234.5f; // Precision : 7 chiffres
             // Par défaut le type d'un littéral réel est double
             // on ajoute 'f' pour spécifier la création d'un float
 
@@ -114,9 +114,9 @@ namespace Learning
             string fooString = "\"échappement\" de guillemets et ajout de \n (nouvelle ligne) et  de \t (tabulation)";
             Console.WriteLine(fooString);
 
-            // Il est possible d'accéder à chaque caractère d'une chaîne de caractères via un indexeur
+            // Il est possible d'accéder à chaque caractère d'une chaîne de caractères via son index
             char charFromString = fooString[1]; // 'é'
-            // une chaîne de caractères est immuable: impossible de faire fooString[1] = 'X';
+            // une chaîne de caractères est immuable : impossible de faire fooString[1] = 'X';
 
             // Comparaison de chaînes de caractères avec la culture courrante en ignorant la casse
             string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase);
@@ -163,14 +163,14 @@ sur une nouvelle ligne! ""Wow!"", quel style";
             List<string> stringList = new List<string>();
             List<int> z = new List<int> { 9000, 1000, 1337 }; // intialisation
             // Les <> indiquent un type générique 
-            // Pus d'info dans la partie FONCTIONNALITÉS INTERESSANTES
+            // Pus d'info dans la partie FONCTIONNALITÉS INTERÉSSANTES
 
             // Les éléments d'une liste ne sont pas null par défaut
             // Il faut ajouter une valeur avant d'y accéder par index
             intList.Add(1);
             Console.WriteLine("intList à 0: " + intList[0]);
 
-            // Autres structures de données à étudier:
+            // Autres structures de données à étudier :
             // Stack/Queue (Pile/File)
             // Dictionary (une implémentation de hash map)
             // HashSet (représente un ensemble)
@@ -217,11 +217,11 @@ sur une nouvelle ligne! ""Wow!"", quel style";
             Console.WriteLine(--i); //i = 0. Pre-Decrémentation
 
             ///////////////////////////////////////
-            // Structure de contrôle
+            // Structures de contrôle
             ///////////////////////////////////////
-            Console.WriteLine("\n->Structure de contrôle");
+            Console.WriteLine("\n->Structures de contrôle");
 
-            // Clause 'if' à la C
+            // Structure conditionnelle
             int j = 10;
             if (j == 10)
             {
@@ -268,7 +268,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
             // Structure : foreach(<type_iterateur> <nom_iterateur> in <enumerable>)
             // Cette boucle est utilisable sur des objets implémentant IEnumerable ou IEnumerable<T>
             // Toutes les collections du framework .NET (Tableaux, Listes, ...) implémentent ces interfaces.
-            // (Notez que dans l'exemple suivant .ToCharArray() peut être omit car,
+            // (Notez que dans l'exemple suivant .ToCharArray() peut être omit car
             //  string implémente IEnumerable)
             foreach (char character in "Hello World".ToCharArray())
             {
@@ -352,14 +352,14 @@ sur une nouvelle ligne! ""Wow!"", quel style";
             Console.Read();
         }
 
-        // POINT D'ENTREE Une application console doit avoir une méthode main comme point d'entrée
+        // POINT D'ENTRÉE - Une application console doit avoir une méthode main comme point d'entrée
         public static void Main(string[] args)
         {
             OtherInterestingFeatures();
         }
 
         //
-        // FONCTIONNALITÉS INTERESSANTES
+        // FONCTIONNALITÉS INTÉRÉSSANTES
         //
         
         // SIGNATURE DE METHODE
@@ -381,7 +381,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
         {
         }
 
-        // TYPE GENERIQUE
+        // TYPE GÉNÉRIQUE
         
         // Les types TKey et TValue sont spécifiés par l'utilisateur lors de l'appel de la fonction
         // Cette méthode émule SetDefaut de Python
@@ -414,7 +414,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
 
             // MÉTHODE D'EXTENSION
             int i = 3;
-            i.Print(); // Défini plus bas
+            i.Print(); // Définit plus bas
 
             // TYPES NULLABLE - idéal pour les interactions avec une base de données ou pour les valeurs de retour
             // Tous les types valeurs peuvent être rendus nullable en les suffixant par '?'
@@ -427,7 +427,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
             // au cas ou une autre valeur serait nulle
             int notNullable = nullable ?? 0; // 0
 
-            // VARIABLES IMPLICITEMENT TYPÉE - vous pouvez laisser le compilateur deviner le type d'une variable
+            // VARIABLES IMPLICITEMENT TYPÉES - vous pouvez laisser le compilateur deviner le type d'une variable
             var magic = "magic est de type string à la compilation. On a toujours un typage fort !";
             // magic = 9; // ne fonctionnera pas car magic est désormais une chaîne de caractères
 
@@ -436,23 +436,23 @@ sur une nouvelle ligne! ""Wow!"", quel style";
                 {"Sarah", "212 555 5555"} // Ajout d'une entrée à notre agenda
             };
 
-            // Appel de la fonction SetDefault (défini plus haut)
+            // Appel de la fonction SetDefault (définie plus haut)
             Console.WriteLine(SetDefault<string,string>(agenda, "Shaun", "Pas de numéro")); // => Pas de numéro
             // Notez que vous n'avez pas à spécifier TKey et TValue car le compilateur saura les inférer.
             Console.WriteLine(SetDefault(agenda, "Sarah", "No Phone")); // => 212 555 5555
 
             // EXPRESSION LAMBDA - permet d'écrire une fonction en tant qu'expression
-            Func<int, int> square = (x) => x * x; // Le dernier élément est la valeur de retour
+            Func<int, int> square = (x) => x * x; // La dernière expression est la valeur de retour
             Console.WriteLine(square(3)); // => 9
 
             // GESTION AUTOMATIQUE DES RESSOURCES - vous permet de manipuler facilement des resources non-managées
             // La plus part des objets qui accèdent à des ressources non-managées (handle de fichier, périphérique, etc.)
-            // implémentent l'interface IDisposable. L'instruction using prends soin
-            // de libérer ses objets IDisposable proprement à votre place.
+            // implémentent l'interface IDisposable. L'instruction using prend soin
+            // de libérer les objets IDisposable proprement à votre place.
             using (StreamWriter writer = new StreamWriter("log.txt"))
             {
                 writer.WriteLine("Rien à signaler");
-                // À la fin de cette portée, les ressources seront libérées.
+                // À la fin de cette portée les ressources seront libérées.
                 // Même si une exception est levée.
             } 
 
@@ -485,7 +485,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
             dynamic student = new ExpandoObject();
             student.FirstName = "Mon prénom"; // Pas besoin de définir l'objet
 
-            // Vous pouvez même ajouter des méthodes (dans cet exemple: la méthode prend une chaîne de caractères et retourne une chaîne de caractères)
+            // Vous pouvez même ajouter des méthodes (dans cet exemple : la méthode prend une chaîne de caractères et retourne une chaîne de caractères)
             student.Introduce = new Func<string, string>(
                 (introduceTo) => string.Format("Hey {0}, c'est {1}", student.FirstName, introduceTo));
             Console.WriteLine(student.Introduce("Beth"));
@@ -505,7 +505,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
 
             // Creation d'une liste d'objet anonymes basés sur des paramètres de la classe Bike
             var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles });
-            // Le compilateur peut inférer le type de ces objets anonymes, permettant à certain IDE d'effectuer 
+            // Le compilateur peut inférer le type de ces objets anonymes, permettant à certains IDE d'effectuer 
             // des autos-complétion.
             foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome))
                 Console.WriteLine(bikeSummary.Name);
@@ -519,16 +519,16 @@ sur une nouvelle ligne! ""Wow!"", quel style";
             // machine dispose de plusieurs coeurs)
 
 
-            // LINQ - lie une source de donnée à des objets IQueryable<T>
-            // ex: LindToSql => liaison avec une base de données, LinqToXml => liaison avec un document xml
+            // LINQ - lie une source de données à des objets IQueryable<T>
+            // ex : LindToSql => liaison avec une base de données, LinqToXml => liaison avec un document xml
             var db = new BikeRespository();
 
             // l'exécution est décalée, ce qui est préférable quand on travaille sur une base données
-            var fitler = db.Bikes.Where(b => b.HasTassles); // pas de requête exécutée
+            var filter = db.Bikes.Where(b => b.HasTassles); // pas de requête exécutée
             if (42 > 6) //  Vous pouvez continuer à affiner la recherche
-                fitler = fitler.Where(b => b.IsBroken); // pas de requête exécutée
+                filter = filter.Where(b => b.IsBroken); // pas de requête exécutée
 
-            var query = fitler
+            var query = filter
                 .OrderBy(b => b.Wheels)
                 .ThenBy(b => b.Name)
                 .Select(b => b.Name); // toujours pas de requête exécutée
@@ -561,7 +561,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
     public class Bicycle
     {
         // Propriétés et variable de la classe
-        public int Cadence // Public: peut être accédé de partout
+        public int Cadence // Public : peut être accédé de partout
         {
             get // get - définit une méthode pour lire la propriété
             {
@@ -574,13 +574,13 @@ sur une nouvelle ligne! ""Wow!"", quel style";
         }
         private int _cadence;
 
-        protected virtual int Gear // Protected: accessible depuis la classe et ses classes filles
+        protected virtual int Gear // Protected : accessible depuis la classe et ses classes filles
         {
             get; // crée une propriété automatique, pas besoin de créer une variable de stockage
             set;
         }
 
-        internal int Wheels // Internal: accessible depuis l'assembly
+        internal int Wheels // Internal : accessible depuis l'assembly
         {
             get;
             private set; // Il est possible de choisir la portée d'un accesseur
@@ -609,8 +609,8 @@ sur une nouvelle ligne! ""Wow!"", quel style";
         public BikeBrand Brand; // Après avoir déclaré notre type enum, on peut créer un champ de ce type
 
         // Les membres statiques appartiennent à une classe plutôt qu'à une instance particulière
-        // Il est possible d'y accéder sans passer par un objet:
-        // ex: Console.WriteLine("Bicycles créés: " + Bicycle.bicyclesCreated);
+        // Il est possible d'y accéder sans passer par un objet :
+        // ex : Console.WriteLine("Bicycles créés : " + Bicycle.bicyclesCreated);
         static public int BicyclesCreated = 0;
 
         // Les valeurs en lecture seule sont affectées lors de l'exécution
@@ -648,7 +648,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
         {
         }
 
-        // Syntaxe de méthode:
+        // Syntaxe de méthode :
         // <public/private/protected> <type de retour> <nom de methode>(<args>)
 
         // Les classes peuvent implémenter des accesseurs pour leurs champs
@@ -688,7 +688,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
             private set;
         }
 
-        // Méthode qui affiche les valeurs des champs de cet objet
+        // Méthode qui affiche la valeur des champs de cet objet
         public virtual string Info()
         {
             return "Gear: " + Gear +
@@ -703,7 +703,7 @@ sur une nouvelle ligne! ""Wow!"", quel style";
         // Les méthodes peuvent aussi être statiques. Utile pour les méthodes d'aide.
         public static bool DidWeCreateEnoughBycles()
         {
-            // A l'intérieur d'une méthode statique on ne peut que référencer des membres statiques !
+            // À l'intérieur d'une méthode statique on ne peut que référencer des membres statiques !
             return BicyclesCreated > 9000;
         } // Si votre classe n'a que des membres statiques, marquez la comme statique 
 
-- 
cgit v1.2.3


From be55775d5a7b278048b08474e42aa9703bf3905b Mon Sep 17 00:00:00 2001
From: Arnaud <arnaud333@gmail.com>
Date: Tue, 15 Apr 2014 16:15:07 +0200
Subject: Escaped a quote

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

(limited to 'fr-fr')

diff --git a/fr-fr/python-fr.html.markdown b/fr-fr/python-fr.html.markdown
index 9dbdafe1..58a036ba 100644
--- a/fr-fr/python-fr.html.markdown
+++ b/fr-fr/python-fr.html.markdown
@@ -75,7 +75,7 @@ not False #=> True
 
 # Les chaînes de caractères sont créées avec " ou '
 "C'est une chaîne."
-'C'est aussi une chaîne.'
+'C\'est aussi une chaîne.'
 
 # On peut aussi les "additioner" !
 "Hello " + "world!" #=> "Hello world!"
-- 
cgit v1.2.3


From 664389fb7c17a8c7271b32270f51b38a85f75bdd Mon Sep 17 00:00:00 2001
From: chtiprog <chtiprog@free.fr>
Date: Tue, 10 Jun 2014 17:52:36 +0200
Subject: Added french version of Scala

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

(limited to 'fr-fr')

diff --git a/fr-fr/scala.html.markdown b/fr-fr/scala.html.markdown
new file mode 100644
index 00000000..56ecfb0b
--- /dev/null
+++ b/fr-fr/scala.html.markdown
@@ -0,0 +1,456 @@
+---
+language: Scala
+filename: learnscala.scala
+contributors:
+    - ["George Petrov", "http://github.com/petrovg"]
+    - ["Dominic Bou-Samra", "http://dbousamra.github.com"]
+translators:
+	- ["Anne-Catherine Dehier", "https://github.com/spellart"]
+filename: learn.scala
+lang: fr-fr
+---
+
+### Scala - le langage évolutif
+
+```scala
+
+/*
+  Pour vous préparer :
+
+  1) Téléchargez Scala - http://www.scala-lang.org/downloads
+  2) dézippez/décompressez dans votre endroit préféré
+  et ajoutez le chemin du sous-répertoire bin au chemin du système
+  3) Commencez un REPL de Scala en tapant juste scala. Vous devriez voir le prompteur :
+
+  scala>
+
+  C'est ce qu'on appelle un REPL. Vous pouvez y exécuter des commandes.
+  Allons-y :
+*/
+
+println(10) // imprime l'integer 10
+
+println("Boo!") // imprime avec retour à la ligne la chaîne de caractère Boo!
+
+
+// Quelques basiques
+
+// Imprimer et forcer une nouvelle ligne à la prochaine impression
+println("Hello world!")
+// Imprimer sans forcer une nouvelle ligne à la prochaine impression
+print("Hello world")
+
+// Pour déclarer des valeurs on utile var ou val
+// Les déclarations val sont immuables, tandis que les var sont muables.
+// L'immuabilité est une bonne chose.
+
+val x = 10 // x vaut maintenant 10
+x = 20 // erreur: réaffectation à val
+var x = 10
+x = 20  // x vaut maintenant 20
+
+// Les commentaires d'une ligne commencent par deux slashs
+
+/*
+Les commentaires multilignes ressemblent à ça.
+*/
+
+// les valeurs booléennes
+true
+false
+
+// Les opérateurs booléens
+!true // false
+!false // true
+true == false // false
+10 > 5 // true
+
+// Les maths sont comme d'habitude
+1 + 1 // 2
+2 - 1 // 1
+5 * 3 // 15
+6 / 2 // 3
+
+
+// REPL donne le type et la valeur du résultat quand vous évaluez une commande
+
+1 + 7
+
+/* Les lignes ci-dessous donne les résultats :
+
+  scala> 1 + 7
+  res29: Int = 8
+
+  Ça signifie que le résultat de l'évaluation 1 + 7 est un objet de
+  type Int avec une valeur de 8
+
+  1+7 donnera le même résultat
+*/
+
+
+// Tout est un objet, même une fonction. Tapez ceci dans le REPL :
+
+7 // donne res30: Int = 7 (res30 est seulement un nom de var généré pour le résultat)
+
+
+// La ligne suivante est une fonction qui prend un Int et retourne son carré
+(x:Int) => x * x
+
+
+// On peut assigner cette fonction à un identifieur comme ceci :
+val sq = (x:Int) => x * x
+
+/* La ligne suivante nous dit :
+
+   sq: Int => Int = <function1>
+
+   Ce qui signifie que cette fois-ci nous avons donné un nom explicite à la valeur
+   sq est une fonction qui prend un Int et retourne un Int.
+
+
+   sq peut-être exécuté comme ci-dessous :
+*/
+
+sq(10)   // donne comme résultat : res33: Int = 100.
+
+
+// les deux-points définissent explicitement le type de valeur,
+// dans ce cas une fonction qui prend un Int et retourne un Int.
+val add10: Int => Int = _ + 10
+
+// Scala autorise des méthodes et des fonctions pour retourner,
+// ou prendre comme paramètres, des autres fonctions ou méthodes
+
+
+List(1, 2, 3) map add10 // List(11, 12, 13) - add10 est appliqué à chaque éléments
+
+
+// Les fonctions anonymes peuvent être utilisées à la place des fonctions nommées :
+List(1, 2, 3) map (x => x + 10)
+
+
+
+
+// Le tiret du bas peut être utilisé si il n'y a qu'un paramètre à la fonction anonyme.
+// Il se borne à une variable
+List(1, 2, 3) map (_ + 10)
+
+
+
+// Si le bloc et la fonction anonyme prennent tous les deux un seul argument,
+// vous pouvez omettre le tiret du bas
+List("Dom", "Bob", "Natalia") foreach println
+
+
+
+// Les structures de données
+
+val a = Array(1, 2, 3, 5, 8, 13)
+a(0)
+a(3)
+a(21)    // Jette une exception
+
+val m = Map("fork" -> "tenedor", "spoon" -> "cuchara", "knife" -> "cuchillo")
+m("fork")
+m("spoon")
+m("bottle")       // Jette une exception
+
+val safeM = m.withDefaultValue("no lo se")
+safeM("bottle")
+
+val s = Set(1, 3, 7)
+s(0)
+s(1)
+
+/* Jetez un oeil sur la documentation de map ici -
+ * http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.Map
+ */
+
+
+// Tuples
+
+(1, 2)
+
+(4, 3, 2)
+
+(1, 2, "three")
+
+(a, 2, "three")
+
+// Pourquoi avoir ça ?
+val divideInts = (x:Int, y:Int) => (x / y, x % y)
+
+
+divideInts(10,3) // La fonction divideInts donne le résultat et le reste de la division
+
+// Pour accéder à un élément d'un tuple, utilisez _._n 
+// où n est l'index de base 1 de l'élément
+val d = divideInts(10,3)
+
+d._1
+
+d._2
+
+
+
+// Des combinaisons
+
+s.map(sq)
+
+val sSquared = s. map(sq)
+
+sSquared.filter(_ < 10)
+
+sSquared.reduce (_+_)
+
+
+
+// La fonction filter prends un prédicat (une fonction de A -> Booléen) et
+// sélectionne tous les éléments qui satisfont ce prédicat
+List(1, 2, 3) filter (_ > 2) // List(3)
+List(
+  Person(name = "Dom", age = 23),
+  Person(name = "Bob", age = 30)
+).filter(_.age > 25) // List(Person("Bob", 30))
+
+
+
+// Scala a une méthode foreach définie pour certaines collections
+// qui prend un type d'argument retournant Unit (une méthode void)
+aListOfNumbers foreach (x => println(x))
+aListOfNumbers foreach println
+
+
+
+
+// For compréhensions
+
+for { n <- s } yield sq(n)
+
+val nSquared2 = for { n <- s } yield sq(n)
+
+for { n <- nSquared2 if n < 10 } yield n
+
+for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared
+
+ 
+
+/* Ci-dessus ce ne sont pas des boucles for. La sémantique des boucles for est "répète",
+   alors qu'une for-compréhension définit une relation entre deux ensembles de données. */
+
+
+
+// Boucles et itération
+
+1 to 5
+val r = 1 to 5
+r.foreach( println )
+
+r foreach println
+// NB: Scala est vraiment tolérant par rapport aux points et aux parenthèses en étudiant
+// les roles séparément. Ça aide pour écrire des DSL ou des API qui se lisent comme en anglais
+
+
+(5 to 1 by -1) foreach ( println )
+
+// Une boucle while
+var i = 0
+while (i < 10) {  println("i " + i); i+=1  }
+
+while (i < 10) {  println("i " + i); i+=1  }  // Oui, encore. Qu'est-ce qui s'est passé ? Pourquoi ?
+
+
+
+
+
+
+i    // Montre la valeur de i. Notez que while est une boucle au sens classique.
+     // Il exécute séquentiellement pendant que la variable de boucle change. 
+     // While est très rapide, plus rapide que les boucles Java, 
+     // mais utiliser des combinateurs et des compréhensions comme ci-dessus est plus 
+     // facile pour comprendre et faire le parallèle
+
+// La boucle do while
+do {
+  println("x is still less then 10");
+  x += 1
+} while (x < 10)
+
+
+// La récursivité est un moyen idiomatique de faire une chose récurrente en Scala.
+// Les fonctions récursives ont besoin d'un type de retour explicite, 
+// le compilateur ne peut pas le déduire. 
+// Ici c'est Unit.
+def showNumbersInRange(a:Int, b:Int):Unit = {
+  print(a)
+  if (a < b)
+    showNumbersInRange(a + 1, b)
+}
+
+
+
+// Conditionnelles
+
+val x = 10
+
+if (x == 1) println("yeah")
+if (x == 10) println("yeah")
+if (x == 11) println("yeah")
+if (x == 11) println ("yeah") else println("nay")
+
+println(if (x == 10) "yeah" else "nope")
+val text = if (x == 10) "yeah" else "nope"
+
+var i = 0
+while (i < 10) { println("i " + i); i+=1  }
+
+
+
+// Les caractéristiques orientées objets
+
+// Classname is Dog
+class Dog {
+  // Une méthode appelée bark qui retourne une chaîne de caractère
+  def bark: String = {
+    // le corps de la méthode
+    "Woof, woof!"
+  }
+}
+
+
+// Les classes peuvent contenir presque n'importe quel autre constructeur, incluant d'autres classes,
+// des fonctions, des méthodes, des objets, des classes case, des traits, etc ...
+
+
+
+// Les classes case
+
+case class Person(name:String, phoneNumber:String)
+
+Person("George", "1234") == Person("Kate", "1236")
+
+
+
+
+// Correspondances de motifs
+
+val me = Person("George", "1234")
+
+me match { case Person(name, number) => {
+            "We matched someone : " + name + ", phone : " + number }}
+
+me match { case Person(name, number) => "Match : " + name; case _ => "Hm..." }
+
+me match { case Person("George", number) => "Match"; case _ => "Hm..." }
+
+me match { case Person("Kate", number) => "Match"; case _ => "Hm..." }
+
+me match { case Person("Kate", _) => "Girl"; case Person("George", _) => "Boy" }
+
+val kate = Person("Kate", "1234")
+
+kate match { case Person("Kate", _) => "Girl"; case Person("George", _) => "Boy" }
+
+
+
+// Expressions régulières
+
+val email = "(.*)@(.*)".r  // On fait un Regex en invoquant r sur la chaîne de caractère 
+
+val email(user, domain) = "henry@zkpr.com"
+
+"mrbean@pyahoo.com" match {
+  case email(name, domain) => "I know your name, " + name
+}
+
+
+
+// Les chaînes de caractères
+
+"Les chaînes de caractères Scala sont entourées de doubles guillements" //
+'a' // Un caractère de Scala
+'Les simples guillemets n'existent pas en Scala // Erreur
+"Les chaînes de caractères possèdent les méthodes usuelles de Java".length 
+"Il y a aussi quelques méthodes extra de Scala.".reverse 
+
+// Voir également :  scala.collection.immutable.StringOps
+
+println("ABCDEF".length)
+println("ABCDEF".substring(2, 6))
+println("ABCDEF".replace("C", "3"))
+
+val n = 45
+println(s"We have $n apples")
+
+val a = Array(11, 9, 6)
+println(s"My second daughter is ${a(2-1)} years old")
+
+// Certains caractères ont besoin d'être "échappés", 
+// ex un double guillement à l'intérieur d'une chaîne de caractère :
+val a = "They stood outside the \"Rose and Crown\""
+
+// Les triples doubles guillemets permettent d'écrire des chaînes de caractères
+// sur plusieurs lignes et peuvent contenir des guillements
+
+val html = """<form id="daform">
+                <p>Press belo', Joe</p>
+             |  <input type="submit">
+              </form>"""
+
+
+
+// Structure et organisation d'une application
+
+// Importer des chaînes de caratères
+import scala.collection.immutable.List
+
+// Importer tous les sous-paquets
+import scala.collection.immutable._
+
+// Importer des classes multiples en une seule instruction
+import scala.collection.immutable.{List, Map}
+
+// Renommer un import en utilisant '=>' 
+import scala.collection.immutable.{ List => ImmutableList }
+
+// Importer toutes les classes, à l'exception de quelques unes. 
+// Les suivantes excluant Map et Set :
+import scala.collection.immutable.{Map => _, Set => _, _}
+
+// Le point d'entrée du programme est défini dans un fichier scala 
+// utilisant un objet, avec une simple méthode, main :
+object Application {
+  def main(args: Array[String]): Unit = {
+    // stuff goes here.
+  }
+}
+
+// Les fichiers peuvent contenir des classes multiples et des objets. 
+// On les compile avec scalac
+
+
+
+
+// Entrée et Sortie
+
+// Pour lire un fichier lignes par lignes
+import scala.io.Source
+for(line <- Source.fromFile("myfile.txt").getLines())
+  println(line)
+
+// On utilise Java's PrintWriter pour écrire un fichier
+
+
+```
+
+## Autres ressources
+
+[Scala for the impatient](http://horstmann.com/scala/)
+
+[Twitter Scala school](http://twitter.github.io/scala_school/)
+
+[The scala documentation](http://docs.scala-lang.org/)
+
+[Try Scala in your browser](http://scalatutorials.com/tour/)
+
+Rejoindre le[Scala user group](https://groups.google.com/forum/#!forum/scala-user)
-- 
cgit v1.2.3


From f011c1af0e84570e567d07e48904b579b8b58a1f Mon Sep 17 00:00:00 2001
From: chtiprog <chtiprog@free.fr>
Date: Tue, 10 Jun 2014 23:12:07 +0200
Subject: Updated french version of scala

---
 fr-fr/scala.html.markdown | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/scala.html.markdown b/fr-fr/scala.html.markdown
index 56ecfb0b..dfcdf7cc 100644
--- a/fr-fr/scala.html.markdown
+++ b/fr-fr/scala.html.markdown
@@ -148,12 +148,12 @@ List("Dom", "Bob", "Natalia") foreach println
 val a = Array(1, 2, 3, 5, 8, 13)
 a(0)
 a(3)
-a(21)    // Jette une exception
+a(21)    // Lance une exception
 
 val m = Map("fork" -> "tenedor", "spoon" -> "cuchara", "knife" -> "cuchillo")
 m("fork")
 m("spoon")
-m("bottle")       // Jette une exception
+m("bottle")       // Lance une exception
 
 val safeM = m.withDefaultValue("no lo se")
 safeM("bottle")
@@ -183,7 +183,7 @@ val divideInts = (x:Int, y:Int) => (x / y, x % y)
 
 divideInts(10,3) // La fonction divideInts donne le résultat et le reste de la division
 
-// Pour accéder à un élément d'un tuple, utilisez _._n 
+// Pour accéder à un élément d'un tuple, utilisez _._n
 // où n est l'index de base 1 de l'élément
 val d = divideInts(10,3)
 
@@ -233,7 +233,7 @@ for { n <- nSquared2 if n < 10 } yield n
 
 for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared
 
- 
+
 
 /* Ci-dessus ce ne sont pas des boucles for. La sémantique des boucles for est "répète",
    alors qu'une for-compréhension définit une relation entre deux ensembles de données. */
@@ -265,9 +265,9 @@ while (i < 10) {  println("i " + i); i+=1  }  // Oui, encore. Qu'est-ce qui s'es
 
 
 i    // Montre la valeur de i. Notez que while est une boucle au sens classique.
-     // Il exécute séquentiellement pendant que la variable de boucle change. 
-     // While est très rapide, plus rapide que les boucles Java, 
-     // mais utiliser des combinateurs et des compréhensions comme ci-dessus est plus 
+     // Il exécute séquentiellement pendant que la variable de boucle change.
+     // While est très rapide, plus rapide que les boucles Java,
+     // mais utiliser des combinateurs et des compréhensions comme ci-dessus est plus
      // facile pour comprendre et faire le parallèle
 
 // La boucle do while
@@ -278,8 +278,8 @@ do {
 
 
 // La récursivité est un moyen idiomatique de faire une chose récurrente en Scala.
-// Les fonctions récursives ont besoin d'un type de retour explicite, 
-// le compilateur ne peut pas le déduire. 
+// Les fonctions récursives ont besoin d'un type de retour explicite,
+// le compilateur ne peut pas le déduire.
 // Ici c'est Unit.
 def showNumbersInRange(a:Int, b:Int):Unit = {
   print(a)
@@ -355,7 +355,7 @@ kate match { case Person("Kate", _) => "Girl"; case Person("George", _) => "Boy"
 
 // Expressions régulières
 
-val email = "(.*)@(.*)".r  // On fait un Regex en invoquant r sur la chaîne de caractère 
+val email = "(.*)@(.*)".r  // On fait un Regex en invoquant r sur la chaîne de caractère
 
 val email(user, domain) = "henry@zkpr.com"
 
@@ -370,8 +370,8 @@ val email(user, domain) = "henry@zkpr.com"
 "Les chaînes de caractères Scala sont entourées de doubles guillements" //
 'a' // Un caractère de Scala
 'Les simples guillemets n'existent pas en Scala // Erreur
-"Les chaînes de caractères possèdent les méthodes usuelles de Java".length 
-"Il y a aussi quelques méthodes extra de Scala.".reverse 
+"Les chaînes de caractères possèdent les méthodes usuelles de Java".length
+"Il y a aussi quelques méthodes extra de Scala.".reverse
 
 // Voir également :  scala.collection.immutable.StringOps
 
@@ -385,7 +385,7 @@ println(s"We have $n apples")
 val a = Array(11, 9, 6)
 println(s"My second daughter is ${a(2-1)} years old")
 
-// Certains caractères ont besoin d'être "échappés", 
+// Certains caractères ont besoin d'être "échappés",
 // ex un double guillement à l'intérieur d'une chaîne de caractère :
 val a = "They stood outside the \"Rose and Crown\""
 
@@ -410,14 +410,14 @@ import scala.collection.immutable._
 // Importer des classes multiples en une seule instruction
 import scala.collection.immutable.{List, Map}
 
-// Renommer un import en utilisant '=>' 
+// Renommer un import en utilisant '=>'
 import scala.collection.immutable.{ List => ImmutableList }
 
-// Importer toutes les classes, à l'exception de quelques unes. 
+// Importer toutes les classes, à l'exception de quelques unes.
 // Les suivantes excluant Map et Set :
 import scala.collection.immutable.{Map => _, Set => _, _}
 
-// Le point d'entrée du programme est défini dans un fichier scala 
+// Le point d'entrée du programme est défini dans un fichier scala
 // utilisant un objet, avec une simple méthode, main :
 object Application {
   def main(args: Array[String]): Unit = {
@@ -425,7 +425,7 @@ object Application {
   }
 }
 
-// Les fichiers peuvent contenir des classes multiples et des objets. 
+// Les fichiers peuvent contenir des classes multiples et des objets.
 // On les compile avec scalac
 
 
-- 
cgit v1.2.3


From 57cc424b54736287f911777f8b9615882647374d Mon Sep 17 00:00:00 2001
From: chtiprog <chtiprog@free.fr>
Date: Sat, 14 Jun 2014 13:04:18 +0200
Subject: Corrections after pull request of the french translation of Scala

---
 fr-fr/scala.html.markdown | 96 ++++++++++++++++++++++++-----------------------
 1 file changed, 49 insertions(+), 47 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/scala.html.markdown b/fr-fr/scala.html.markdown
index dfcdf7cc..2e18d219 100644
--- a/fr-fr/scala.html.markdown
+++ b/fr-fr/scala.html.markdown
@@ -18,19 +18,20 @@ lang: fr-fr
   Pour vous préparer :
 
   1) Téléchargez Scala - http://www.scala-lang.org/downloads
-  2) dézippez/décompressez dans votre endroit préféré
+  2) Dézippez/décompressez dans votre endroit préféré
   et ajoutez le chemin du sous-répertoire bin au chemin du système
   3) Commencez un REPL de Scala en tapant juste scala. Vous devriez voir le prompteur :
 
   scala>
 
-  C'est ce qu'on appelle un REPL. Vous pouvez y exécuter des commandes.
+  C'est ce qu'on appelle un REPL (Read-Eval-Print-Loop), c'est une interface de programmation interactive. 
+  Vous pouvez y exécuter des commandes.
   Allons-y :
 */
 
-println(10) // imprime l'integer 10
+println(10) // affiche l'integer 10
 
-println("Boo!") // imprime avec retour à la ligne la chaîne de caractère Boo!
+println("Boo!") // affiche avec retour à la ligne la chaîne de caractère Boo!
 
 
 // Quelques basiques
@@ -40,14 +41,14 @@ println("Hello world!")
 // Imprimer sans forcer une nouvelle ligne à la prochaine impression
 print("Hello world")
 
-// Pour déclarer des valeurs on utile var ou val
+// Pour déclarer des valeurs on utilise var ou val
 // Les déclarations val sont immuables, tandis que les var sont muables.
 // L'immuabilité est une bonne chose.
 
 val x = 10 // x vaut maintenant 10
-x = 20 // erreur: réaffectation à val
+x = 20 // erreur : réaffectation à val
 var x = 10
-x = 20  // x vaut maintenant 20
+x = 20 // x vaut maintenant 20
 
 // Les commentaires d'une ligne commencent par deux slashs
 
@@ -65,18 +66,18 @@ false
 true == false // false
 10 > 5 // true
 
-// Les maths sont comme d'habitude
+// Les opérateurs mathématiques sont habituels
 1 + 1 // 2
 2 - 1 // 1
 5 * 3 // 15
 6 / 2 // 3
 
 
-// REPL donne le type et la valeur du résultat quand vous évaluez une commande
+// Le REPL donne le type et la valeur du résultat quand vous évaluez une commande
 
 1 + 7
 
-/* Les lignes ci-dessous donne les résultats :
+/* Les lignes ci-dessous donnent les résultats :
 
   scala> 1 + 7
   res29: Int = 8
@@ -90,7 +91,7 @@ true == false // false
 
 // Tout est un objet, même une fonction. Tapez ceci dans le REPL :
 
-7 // donne res30: Int = 7 (res30 est seulement un nom de var généré pour le résultat)
+7 // donne res30: Int = 7 (res30 est seulement un nom de variable généré pour le résultat)
 
 
 // La ligne suivante est une fonction qui prend un Int et retourne son carré
@@ -104,22 +105,22 @@ val sq = (x:Int) => x * x
 
    sq: Int => Int = <function1>
 
-   Ce qui signifie que cette fois-ci nous avons donné un nom explicite à la valeur
+   Ce qui signifie que cette fois-ci nous avons donné un nom explicite à la valeur.
    sq est une fonction qui prend un Int et retourne un Int.
 
 
-   sq peut-être exécuté comme ci-dessous :
+   sq peut être exécutée comme ci-dessous :
 */
 
-sq(10)   // donne comme résultat : res33: Int = 100.
+sq(10) // donne comme résultat : res33: Int = 100.
 
 
-// les deux-points définissent explicitement le type de valeur,
+// les deux-points définissent explicitement le type de la valeur,
 // dans ce cas une fonction qui prend un Int et retourne un Int.
 val add10: Int => Int = _ + 10
 
-// Scala autorise des méthodes et des fonctions pour retourner,
-// ou prendre comme paramètres, des autres fonctions ou méthodes
+// Scala autorise des méthodes et des fonctions à retourner
+// ou prendre comme paramètres des autres fonctions ou méthodes
 
 
 List(1, 2, 3) map add10 // List(11, 12, 13) - add10 est appliqué à chaque éléments
@@ -131,8 +132,8 @@ List(1, 2, 3) map (x => x + 10)
 
 
 
-// Le tiret du bas peut être utilisé si il n'y a qu'un paramètre à la fonction anonyme.
-// Il se borne à une variable
+// Le tiret du bas peut être utilisé si la fonction anonyme ne prend qu'un paramètre.
+// Il se comporte comme une variable
 List(1, 2, 3) map (_ + 10)
 
 
@@ -177,7 +178,7 @@ s(1)
 
 (a, 2, "three")
 
-// Pourquoi avoir ça ?
+// Exemple d'utilisation
 val divideInts = (x:Int, y:Int) => (x / y, x % y)
 
 
@@ -205,7 +206,7 @@ sSquared.reduce (_+_)
 
 
 
-// La fonction filter prends un prédicat (une fonction de A -> Booléen) et
+// La fonction filter prend un prédicat (une fonction de type A -> Booléen) et
 // sélectionne tous les éléments qui satisfont ce prédicat
 List(1, 2, 3) filter (_ > 2) // List(3)
 List(
@@ -216,14 +217,14 @@ List(
 
 
 // Scala a une méthode foreach définie pour certaines collections
-// qui prend un type d'argument retournant Unit (une méthode void)
+// qui prend en argument une fonction renvoyant Unit (une méthode void)
 aListOfNumbers foreach (x => println(x))
 aListOfNumbers foreach println
 
 
 
 
-// For compréhensions
+// Compréhensions de listes
 
 for { n <- s } yield sq(n)
 
@@ -235,8 +236,9 @@ for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared
 
 
 
-/* Ci-dessus ce ne sont pas des boucles for. La sémantique des boucles for est "répète",
-   alors qu'une for-compréhension définit une relation entre deux ensembles de données. */
+/* Les exemples précédents ne sont pas des boucles for. La sémantique des boucles for
+   est "répète", alors qu'une for-compréhension définit une relation 
+   entre deux ensembles de données. */
 
 
 
@@ -247,8 +249,8 @@ val r = 1 to 5
 r.foreach( println )
 
 r foreach println
-// NB: Scala est vraiment tolérant par rapport aux points et aux parenthèses en étudiant
-// les roles séparément. Ça aide pour écrire des DSL ou des API qui se lisent comme en anglais
+// NB: Scala est vraiment tolérant par rapport aux points et aux parenthèses en étudiant les roles séparément. 
+// Ça aide pour écrire des DSL ou des API qui se lisent comme en anglais.
 
 
 (5 to 1 by -1) foreach ( println )
@@ -277,7 +279,7 @@ do {
 } while (x < 10)
 
 
-// La récursivité est un moyen idiomatique de faire une chose récurrente en Scala.
+// La récursivité est un moyen idiomatique de faire une chose répétitive en Scala.
 // Les fonctions récursives ont besoin d'un type de retour explicite,
 // le compilateur ne peut pas le déduire.
 // Ici c'est Unit.
@@ -289,7 +291,7 @@ def showNumbersInRange(a:Int, b:Int):Unit = {
 
 
 
-// Conditionnelles
+// Structures de contrôle
 
 val x = 10
 
@@ -306,9 +308,9 @@ while (i < 10) { println("i " + i); i+=1  }
 
 
 
-// Les caractéristiques orientées objets
+// Les caractéristiques "Orienté Objet"
 
-// Classname is Dog
+// Création d'une classe Dog
 class Dog {
   // Une méthode appelée bark qui retourne une chaîne de caractère
   def bark: String = {
@@ -318,7 +320,7 @@ class Dog {
 }
 
 
-// Les classes peuvent contenir presque n'importe quel autre constructeur, incluant d'autres classes,
+// Les classes peuvent contenir presque n'importe quelle autre construction, incluant d'autres classes,
 // des fonctions, des méthodes, des objets, des classes case, des traits, etc ...
 
 
@@ -355,7 +357,7 @@ kate match { case Person("Kate", _) => "Girl"; case Person("George", _) => "Boy"
 
 // Expressions régulières
 
-val email = "(.*)@(.*)".r  // On fait un Regex en invoquant r sur la chaîne de caractère
+val email = "(.*)@(.*)".r  // On fait une Regex en invoquant r sur la chaîne de caractère
 
 val email(user, domain) = "henry@zkpr.com"
 
@@ -367,13 +369,13 @@ val email(user, domain) = "henry@zkpr.com"
 
 // Les chaînes de caractères
 
-"Les chaînes de caractères Scala sont entourées de doubles guillements" //
+"Les chaînes de caractères Scala sont entourées de doubles guillements"
 'a' // Un caractère de Scala
 'Les simples guillemets n'existent pas en Scala // Erreur
 "Les chaînes de caractères possèdent les méthodes usuelles de Java".length
 "Il y a aussi quelques méthodes extra de Scala.".reverse
 
-// Voir également :  scala.collection.immutable.StringOps
+// Voir également : scala.collection.immutable.StringOps
 
 println("ABCDEF".length)
 println("ABCDEF".substring(2, 6))
@@ -386,11 +388,11 @@ val a = Array(11, 9, 6)
 println(s"My second daughter is ${a(2-1)} years old")
 
 // Certains caractères ont besoin d'être "échappés",
-// ex un double guillement à l'intérieur d'une chaîne de caractère :
+// ex un guillemet à l'intérieur d'une chaîne de caractères :
 val a = "They stood outside the \"Rose and Crown\""
 
-// Les triples doubles guillemets permettent d'écrire des chaînes de caractères
-// sur plusieurs lignes et peuvent contenir des guillements
+// Les triples guillemets permettent d'écrire des chaînes de caractères
+// sur plusieurs lignes et peuvent contenir des guillemets
 
 val html = """<form id="daform">
                 <p>Press belo', Joe</p>
@@ -407,25 +409,25 @@ import scala.collection.immutable.List
 // Importer tous les sous-paquets
 import scala.collection.immutable._
 
-// Importer des classes multiples en une seule instruction
+// Importer plusieurs classes en une seule instruction
 import scala.collection.immutable.{List, Map}
 
 // Renommer un import en utilisant '=>'
 import scala.collection.immutable.{ List => ImmutableList }
 
-// Importer toutes les classes, à l'exception de quelques unes.
-// Les suivantes excluant Map et Set :
+// Importer toutes les classes, à l'exception de certaines.
+// La ligne suivante exclut Map et Set :
 import scala.collection.immutable.{Map => _, Set => _, _}
 
 // Le point d'entrée du programme est défini dans un fichier scala
-// utilisant un objet, avec une simple méthode, main :
+// utilisant un objet, avec une simple méthode main :
 object Application {
   def main(args: Array[String]): Unit = {
-    // stuff goes here.
+    // Votre code ici.
   }
 }
 
-// Les fichiers peuvent contenir des classes multiples et des objets.
+// Les fichiers peuvent contenir plusieurs classes et plusieurs objets.
 // On les compile avec scalac
 
 
@@ -433,12 +435,12 @@ object Application {
 
 // Entrée et Sortie
 
-// Pour lire un fichier lignes par lignes
+// Pour lire un fichier ligne par ligne
 import scala.io.Source
 for(line <- Source.fromFile("myfile.txt").getLines())
   println(line)
 
-// On utilise Java's PrintWriter pour écrire un fichier
+// On utilise le PrintWriter de Java pour écrire un fichier
 
 
 ```
@@ -453,4 +455,4 @@ for(line <- Source.fromFile("myfile.txt").getLines())
 
 [Try Scala in your browser](http://scalatutorials.com/tour/)
 
-Rejoindre le[Scala user group](https://groups.google.com/forum/#!forum/scala-user)
+Rejoindre le [Scala user group](https://groups.google.com/forum/#!forum/scala-user)
-- 
cgit v1.2.3


From ad9186f4f8389cb4cb23744a80bcf7bf47735869 Mon Sep 17 00:00:00 2001
From: chtiprog <chtiprog@free.fr>
Date: Sat, 14 Jun 2014 19:26:14 +0200
Subject: Updated links and fix typo

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

(limited to 'fr-fr')

diff --git a/fr-fr/scala.html.markdown b/fr-fr/scala.html.markdown
index 2e18d219..46f602ff 100644
--- a/fr-fr/scala.html.markdown
+++ b/fr-fr/scala.html.markdown
@@ -17,14 +17,14 @@ lang: fr-fr
 /*
   Pour vous préparer :
 
-  1) Téléchargez Scala - http://www.scala-lang.org/downloads
+  1) (Téléchargez Scala)[http://www.scala-lang.org/downloads]
   2) Dézippez/décompressez dans votre endroit préféré
   et ajoutez le chemin du sous-répertoire bin au chemin du système
   3) Commencez un REPL de Scala en tapant juste scala. Vous devriez voir le prompteur :
 
   scala>
 
-  C'est ce qu'on appelle un REPL (Read-Eval-Print-Loop), c'est une interface de programmation interactive. 
+  C'est ce qu'on appelle un REPL (Read-Eval-Print-Loop), c'est une interface de programmation interactive.
   Vous pouvez y exécuter des commandes.
   Allons-y :
 */
@@ -237,7 +237,7 @@ for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared
 
 
 /* Les exemples précédents ne sont pas des boucles for. La sémantique des boucles for
-   est "répète", alors qu'une for-compréhension définit une relation 
+   est "répète", alors qu'une for-compréhension définit une relation
    entre deux ensembles de données. */
 
 
@@ -249,7 +249,7 @@ val r = 1 to 5
 r.foreach( println )
 
 r foreach println
-// NB: Scala est vraiment tolérant par rapport aux points et aux parenthèses en étudiant les roles séparément. 
+// NB: Scala est vraiment tolérant par rapport aux points et aux parenthèses en étudiant les roles séparément.
 // Ça aide pour écrire des DSL ou des API qui se lisent comme en anglais.
 
 
@@ -270,7 +270,7 @@ i    // Montre la valeur de i. Notez que while est une boucle au sens classique.
      // Il exécute séquentiellement pendant que la variable de boucle change.
      // While est très rapide, plus rapide que les boucles Java,
      // mais utiliser des combinateurs et des compréhensions comme ci-dessus est plus
-     // facile pour comprendre et faire le parallèle
+     // facile pour comprendre et faire la parallélisation
 
 // La boucle do while
 do {
-- 
cgit v1.2.3


From 7c306cead86cbcfe56c0f5b112066260389b28ea Mon Sep 17 00:00:00 2001
From: chtiprog <chtiprog@free.fr>
Date: Sat, 14 Jun 2014 19:37:45 +0200
Subject: Removing comparison with java performance for while loops

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

(limited to 'fr-fr')

diff --git a/fr-fr/scala.html.markdown b/fr-fr/scala.html.markdown
index 46f602ff..da562138 100644
--- a/fr-fr/scala.html.markdown
+++ b/fr-fr/scala.html.markdown
@@ -268,9 +268,9 @@ while (i < 10) {  println("i " + i); i+=1  }  // Oui, encore. Qu'est-ce qui s'es
 
 i    // Montre la valeur de i. Notez que while est une boucle au sens classique.
      // Il exécute séquentiellement pendant que la variable de boucle change.
-     // While est très rapide, plus rapide que les boucles Java,
+     // While est très rapide,
      // mais utiliser des combinateurs et des compréhensions comme ci-dessus est plus
-     // facile pour comprendre et faire la parallélisation
+     // facile pour comprendre et pour faire la parallélisation
 
 // La boucle do while
 do {
-- 
cgit v1.2.3


From cf3ea24d41cade2420c85c54e71228561f43b354 Mon Sep 17 00:00:00 2001
From: Amar Sood <mail@tekacs.com>
Date: Tue, 22 Jul 2014 13:06:18 +0100
Subject: Fix 'filename' collision between csharp{,-fr}.html.markdown

Both were set to LearnCSharp.cs, so the live site has been serving the French version for English.

(see set_rawcode: https://github.com/adambard/learnxinyminutes-site/blob/547a620dd8dc78f8518b0072e456ae2d384a0465/config.rb#L103)
---
 fr-fr/csharp-fr.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'fr-fr')

diff --git a/fr-fr/csharp-fr.html.markdown b/fr-fr/csharp-fr.html.markdown
index c1641716..e51eacc8 100644
--- a/fr-fr/csharp-fr.html.markdown
+++ b/fr-fr/csharp-fr.html.markdown
@@ -7,7 +7,7 @@ contributors:
     - ["Shaun McCarthy", "http://www.shaunmccarthy.com"]
 translators:
     - ["Olivier Hoarau", "https://github.com/Olwaro"]
-filename: LearnCSharp.cs
+filename: LearnCSharp-fr.cs
 lang: fr-fr
 ---
 
-- 
cgit v1.2.3


From b33208ad676473b403d4f838b2c89bbae3056f51 Mon Sep 17 00:00:00 2001
From: Pierre-Arnaud Baciocchini <pierre.baciocchini@gmail.com>
Date: Tue, 19 Aug 2014 16:48:56 +0200
Subject: Added french translation for Swift

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

(limited to 'fr-fr')

diff --git a/fr-fr/swift-fr.html.markdown b/fr-fr/swift-fr.html.markdown
new file mode 100644
index 00000000..18628524
--- /dev/null
+++ b/fr-fr/swift-fr.html.markdown
@@ -0,0 +1,225 @@
+---
+language: swift
+contributors:
+  - ["Grant Timmerman", "http://github.com/grant"]
+translators:
+  - ["@prrrnd", "https://github.com/prrrnd"]
+lang: fr-fr
+---
+
+Swift est un langage de programmation crée par Apple pour iOS et OS X. Swift a été introduit en 2014 à la conférence WWDC d'Apple. Il est construit avec le compilateur LLVM inclus dans la version bétâ de Xcode 6.
+
+Pour plus d'informations, en anglais, regardez le [guide d'Apple](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/LandingPage/index.html), qui inclus un tutoriel complet sur Swift.
+
+```js
+//
+// Bases
+//
+
+println("Hello, world")
+var myVariable = 42
+let myConstant = 3.1415926
+let explicitDouble: Double = 70
+let label = "du texte " + String(myVariable)      // Cast
+let piText = "Pi = \(myConstant)"                 // Interpolation
+var optionalString: String? = "optional"          // Peut être nil
+optionalString = nil
+
+
+//
+// Tableaux et dictionnaires
+//
+
+// Tableau
+var shoppingList = ["poisson", "eau", "citrons"]
+shoppingList[1] = "bouteille d'eau"
+let tableauVide = [String]()
+
+// Dictionnaire
+var occupations = [
+  "Malcolm": "Capitaine",
+  "kaylee": "Mécanicien"
+]
+occupations["Jayne"] = "Secretaire"
+let dicoVide = Dictionary<String, Float>()
+
+
+//
+// Contrôle et boucles
+//
+
+// Boucle for (tableau)
+let monTableau = [1, 1, 2, 3, 5]
+for value in monTableau {
+  if value == 1 {
+    println("Un!")
+  } else {
+    println("Pas un!")
+  }
+}
+
+// Boucle for (dictionnaire)
+for (key, value) in dict {
+  println("\(key): \(value)")
+}
+
+// Boucle for (interval)
+for i in -1...1 { // [-1, 0, 1]
+  println(i)
+}
+// utilisez ..< pour exclure le dernier élement
+
+// Boucle while
+var i = 1
+while i < 1000 {
+  i *= 2
+}
+
+// Boucle do-while
+do {
+  println("bonjour")
+} while 1 == 2
+
+// Switch
+let legume = "haricot"
+switch legume {
+case "haricot":
+  // ...
+case "concombre", "patate":
+  // ...
+default: // requis afin de couvrir toutes les possibilités
+  // ...
+}
+
+
+//
+// Fonctions
+//
+
+// Les fonctions sont de type primitif, ce qui veut dire qu'elles peuvent être incluses dans d'autres fonctions
+
+// Fonction
+func direBonjour(name: String, day: String) -> String {
+  return "Bonjour \(name), on est \(day) aujourd'hui."
+}
+direBonjour("Bob", "mardi")
+
+// Fonction qui retourne plusieurs valeurs dans un tuple
+func getPrix() -> (Double, Double, Double) {
+  return (3.59, 3.69, 3.79)
+}
+
+// Arguments
+func setup(nombres: Int...) {}
+
+// Passer et retourner des fonctions
+func augmenter() -> (Int -> Int) {
+  func ajouterUn(nombre: Int) -> Int {
+    return 1 + nombre
+  }
+  return ajouterUn
+}
+var increment = augmenter()
+increment(7)
+
+
+//
+// Closures
+//
+var nombres = [1, 2, 6]
+
+// Les fonctions sont des cas de closures spéciales ({})
+
+// Exemple de closure.
+// `->` sépare les arguments et le type de retour
+// `in` sépare l'en-tête de closure de son corps
+nombres.map({
+  (nombre: Int) -> Int in
+  let resultat = 3 * nombre
+  return resultat
+  })
+
+// Lorsque le type est connu, comme ci-dessus, on peut faire ceci
+nombres = nombres.map({ nombre in 3 * nombre })
+//Ou cela
+//nombres = nombres.map({ $0 * 3 })
+
+print(nombres) // [3, 6, 18]
+
+
+//
+// Classes
+//
+
+// Toutes les méthodes et propriétés d'une classe sont publiques.
+// Si vous avez juste besoin de stocker des données dans un
+// objet structuré, vous devez utiliser une structure
+
+// Une classe `Square` hérite d'une classe `Shape`
+class Rect: Shape {
+  var longueurCote: Int = 1
+
+  // Custom getter and setter property
+  var perimeter: Int {
+    get {
+      return 4 * longueurCote
+    }
+    set {
+      longueurCote = newValue / 4
+    }
+  }
+
+  init(longueurCote: Int) {
+    super.init()
+    self.longueurCote = longueurCote
+  }
+
+  func shrink() {
+    if longueurCote > 0 {
+      --longueurCote
+    }
+  }
+
+  override func getArea() -> Int {
+    return longueurCote * longueurCote
+  }
+}
+var monCarre = new Square(longueurCote: 5)
+print(monCarre.getArea()) // 25
+monCarre.shrink()
+print(monCarre.longueurCote) // 4
+
+// If you don't need a custom getter and setter,
+// but still want to run code before and after getting or setting
+// a property, you can use `willSet` and `didSet`
+
+
+//
+// Enumerations
+//
+
+// Les énumerations peuvent être d'un type spécifique ou non.
+// Elles peuvent contenir méthodes et classes
+
+enum Suit {
+  case Pic, Coeur, Carre, Trefle
+  func getIcon() -> String {
+    switch self {
+    case .Pic: return "♤"
+    case .Coeur: return "♡"
+    case .Carre: return "♢"
+    case .Trefle: return "♧"
+    }
+  }
+}
+
+
+//
+// Autres
+//
+
+// `protocol`: Similaire aux interfaces en Java
+// `extension`s: Permet d'ajouter des fonctionnalités à un type existant
+// Generics: Similaire à Java. Utilisez le mot clé `where` pour specifier les pré-requis du generic
+
+```
-- 
cgit v1.2.3


From e5a61a1db19f9099697791958a53c809d2050866 Mon Sep 17 00:00:00 2001
From: MrAkirah <akira.aymane@gmail.com>
Date: Tue, 19 Aug 2014 21:30:31 +0100
Subject: Update ruby-fr.html.markdown
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

@@species n'existe pas, remplacé @@espece
---
 fr-fr/ruby-fr.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/ruby-fr.html.markdown b/fr-fr/ruby-fr.html.markdown
index 3060bd75..75c8d0d3 100644
--- a/fr-fr/ruby-fr.html.markdown
+++ b/fr-fr/ruby-fr.html.markdown
@@ -336,8 +336,8 @@ class Humain
     puts "#{msg}"
   end
 
-  def species
-    @@species
+  def espece
+    @@espece
   end
 
 end
-- 
cgit v1.2.3


From ddd4db06cabe4371b5cf6802b70995ac3b4a4db6 Mon Sep 17 00:00:00 2001
From: Nicolas Brugneaux <nicolas.brugneaux@gmail.com>
Date: Wed, 20 Aug 2014 02:01:40 +0200
Subject: Added French translation for Javascript

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

(limited to 'fr-fr')

diff --git a/fr-fr/javascript-fr.html.markdown b/fr-fr/javascript-fr.html.markdown
new file mode 100644
index 00000000..598fb6af
--- /dev/null
+++ b/fr-fr/javascript-fr.html.markdown
@@ -0,0 +1,508 @@
+---
+language: javascript
+contributors:
+    - ['Adam Brenecki', 'http://adam.brenecki.id.au']
+    - ['Ariel Krakowski', 'http://www.learneroo.com']
+filename: javascript-fr.js
+translators:
+    - ['@nbrugneaux', 'https://nicolasbrugneaux.me']
+lang: fr-fr
+---
+
+JavaScript a été crée 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 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, 
+peut être utilisé directement côté serveur pour exécuter des programmes écrits
+en JavaScript.
+
+```js
+// Les commentaires sont comme en C. Les commentaires en ligne commencent par 2 slashs,
+/* et les commentaires sur plusieurs lignes commencent avec slash-étoile
+   et finissent avec étoile-slash */
+
+// Toutes les expressions peuvent finir par ;
+doStuff();
+
+// ... 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()
+
+// Parce que ces cas peuvent produire des effets inattendus, nous utiliserons
+// des point-virgules dans ce guide.
+
+///////////////////////////////////
+// 1. Nombres, Chaines de caractères et Opérateurs
+
+// JavaScript a un seul type de nombre (qui est un 64-bit IEEE 754 double (décimaux))
+// Comme avec le Lua, ne paniquez pas à cause du manque d'int (entiers): les
+// doubles ont un mantisse de 52 bits, ce qui est assez pour stocker des int jusqu'à
+// 9 x 10¹⁵ exactement.
+3; // = 3
+1.5; // = 1.5
+
+// L'arithmétique de base fonctionne comme vous vous y attendriez
+1 + 1; // = 2
+8 - 1; // = 7
+10 * 2; // = 20
+35 / 5; // = 7
+
+// Ainsi que les divisions non-entières
+5 / 2; // = 2.5
+
+// Les opérations bits à bits fonctionnent aussi, quand vous effectuez une opération
+// bits à bits , votre nombre décimal est converti en entier *jusqu'à* 32 bits.
+1 << 2; // = 4
+
+// Comme en mathématiques, la priorité est donnée aux parenthèses.
+(1 + 3) * 2; // = 8
+
+// Il existe 3 valeurs spéciales pour les nombres:
+Infinity; // le résultat de 1/0 par exemple
+-Infinity; // le résultat de -1/0 par exemple
+NaN; // le résultat de 0/0 par exemple
+
+// Il existe également le type booléen.
+true; // vrai
+false; // faux
+
+// Les chaines de caractères (strings) sont crées avec ' ou ' indifféremment, la seule
+// raison de choisir l'un ou l'autre est la consistance dans votre code.
+'abc';
+'Hello, world';
+
+// La négation utilise le symbole !
+!true; // = false
+!false; // = true
+
+// L'égalité est === ou ==
+// === compare la valeur exacte 2 === '2' // = false
+// == convertit la valeur pour comparer 2 === '2' // = true
+// En général, il vaut mieux utiliser === pour ne pas faire d'erreurs.
+1 === 1; // = true
+2 === 1; // = false
+
+// L'inégalité est !== ou !=, basé sur le même principe qu'avant.
+1 !== 1; // = false
+2 !== 1; // = true
+
+// Plus de comparaisons:
+1 < 10; // = true
+1 > 10; // = false
+2 <= 2; // = true
+2 >= 2; // = true
+
+// Les strings se concatènent avec +
+'Hello ' + 'world!'; // = 'Hello world!'
+
+// et peuvent être comparées avec < et >
+'a' < 'b'; // = true
+
+// Vous pouvez accéder les caractères dans une string avec charAt
+'This is a string'.charAt(0);  // = 'T'
+
+// .. ou utiliser substring pour avoir un plus gros morceau
+'Hello world'.substring(0, 5); // = 'Hello'
+
+// la longueur, length, est une propriété, donc n'utilisez pas de ()
+'Hello'.length; // = 5
+
+// Il y a également null et undefined
+null; // utilisé pour une non-valeur
+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')
+
+
+///////////////////////////////////
+// 2. Variables, Tableaux et Objets
+
+// 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 sera crée dans l’environnement global, et non l’environnement
+// local dans lequel vous l'avez défini.
+
+// Les variables déclarées et non assignées sont undefined par défaut
+var someThirdVar;
+var someThirdVar = undefined;
+
+// ... sont deux déclarations identiques.
+
+// 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;
+someVar++;    // = someVar += 1;
+someVar--;  // = someVar -= 1;
+
+// Les tableaux (Arrays) sont des listes ordonnées de valeurs, de tous types.
+var myArray = ['Hello', 45, true];
+
+// Leurs membres peuvent être accédés en utilisant les crochets
+// Les indices commencent à 0.
+myArray[1]; // = 45
+
+// Les tableaux sont modifiables, ainsi que leurs longueurs
+myArray.push( 'World' );
+myArray.length; // = 4
+
+// Ajout/Modification à un index spécifique
+myArray[3] = 'Hello';
+
+// 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'};
+
+// Les clés sont des strings, mais les ' ou " sont optionels si elles sont des
+// noms valides en JavaScript. Les valeurs peuvent être de n'importe quel type.
+var myObj = {myKey: 'myValue', 'my other key': 4};
+
+// Les attributs d'objets peuvent être accédés avec les crochets
+myObj['my other key']; // = 4
+
+// .. ou avec un point si la clé est un identifiant valide.
+myObj.myKey; // = 'myValue'
+
+// 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
+
+///////////////////////////////////
+// 3. Logique et structures de contrôle
+
+// La syntaxe de cette section est identique au Java.
+
+// Les si (if) fonctionnent comme vous vous y attendez.
+var count = 1;
+if (count === 3) {
+  // seulement quand count est 3
+}
+else if (count === 4) {
+  // uniquement quand count est 4
+}
+else {
+  // le reste du temps, si ni 3, ni 4. 
+}
+
+// De même pour while.
+while (true) {
+  // Une boucle infinie !
+}
+
+// Les boucles do-while sont pareilles, mais sont exécutées au moins une fois.
+var input
+do {
+  input = getInput();
+} while (!isValid(input))
+
+// La boucle for est la même qu'en C ou en Java:
+// initialisation; condition pour continuer; itération
+for (var i = 0; i < 5; i++){
+    // sera exécutée 5 fois
+}
+
+// && est le "et" logique, || est le "ou" logique
+if (house.size === 'big' && house.colour === 'blue'){
+    house.contains = 'bear';
+}
+if (colour === 'red' || colour === 'blue'){
+    // colour est soit 'red' soit 'blue'
+}
+
+// Les raccourcis && et || sont pratiques pour instancier des valeurs par defaut.
+var name = otherName || 'default';
+
+// Ceci est l'équivalent de
+var name = otherName;
+if (!name){
+  name = 'default';
+}
+
+// Le switch vérifie les égalités avec ===
+// utilisez un "break" à la fin de chaque cas
+// ou les cas suivants seront eux aussi exécutés
+grade = 'B';
+switch (grade) {
+  case 'A':
+    console.log('Great job');
+    break;
+  case 'B':
+    console.log('OK job');
+    break;
+  case 'C':
+    console.log('You can do better');
+    break;
+  default:
+    console.log('Oy vey');
+    break;
+}
+
+
+///////////////////////////////////
+// 4. Fonctions, Scope (Environnement) et Closures
+
+// Les fonctions sont déclarées avec le mot clé function
+function myFunction(thing){
+    return thing.toUpperCase();
+}
+myFunction('foo'); // = 'FOO'
+
+// 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(){
+    // ce code s'exécutera dans 5 secondes
+}
+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 
+// anonymes
+setTimeout(function(){
+    // ce code s'exécutera dans 5 secondes
+}, 5000);
+
+// Le Javascript crée uniquement un scope dans les fonctions, pas dans les 
+// autres blocs.
+if (true){
+    var i = 5;
+}
+i; // = 5 - et non undefined comme vous pourriez vous y attendre
+
+// Cela a mené à un style comment de fonctions anonymes immédiatement exécutée;
+// ou "immediately-executing anonymous functions"
+(function(){
+    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.
+    window.permanent = 10;
+})();
+// Cela permet de ne pas avoir de fuites de variables qui polluent
+// l’environnement global.
+temporary; // raises ReferenceError
+permanent; // = 10
+
+// Une des particularité 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){
+    var prompt = 'Hello, ' + name + '!';
+    // Fonction interne
+    function inner(){
+        alert(prompt);
+    }
+    setTimeout(inner, 5000);
+    // setTimeout is asynchrone, donc la fonction sayHelloInFiveSeconds quittera
+    // immédiatement, et setTimeout appelera inner après.
+}
+sayHelloInFiveSeconds('Adam'); // ouvre un popup avec 'Hello, Adam!' dans 5sec
+
+///////////////////////////////////
+// 5. Encore plus à propos des Objets; Constructeurs and Prototypes
+
+// Les objets peuvent contenir des fonctions.
+var myObj = {
+    myFunc: function(){
+        return 'Hello world!';
+    }
+};
+myObj.myFunc(); // = 'Hello world!'
+
+// Lorsqu'une fonction attachée à un objet est appelée, elle peut accéder à
+// l'objet avec le mot clé this.
+myObj = {
+    myString: 'Hello world!',
+    myFunc: function(){
+        return this.myString;
+    }
+};
+myObj.myFunc(); // = 'Hello world!'
+
+// 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;
+myFunc(); // = undefined
+
+// A l'inverse, une fonction peut être attachée à un objet et y gagner l'accès
+// au travers de "this"
+var myOtherFunc = function(){
+    return this.myString.toUpperCase();
+}
+
+myObj.myOtherFunc = myOtherFunc;
+myObj.myOtherFunc(); // = 'HELLO WORLD!'
+
+// Nous pouvons aussi spécifier un contexte pour une fonction quand elle est 
+// appelée grâce à "call" ou "apply".
+var anotherFunc = function(s){
+    return this.myString + s;
+}
+anotherFunc.call(myObj, ' And Hello Moon!'); // = 'Hello World! And Hello Moon!'
+
+// 'apply' est presque identique, mais prend un tableau comme liste d’arguments.
+
+anotherFunc.apply(myObj, [' And Hello Sun!']); // = 'Hello World! And Hello Sun!'
+
+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" sont temporaires. Pour lier le contexte de façon
+// permanente, nous pouvons utiliser "bind"
+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 
+// 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 
+// crée et mis à disposition de la fonction via "this". Ces fonctions sont
+// communément appelées constructeurs.
+var MyConstructor = function(){
+    this.myNumber = 5;
+}
+myNewObj = new MyConstructor(); // = {myNumber: 5}
+myNewObj.myNumber; // = 5
+
+// Chaque objet en Javascript a un "prototype". Quand vous essayez d'accéder à
+// une propriété que n'a pas l'objet, l'interpréteur regarder son prototype.
+
+// Quelque 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 les navigateurs actuels.
+var myObj = {
+    myString: 'Hello world!'
+};
+var myPrototype = {
+    meaningOfLife: 42,
+    myFunc: function(){
+        return this.myString.toLowerCase()
+    }
+};
+
+myObj.__proto__ = myPrototype;
+myObj.meaningOfLife; // = 42
+myObj.myFunc(); // = 'hello world!'
+
+myPrototype.__proto__ = {
+    myBoolean: true
+};
+myObj.myBoolean; // = true
+
+// Il n'y a pas de copie ici. Chacun des objets stocke une référence à son
+// prototype. Cela veut dire que l'on peut le modifier et cela se répercutera
+// partout.
+myPrototype.meaningOfLife = 43;
+myObj.meaningOfLife; // = 43
+
+// Comme précédemment dit, __proto__ n'est pas standard et ne devrait pas être
+// utilisé. Il y a deux autres moyen de créer un nouvel objet avec un prototype
+// donné.
+
+// Le premier est Object.create, mais c'est assez récent et risque de ne pas
+// fonctionner dans tous les navigateurs.
+var myObj = Object.create(myPrototype);
+myObj.meaningOfLife; // = 43
+
+// Le deuxième moyen, qui marche partout, fonctionne avec les constructeurs.
+// Les constructeurs ont un propriété appelée prototype. Ce n'est *pas* le
+// prototype du constructeur de la fonction elle-même, c'est le prototype que
+// les nouveaux objets crées grâce à ce constructeur avec "new" auront.
+MyConstructor.prototype = {
+    myNumber: 5,
+    getMyNumber: function(){
+        return this.myNumber;
+    }
+};
+var myNewObj2 = new MyConstructor();
+myNewObj2.getMyNumber(); // = 5
+myNewObj2.myNumber = 6
+myNewObj2.getMyNumber(); // = 6
+
+// Les types pré-définis tels que les strings ou nombres ont aussi des
+// constructeurs
+var myNumber = 12;
+var myNumberObj = new Number(12);
+myNumber == myNumberObj; // = true
+
+// ... mais ils ne sont pas exactement équivalent.
+typeof myNumber; // = 'number'
+typeof myNumberObj; // = 'object'
+myNumber === myNumberObj; // = false
+if (0){
+    // 0 est falsy, le code ne fonctionnera pas.
+}
+if (Number(0)){
+    // Parce que Number(0) est truthy, le code fonctionnera
+}
+
+// Cependant, vous pouvez ajouter des fonctionnalités aux types de bases grâce à
+// cette particularité.
+String.prototype.firstCharacter = function(){
+    return this.charAt(0);
+}
+'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 
+// les vieux navigateurs.
+
+//Par exemple, Object.create est assez récent, mais peut être implémenté grâce à
+// ce polyfill
+if (Object.create === undefined){ // don't overwrite it if it exists
+    Object.create = function(proto){
+        // make a temporary constructor with the right prototype
+        var Constructor = function(){};
+        Constructor.prototype = proto;
+        // then use it to create a new, appropriately-prototyped object
+        return new Constructor();
+    }
+}
+
+## 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 
+é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 
+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. 
+
+[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. 
+
+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 1d4e0929ff82d7205b09da2f30b37541464dc029 Mon Sep 17 00:00:00 2001
From: Nicolas Brugneaux <nicolas.brugneaux@gmail.com>
Date: Wed, 20 Aug 2014 02:03:01 +0200
Subject: Update javascript-fr.html.markdown

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

(limited to 'fr-fr')

diff --git a/fr-fr/javascript-fr.html.markdown b/fr-fr/javascript-fr.html.markdown
index 598fb6af..1dc4f8db 100644
--- a/fr-fr/javascript-fr.html.markdown
+++ b/fr-fr/javascript-fr.html.markdown
@@ -479,6 +479,7 @@ if (Object.create === undefined){ // don't overwrite it if it exists
         return new Constructor();
     }
 }
+```
 
 ## Pour aller plus loin (en anglais)
 
-- 
cgit v1.2.3


From 12292eab583ce66a5ec7a2d60ff0f88a0aa2636b Mon Sep 17 00:00:00 2001
From: Pierre-Arnaud Baciocchini <pb@centic.dk>
Date: Wed, 20 Aug 2014 07:45:07 +0200
Subject: [css/fr-fr] Added french translation of CSS

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

(limited to 'fr-fr')

diff --git a/fr-fr/css-fr.html.markdown b/fr-fr/css-fr.html.markdown
new file mode 100644
index 00000000..df45cf8e
--- /dev/null
+++ b/fr-fr/css-fr.html.markdown
@@ -0,0 +1,223 @@
+---
+language: css
+contributors:
+    - ["Mohammad Valipour", "https://github.com/mvalipour"]
+    - ["Marco Scannadinari", "https://github.com/marcoms"]
+translators:
+		- ["@prrrnd", "https://github.com/prrrnd"]
+lang: fr-fr
+---
+
+Au début du web, il n'y avait pas d'élements visuels, simplement du texte pure. Mais avec le developemnt 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.
+
+En résumé, CSS fournit une syntaxe qui vous permet de cibler des élements présents   
+sur un page HTML afin de leurs 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.
+
+**NOTE:** Parce que le résultat du code CSS est un effet visuel, vous pouvez utiliser [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.
+
+
+```css
+/* Les commentaires sont entourés par slash-étoile, comme cette ligne! */
+
+/* ####################
+   ## SELECTEURS
+   ####################*/
+
+/* 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
+
+Vous pouvez cibler tous les éléments d'une page! */
+* { color:red; }
+
+/*
+Voici un élément dans notre HTML:
+
+<div class='une-classe classe2' id='unId' attr='valeur' />
+*/
+
+/* Vous pouvez le cibler par une classe */
+.une-classe { }
+
+/* ou les deux */
+.une-classe.classe2 { }
+
+/* ou par son type */
+div { }
+
+/* ou son id */
+#unId { }
+
+/* ou par le fait qu'il a un attribut */
+[attr] { font-size:smaller; }
+
+/* ou que l'attribut a une valeur spécifique */
+[attr='valeur'] { font-size:smaller; }
+
+/* commence avec une valeur */
+[attr^='val'] { font-size:smaller; }
+
+/* termine avec une valeur */
+[attr$='eur'] { font-size:smaller; }
+
+/* contient une valeur */
+[attr~='leu'] { font-size:smaller; }
+
+
+/* Ce qu'il faut bien comprendre, c'est que vous pouvez combiner ceci -- Il ne doit pas y avoir
+d'espaces entre.*/
+div.une-classe[attr$='eu'] { }
+
+/* Vous pouvez aussi cibler un élément par son parent.*/
+
+/* Un élément qui est en enfant direct */
+div.un-parent > .enfant {}
+
+/* Cela cible aussi les .enfants plus profond dans la structure HTML */
+div.un-parent .enfants {}
+
+/* Attention: le même sélécteur sans espace a un autre sens. */
+div.un-parent.classe {}
+
+/* Vous pouvez cibler un élément basé sur un enfant de même parent */
+.je-suis-avant + .cet-element { }
+
+/* ou n'importe quel enfant de même parent avec celui ci */
+.je-suis-tout-avant ~ .cet-element {}
+
+/* Il y a des pseudo-classes qui permettent de cibler un élément 
+basé sur le comportement, plus que la structure de la page */
+
+/* élément avec le curseur au-dessus */
+:hover {}
+
+/* lien visité */
+:visited {}
+
+/* lien non visité */
+:link {}
+
+/* élément avec le focus */
+:focus {}
+
+
+/* ####################
+   ## PROPRIETES
+   ####################*/
+
+selecteur {
+    
+    /* Units */
+    width: 50%; /* pourcentage */
+    font-size: 2em; /* times current font-size */
+    width: 200px; /* pixels */
+    font-size: 20pt; /* points */
+    width: 5cm; /* centimetres */
+    width: 50mm; /* millimetres */
+    width: 5in; /* pouces */
+    
+    /* Couleurs */
+    background-color: #F6E;  /* court hex */
+    background-color: #F262E2; /* long hex */
+    background-color: tomato; /* couleur nommée */
+    background-color: rgb(255, 255, 255); /* rouge, vert, bleu */
+    background-color: rgb(10%, 20%, 50%); /* rouge, vert, bleu en pourcent */
+    background-color: rgba(255, 0, 0, 0.3); /* rouge, vert, bleu avec transparence */
+    
+    /* Images */
+    background-image: url(/chemin-vers-image/image.jpg);
+    
+    /* Polices */
+    font-family: Arial;
+    font-family: "Courier New"; /* Si espace, entre guillemets */
+    font-family: "Courier New", Trebuchet, Arial; /* Si la première n'est pas trouvée, deuxième, etc... */
+}
+
+```
+
+## Utilisation
+
+Le CSS s'écrit dans des fichiers `.css`.
+
+```xml
+<!-- Vous devez inclure le CSS dans la balise <head>: -->
+<link rel='stylesheet' type='text/css' href='chemin/style.css' />
+
+<!-- Vous pouvez inclure du CSS dans le HTML directement, mais ce n'est vraiment pas recommandé. -->
+<style>
+   selecteur { propriete:valeur; }
+</style>
+
+<!-- ou directement sur l'élément HTML. 
+PS: À ne pas faire. -->
+<div style='propriete:valeur;'>
+</div>
+
+```
+
+## Priorités
+
+Comme on vient de le voir, un élément peut être ciblé par plus qu'un seul sélécteur
+et une même propriété peut être définie plusieurs fois.
+Dans ces cas, une des propriétés devient prioritaire.
+
+Voici du code CSS:
+
+```css
+/*A*/
+p.classe1[attr='valeur']
+
+/*B*/
+p.classe1 {}
+
+/*C*/
+p.classe2 {}
+
+/*D*/
+p {}
+
+/*E*/
+p { propriete: valeur !important; }
+
+```
+
+et le code HTML:
+
+```xml
+<p style='/*F*/ propriete:valeur;' class='classe1 classe2' attr='valeur'>
+</p>
+```
+
+Les priorités de style sont:
+Attention, les priorités s'appliquent aux **propriétés**, pas aux blocs entiers.
+
+* `E` a la priorité grâce à `!important`.  
+* `F` vient ensuite, car le code se trouve directement dans le HTML.
+* `A` vient ensuite, car il est le plus spécifique.  
+	plus spécifique veut dire, celui qui cible le plus l'élément
+* `C` vient ensuite. Il est aussi spécifique que `B`, mais est écrit après.
+* Puis `B`
+* Et enfin `D`.
+
+## Compatibilité
+
+La plupart des fonctionnalités de CSS2 (et de plus en plus CSS3) sont compatibles 
+avec tous les navigateurs. Mais c'est important de vérifier la compatibilité.
+
+[QuirksMode CSS](http://www.quirksmode.org/css/) est une très bonne source pour cela.
+
+## En savoir plus (en anglais)
+
+* [Understanding Style Precedence in CSS: Specificity, Inheritance, and the Cascade](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/)
+* [QuirksMode CSS](http://www.quirksmode.org/css/)
+* [Z-Index - The stacking context](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Understanding_z_index/The_stacking_context)
+
-- 
cgit v1.2.3


From d46303a1239abe4430c3e0753c943f723545c49e Mon Sep 17 00:00:00 2001
From: Pierre-Arnaud Baciocchini <pb@centic.dk>
Date: Wed, 20 Aug 2014 07:47:06 +0200
Subject: Fixed indentation

---
 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 df45cf8e..17f1eab4 100644
--- a/fr-fr/css-fr.html.markdown
+++ b/fr-fr/css-fr.html.markdown
@@ -4,7 +4,7 @@ contributors:
     - ["Mohammad Valipour", "https://github.com/mvalipour"]
     - ["Marco Scannadinari", "https://github.com/marcoms"]
 translators:
-		- ["@prrrnd", "https://github.com/prrrnd"]
+    - ["@prrrnd", "https://github.com/prrrnd"]
 lang: fr-fr
 ---
 
-- 
cgit v1.2.3


From 8df21274b997b2c8f6913fd4694f141c2f5d68cc Mon Sep 17 00:00:00 2001
From: Pierre-Arnaud Baciocchini <pb@centic.dk>
Date: Wed, 20 Aug 2014 07:49:13 +0200
Subject: Removed Swift fr

---
 fr-fr/swift-fr.html.markdown | 225 -------------------------------------------
 1 file changed, 225 deletions(-)
 delete mode 100644 fr-fr/swift-fr.html.markdown

(limited to 'fr-fr')

diff --git a/fr-fr/swift-fr.html.markdown b/fr-fr/swift-fr.html.markdown
deleted file mode 100644
index 18628524..00000000
--- a/fr-fr/swift-fr.html.markdown
+++ /dev/null
@@ -1,225 +0,0 @@
----
-language: swift
-contributors:
-  - ["Grant Timmerman", "http://github.com/grant"]
-translators:
-  - ["@prrrnd", "https://github.com/prrrnd"]
-lang: fr-fr
----
-
-Swift est un langage de programmation crée par Apple pour iOS et OS X. Swift a été introduit en 2014 à la conférence WWDC d'Apple. Il est construit avec le compilateur LLVM inclus dans la version bétâ de Xcode 6.
-
-Pour plus d'informations, en anglais, regardez le [guide d'Apple](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/LandingPage/index.html), qui inclus un tutoriel complet sur Swift.
-
-```js
-//
-// Bases
-//
-
-println("Hello, world")
-var myVariable = 42
-let myConstant = 3.1415926
-let explicitDouble: Double = 70
-let label = "du texte " + String(myVariable)      // Cast
-let piText = "Pi = \(myConstant)"                 // Interpolation
-var optionalString: String? = "optional"          // Peut être nil
-optionalString = nil
-
-
-//
-// Tableaux et dictionnaires
-//
-
-// Tableau
-var shoppingList = ["poisson", "eau", "citrons"]
-shoppingList[1] = "bouteille d'eau"
-let tableauVide = [String]()
-
-// Dictionnaire
-var occupations = [
-  "Malcolm": "Capitaine",
-  "kaylee": "Mécanicien"
-]
-occupations["Jayne"] = "Secretaire"
-let dicoVide = Dictionary<String, Float>()
-
-
-//
-// Contrôle et boucles
-//
-
-// Boucle for (tableau)
-let monTableau = [1, 1, 2, 3, 5]
-for value in monTableau {
-  if value == 1 {
-    println("Un!")
-  } else {
-    println("Pas un!")
-  }
-}
-
-// Boucle for (dictionnaire)
-for (key, value) in dict {
-  println("\(key): \(value)")
-}
-
-// Boucle for (interval)
-for i in -1...1 { // [-1, 0, 1]
-  println(i)
-}
-// utilisez ..< pour exclure le dernier élement
-
-// Boucle while
-var i = 1
-while i < 1000 {
-  i *= 2
-}
-
-// Boucle do-while
-do {
-  println("bonjour")
-} while 1 == 2
-
-// Switch
-let legume = "haricot"
-switch legume {
-case "haricot":
-  // ...
-case "concombre", "patate":
-  // ...
-default: // requis afin de couvrir toutes les possibilités
-  // ...
-}
-
-
-//
-// Fonctions
-//
-
-// Les fonctions sont de type primitif, ce qui veut dire qu'elles peuvent être incluses dans d'autres fonctions
-
-// Fonction
-func direBonjour(name: String, day: String) -> String {
-  return "Bonjour \(name), on est \(day) aujourd'hui."
-}
-direBonjour("Bob", "mardi")
-
-// Fonction qui retourne plusieurs valeurs dans un tuple
-func getPrix() -> (Double, Double, Double) {
-  return (3.59, 3.69, 3.79)
-}
-
-// Arguments
-func setup(nombres: Int...) {}
-
-// Passer et retourner des fonctions
-func augmenter() -> (Int -> Int) {
-  func ajouterUn(nombre: Int) -> Int {
-    return 1 + nombre
-  }
-  return ajouterUn
-}
-var increment = augmenter()
-increment(7)
-
-
-//
-// Closures
-//
-var nombres = [1, 2, 6]
-
-// Les fonctions sont des cas de closures spéciales ({})
-
-// Exemple de closure.
-// `->` sépare les arguments et le type de retour
-// `in` sépare l'en-tête de closure de son corps
-nombres.map({
-  (nombre: Int) -> Int in
-  let resultat = 3 * nombre
-  return resultat
-  })
-
-// Lorsque le type est connu, comme ci-dessus, on peut faire ceci
-nombres = nombres.map({ nombre in 3 * nombre })
-//Ou cela
-//nombres = nombres.map({ $0 * 3 })
-
-print(nombres) // [3, 6, 18]
-
-
-//
-// Classes
-//
-
-// Toutes les méthodes et propriétés d'une classe sont publiques.
-// Si vous avez juste besoin de stocker des données dans un
-// objet structuré, vous devez utiliser une structure
-
-// Une classe `Square` hérite d'une classe `Shape`
-class Rect: Shape {
-  var longueurCote: Int = 1
-
-  // Custom getter and setter property
-  var perimeter: Int {
-    get {
-      return 4 * longueurCote
-    }
-    set {
-      longueurCote = newValue / 4
-    }
-  }
-
-  init(longueurCote: Int) {
-    super.init()
-    self.longueurCote = longueurCote
-  }
-
-  func shrink() {
-    if longueurCote > 0 {
-      --longueurCote
-    }
-  }
-
-  override func getArea() -> Int {
-    return longueurCote * longueurCote
-  }
-}
-var monCarre = new Square(longueurCote: 5)
-print(monCarre.getArea()) // 25
-monCarre.shrink()
-print(monCarre.longueurCote) // 4
-
-// If you don't need a custom getter and setter,
-// but still want to run code before and after getting or setting
-// a property, you can use `willSet` and `didSet`
-
-
-//
-// Enumerations
-//
-
-// Les énumerations peuvent être d'un type spécifique ou non.
-// Elles peuvent contenir méthodes et classes
-
-enum Suit {
-  case Pic, Coeur, Carre, Trefle
-  func getIcon() -> String {
-    switch self {
-    case .Pic: return "♤"
-    case .Coeur: return "♡"
-    case .Carre: return "♢"
-    case .Trefle: return "♧"
-    }
-  }
-}
-
-
-//
-// Autres
-//
-
-// `protocol`: Similaire aux interfaces en Java
-// `extension`s: Permet d'ajouter des fonctionnalités à un type existant
-// Generics: Similaire à Java. Utilisez le mot clé `where` pour specifier les pré-requis du generic
-
-```
-- 
cgit v1.2.3


From 1421ef08f5aa7de56a413753d9017693d3b44187 Mon Sep 17 00:00:00 2001
From: Nicolas Brugneaux <nicolas.brugneaux@gmail.com>
Date: Wed, 20 Aug 2014 10:12:21 +0200
Subject: Updated the part that I forgot to translate.

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

(limited to 'fr-fr')

diff --git a/fr-fr/javascript-fr.html.markdown b/fr-fr/javascript-fr.html.markdown
index 1dc4f8db..55f7858c 100644
--- a/fr-fr/javascript-fr.html.markdown
+++ b/fr-fr/javascript-fr.html.markdown
@@ -37,6 +37,7 @@ doStuff()
 // Parce que ces cas peuvent produire des effets inattendus, nous utiliserons
 // des point-virgules dans ce guide.
 
+
 ///////////////////////////////////
 // 1. Nombres, Chaines de caractères et Opérateurs
 
@@ -182,6 +183,7 @@ myObj.myThirdKey = true;
 // Si vous essayez d'accéder à une valeur non-définie, vous obtiendrez undefined
 myObj.myFourthKey; // = undefined
 
+
 ///////////////////////////////////
 // 3. Logique et structures de contrôle
 
@@ -314,6 +316,7 @@ function sayHelloInFiveSeconds(name){
 }
 sayHelloInFiveSeconds('Adam'); // ouvre un popup avec 'Hello, Adam!' dans 5sec
 
+
 ///////////////////////////////////
 // 5. Encore plus à propos des Objets; Constructeurs and Prototypes
 
@@ -470,12 +473,12 @@ String.prototype.firstCharacter = function(){
 
 //Par exemple, Object.create est assez récent, mais peut être implémenté grâce à
 // ce polyfill
-if (Object.create === undefined){ // don't overwrite it if it exists
+if (Object.create === undefined){ // pour ne pas reécrire si la fonction existe déjà
     Object.create = function(proto){
-        // make a temporary constructor with the right prototype
+        // créer un constructeur temporaire avec le bon prototype
         var Constructor = function(){};
         Constructor.prototype = proto;
-        // then use it to create a new, appropriately-prototyped object
+        // puis on utilise "new" pour créer un object avec ce prototype
         return new Constructor();
     }
 }
-- 
cgit v1.2.3


From f6367016949df3576e9cce4b96148da1f867464c Mon Sep 17 00:00:00 2001
From: Nicolas Brugneaux <nicolas.brugneaux@gmail.com>
Date: Wed, 20 Aug 2014 12:10:15 +0200
Subject: =?UTF-8?q?Translatated=20strings=20to=20"chaines=20de=20caract?=
 =?UTF-8?q?=C3=A8res"?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 fr-fr/javascript-fr.html.markdown | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/javascript-fr.html.markdown b/fr-fr/javascript-fr.html.markdown
index 55f7858c..9e69a038 100644
--- a/fr-fr/javascript-fr.html.markdown
+++ b/fr-fr/javascript-fr.html.markdown
@@ -73,9 +73,9 @@ NaN; // le résultat de 0/0 par exemple
 true; // vrai
 false; // faux
 
-// Les chaines de caractères (strings) sont crées avec ' ou ' indifféremment, la seule
+// Les chaines de caractères (strings) sont crées avec " ou ' indifféremment, la seule
 // raison de choisir l'un ou l'autre est la consistance dans votre code.
-'abc';
+"abc";
 'Hello, world';
 
 // La négation utilise le symbole !
@@ -99,10 +99,10 @@ false; // faux
 2 <= 2; // = true
 2 >= 2; // = true
 
-// Les strings se concatènent avec +
+// Les chaines de caractères se concatènent avec +
 'Hello ' + 'world!'; // = 'Hello world!'
 
-// et peuvent être comparées avec < et >
+// et peuvent être comparées alphabétiquement avec < et >
 'a' < 'b'; // = true
 
 // Vous pouvez accéder les caractères dans une string avec charAt
@@ -475,10 +475,10 @@ String.prototype.firstCharacter = function(){
 // ce polyfill
 if (Object.create === undefined){ // pour ne pas reécrire si la fonction existe déjà
     Object.create = function(proto){
-        // créer un constructeur temporaire avec le bon prototype
+        // on crée un constructeur temporaire avec le bon prototype
         var Constructor = function(){};
         Constructor.prototype = proto;
-        // puis on utilise "new" pour créer un object avec ce prototype
+        // puis on utilise "new" pour créer un object avec ce même prototype
         return new Constructor();
     }
 }
-- 
cgit v1.2.3


From 7367cd9ae801bf0b8fdcef0ab57212e23057869b Mon Sep 17 00:00:00 2001
From: Nicolas Brugneaux <nicolas.brugneaux@gmail.com>
Date: Wed, 20 Aug 2014 19:08:18 +0200
Subject: Updated according to the review.

---
 fr-fr/javascript-fr.html.markdown | 64 +++++++++++++++++++++++----------------
 1 file changed, 38 insertions(+), 26 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/javascript-fr.html.markdown b/fr-fr/javascript-fr.html.markdown
index 9e69a038..21c8b5ae 100644
--- a/fr-fr/javascript-fr.html.markdown
+++ b/fr-fr/javascript-fr.html.markdown
@@ -11,10 +11,11 @@ lang: fr-fr
 
 JavaScript a été crée 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 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.
+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 
+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 
@@ -23,7 +24,7 @@ peut être utilisé directement côté serveur pour exécuter des programmes éc
 en JavaScript.
 
 ```js
-// Les commentaires sont comme en C. Les commentaires en ligne commencent par 2 slashs,
+// Les commentaires sont comme en C. Les commentaires mono-ligne commencent par 2 slashs,
 /* et les commentaires sur plusieurs lignes commencent avec slash-étoile
    et finissent avec étoile-slash */
 
@@ -42,7 +43,7 @@ doStuff()
 // 1. Nombres, Chaines de caractères et Opérateurs
 
 // JavaScript a un seul type de nombre (qui est un 64-bit IEEE 754 double (décimaux))
-// Comme avec le Lua, ne paniquez pas à cause du manque d'int (entiers): les
+// Comme avec le Lua, ne paniquez pas à cause du manque d'int (entiers) : les
 // doubles ont un mantisse de 52 bits, ce qui est assez pour stocker des int jusqu'à
 // 9 x 10¹⁵ exactement.
 3; // = 3
@@ -58,7 +59,7 @@ doStuff()
 5 / 2; // = 2.5
 
 // Les opérations bits à bits fonctionnent aussi, quand vous effectuez une opération
-// bits à bits , votre nombre décimal est converti en entier *jusqu'à* 32 bits.
+// bits à bits, votre nombre décimal est converti en entier *jusqu'à* 32 bits.
 1 << 2; // = 4
 
 // Comme en mathématiques, la priorité est donnée aux parenthèses.
@@ -73,8 +74,8 @@ NaN; // le résultat de 0/0 par exemple
 true; // vrai
 false; // faux
 
-// Les chaines de caractères (strings) sont crées avec " ou ' indifféremment, la seule
-// raison de choisir l'un ou l'autre est la consistance dans votre code.
+// Les chaines de caractères (strings) sont créees avec " ou ' indifféremment, la seule
+// raison de choisir l'un ou l'autre est la cohérence dans votre code.
 "abc";
 'Hello, world';
 
@@ -85,7 +86,7 @@ false; // faux
 // L'égalité est === ou ==
 // === compare la valeur exacte 2 === '2' // = false
 // == convertit la valeur pour comparer 2 === '2' // = true
-// En général, il vaut mieux utiliser === pour ne pas faire d'erreurs.
+// En général, il vaut mieux utiliser === pour ne pas faire d'erreur.
 1 === 1; // = true
 2 === 1; // = false
 
@@ -93,7 +94,7 @@ false; // faux
 1 !== 1; // = false
 2 !== 1; // = true
 
-// Plus de comparaisons:
+// Plus de comparaisons :
 1 < 10; // = true
 1 > 10; // = false
 2 <= 2; // = true
@@ -108,7 +109,7 @@ false; // faux
 // Vous pouvez accéder les caractères dans une string avec charAt
 'This is a string'.charAt(0);  // = 'T'
 
-// .. ou utiliser substring pour avoir un plus gros morceau
+// ... ou utiliser substring pour avoir un plus gros morceau
 'Hello world'.substring(0, 5); // = 'Hello'
 
 // la longueur, length, est une propriété, donc n'utilisez pas de ()
@@ -164,7 +165,7 @@ myArray.length; // = 4
 myArray[3] = 'Hello';
 
 // Les objets JavaScript sont appelés 'dictionnaires' ou 'maps' dans certains autres
-// langages: ils sont une liste non-ordonnée de paires clé-valeur.
+// langages : ils sont une liste non-ordonnée de paires clé-valeur.
 var myObj = {key1: 'Hello', key2: 'World'};
 
 // Les clés sont des strings, mais les ' ou " sont optionels si elles sont des
@@ -187,8 +188,6 @@ myObj.myFourthKey; // = undefined
 ///////////////////////////////////
 // 3. Logique et structures de contrôle
 
-// La syntaxe de cette section est identique au Java.
-
 // Les si (if) fonctionnent comme vous vous y attendez.
 var count = 1;
 if (count === 3) {
@@ -287,12 +286,14 @@ if (true){
 }
 i; // = 5 - et non undefined comme vous pourriez vous y attendre
 
-// Cela a mené à un style comment de fonctions anonymes immédiatement exécutée;
+// Cela a mené à un style commun de fonctions anonymes immédiatement exécutée;
 // ou "immediately-executing anonymous functions"
 (function(){
     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.
+    // 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 
+    // vous trouvez. http://nodejs.org/api/globals.html
     window.permanent = 10;
 })();
 // Cela permet de ne pas avoir de fuites de variables qui polluent
@@ -300,7 +301,7 @@ i; // = 5 - et non undefined comme vous pourriez vous y attendre
 temporary; // raises ReferenceError
 permanent; // = 10
 
-// Une des particularité les plus puissantes de Javascript est le système de 
+// 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.
@@ -338,7 +339,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;
@@ -353,8 +354,9 @@ var myOtherFunc = function(){
 myObj.myOtherFunc = myOtherFunc;
 myObj.myOtherFunc(); // = 'HELLO WORLD!'
 
-// Nous pouvons aussi spécifier un contexte pour une fonction quand elle est 
-// appelée grâce à "call" ou "apply".
+// Le contexte correspond à 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;
 }
@@ -368,8 +370,9 @@ 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" sont temporaires. Pour lier le contexte de façon
-// permanente, nous pouvons utiliser "bind"
+// 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!'
 
@@ -389,11 +392,11 @@ myNewObj = new MyConstructor(); // = {myNumber: 5}
 myNewObj.myNumber; // = 5
 
 // Chaque objet en Javascript a un "prototype". Quand vous essayez d'accéder à
-// une propriété que n'a pas l'objet, l'interpréteur regarder son prototype.
+// une propriété que l'objet n'a pas, l'interpréteur va regarder son prototype.
 
-// Quelque implémentations de JS vous laissent accéder au prototype avec la 
+// 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 les navigateurs actuels.
+// et ne fonctionne pas dans certains des navigateurs actuels.
 var myObj = {
     myString: 'Hello world!'
 };
@@ -413,12 +416,21 @@ myPrototype.__proto__ = {
 };
 myObj.myBoolean; // = true
 
+
+// Pour obtenir le prototype il existe également Object.getPrototypeOf
+Object.getPrototypeOf( myObj ) // = {meaningOfLife: 42, myFunc: function}
+
 // Il n'y a pas de copie ici. Chacun des objets stocke une référence à son
 // prototype. Cela veut dire que l'on peut le modifier et cela se répercutera
 // partout.
 myPrototype.meaningOfLife = 43;
 myObj.meaningOfLife; // = 43
 
+// L'inverse n'est cependant pas vrai. Changer la propriété d'un objet ne change
+// pas la chaine prototypale.
+myObj.lonelyProperty = true;
+myPrototype.lonelyProperty; // = undefined
+
 // Comme précédemment dit, __proto__ n'est pas standard et ne devrait pas être
 // utilisé. Il y a deux autres moyen de créer un nouvel objet avec un prototype
 // donné.
-- 
cgit v1.2.3


From 210d9eba8df66ac7298d4bdea386428fe1a1009f Mon Sep 17 00:00:00 2001
From: Nicolas Brugneaux <nicolas.brugneaux@gmail.com>
Date: Wed, 20 Aug 2014 19:13:53 +0200
Subject: better example.

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

(limited to 'fr-fr')

diff --git a/fr-fr/javascript-fr.html.markdown b/fr-fr/javascript-fr.html.markdown
index 21c8b5ae..dd12d89f 100644
--- a/fr-fr/javascript-fr.html.markdown
+++ b/fr-fr/javascript-fr.html.markdown
@@ -428,8 +428,8 @@ myObj.meaningOfLife; // = 43
 
 // L'inverse n'est cependant pas vrai. Changer la propriété d'un objet ne change
 // pas la chaine prototypale.
-myObj.lonelyProperty = true;
-myPrototype.lonelyProperty; // = undefined
+myObj.meaningOfLife = 42;
+myPrototype.meaningOfLife; // = 43
 
 // Comme précédemment dit, __proto__ n'est pas standard et ne devrait pas être
 // utilisé. Il y a deux autres moyen de créer un nouvel objet avec un prototype
-- 
cgit v1.2.3


From ffd5e7e149cf1da87abce5e56cdf32626eede22a Mon Sep 17 00:00:00 2001
From: Nicolas Brugneaux <nicolas.brugneaux@gmail.com>
Date: Wed, 20 Aug 2014 19:39:19 +0200
Subject: Typo

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

(limited to 'fr-fr')

diff --git a/fr-fr/javascript-fr.html.markdown b/fr-fr/javascript-fr.html.markdown
index dd12d89f..e15f70a3 100644
--- a/fr-fr/javascript-fr.html.markdown
+++ b/fr-fr/javascript-fr.html.markdown
@@ -9,7 +9,7 @@ translators:
 lang: fr-fr
 ---
 
-JavaScript a été crée par Brendan Eich, travaillant alors a Netscape, en 1995.
+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 
-- 
cgit v1.2.3


From d15c9674a9005b544427c206424cc900bda48106 Mon Sep 17 00:00:00 2001
From: Nicolas Brugneaux <nicolas.brugneaux@gmail.com>
Date: Wed, 20 Aug 2014 20:57:40 +0200
Subject: Updated scope part.

---
 fr-fr/javascript-fr.html.markdown | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/javascript-fr.html.markdown b/fr-fr/javascript-fr.html.markdown
index e15f70a3..2e18d0be 100644
--- a/fr-fr/javascript-fr.html.markdown
+++ b/fr-fr/javascript-fr.html.markdown
@@ -135,8 +135,9 @@ 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 sera crée dans l’environnement global, et non l’environnement
-// local dans lequel vous l'avez défini.
+// ... 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
 var someThirdVar;
@@ -279,8 +280,8 @@ setTimeout(function(){
     // ce code s'exécutera dans 5 secondes
 }, 5000);
 
-// Le Javascript crée uniquement un scope dans les fonctions, pas dans les 
-// autres blocs.
+// 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;
 }
-- 
cgit v1.2.3


From eab554a7a7f2869ff7dac9f54acce9a7ed55cfa4 Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Mon, 8 Sep 2014 13:08:28 +0200
Subject: Review docs for added rouge lexers and update those with new
 highlighters

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

(limited to 'fr-fr')

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


From 9df9e23aa4f9d36ec4d27528318b173aec3b0b8e Mon Sep 17 00:00:00 2001
From: Pierre-Arnaud Baciocchini <pierre.baciocchini@gmail.com>
Date: Tue, 16 Sep 2014 17:33:10 +0200
Subject: Fixes french translation of CSS

---
 fr-fr/css-fr.html.markdown | 60 ++++++++++++++++++++++------------------------
 1 file changed, 29 insertions(+), 31 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/css-fr.html.markdown b/fr-fr/css-fr.html.markdown
index 17f1eab4..bff922df 100644
--- a/fr-fr/css-fr.html.markdown
+++ b/fr-fr/css-fr.html.markdown
@@ -10,17 +10,16 @@ lang: fr-fr
 
 Au début du web, il n'y avait pas d'élements visuels, simplement du texte pure. Mais avec le developemnt 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   
+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.
 
-En résumé, CSS fournit une syntaxe qui vous permet de cibler des élements présents   
-sur un page HTML afin de leurs donner des propriétés visuelles différentes.
+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   
+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.
 
-**NOTE:** Parce que le résultat du code CSS est un effet visuel, vous pouvez utiliser [dabblet](http://dabblet.com/) afin de 
-voir les résultats, comprendre, et vous familiariser avec le langage.
+**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.
 
 
@@ -28,7 +27,7 @@ Cet article porte principalement sur la syntaxe et quelques astuces.
 /* Les commentaires sont entourés par slash-étoile, comme cette ligne! */
 
 /* ####################
-   ## SELECTEURS
+   ## SÉLECTEURS
    ####################*/
 
 /* Généralement, la première déclaration en CSS est très simple */
@@ -40,7 +39,7 @@ Vous pouvez cibler tous les éléments d'une page! */
 * { color:red; }
 
 /*
-Voici un élément dans notre HTML:
+Voici un élément dans notre HTML :
 
 <div class='une-classe classe2' id='unId' attr='valeur' />
 */
@@ -48,7 +47,7 @@ Voici un élément dans notre HTML:
 /* Vous pouvez le cibler par une classe */
 .une-classe { }
 
-/* ou les deux */
+/* ou par deux */
 .une-classe.classe2 { }
 
 /* ou par son type */
@@ -74,18 +73,18 @@ div { }
 
 
 /* Ce qu'il faut bien comprendre, c'est que vous pouvez combiner ceci -- Il ne doit pas y avoir
-d'espaces entre.*/
+d'espaces entre. */
 div.une-classe[attr$='eu'] { }
 
-/* Vous pouvez aussi cibler un élément par son parent.*/
+/* Vous pouvez aussi cibler un élément par son parent. */
 
 /* Un élément qui est en enfant direct */
 div.un-parent > .enfant {}
 
-/* Cela cible aussi les .enfants plus profond dans la structure HTML */
+/* Cela cible aussi les .enfants plus profonds dans la structure HTML */
 div.un-parent .enfants {}
 
-/* Attention: le même sélécteur sans espace a un autre sens. */
+/* Attention : le même sélecteur sans espace a un autre sens. */
 div.un-parent.classe {}
 
 /* Vous pouvez cibler un élément basé sur un enfant de même parent */
@@ -94,8 +93,8 @@ div.un-parent.classe {}
 /* ou n'importe quel enfant de même parent avec celui ci */
 .je-suis-tout-avant ~ .cet-element {}
 
-/* Il y a des pseudo-classes qui permettent de cibler un élément 
-basé sur le comportement, plus que la structure de la page */
+/* Il y a des pseudo-classes qui permettent de cibler un élément
+basé sur le comportement, en plus de la structure de la page */
 
 /* élément avec le curseur au-dessus */
 :hover {}
@@ -111,20 +110,20 @@ basé sur le comportement, plus que la structure de la page */
 
 
 /* ####################
-   ## PROPRIETES
+   ## PROPRIÉTÉS
    ####################*/
 
 selecteur {
-    
+
     /* Units */
     width: 50%; /* pourcentage */
-    font-size: 2em; /* times current font-size */
+    font-size: 2em; /* taille de la police multipliée par X */
     width: 200px; /* pixels */
     font-size: 20pt; /* points */
     width: 5cm; /* centimetres */
     width: 50mm; /* millimetres */
     width: 5in; /* pouces */
-    
+
     /* Couleurs */
     background-color: #F6E;  /* court hex */
     background-color: #F262E2; /* long hex */
@@ -132,14 +131,14 @@ selecteur {
     background-color: rgb(255, 255, 255); /* rouge, vert, bleu */
     background-color: rgb(10%, 20%, 50%); /* rouge, vert, bleu en pourcent */
     background-color: rgba(255, 0, 0, 0.3); /* rouge, vert, bleu avec transparence */
-    
+
     /* Images */
     background-image: url(/chemin-vers-image/image.jpg);
-    
+
     /* Polices */
     font-family: Arial;
     font-family: "Courier New"; /* Si espace, entre guillemets */
-    font-family: "Courier New", Trebuchet, Arial; /* Si la première n'est pas trouvée, deuxième, etc... */
+    font-family: "Courier New", Trebuchet, Arial; /* Si la première n'est pas trouvée, la deuxième est utilisée, etc... */
 }
 
 ```
@@ -149,7 +148,7 @@ selecteur {
 Le CSS s'écrit dans des fichiers `.css`.
 
 ```xml
-<!-- Vous devez inclure le CSS dans la balise <head>: -->
+<!-- Vous devez inclure le CSS dans la balise <head> : -->
 <link rel='stylesheet' type='text/css' href='chemin/style.css' />
 
 <!-- Vous pouvez inclure du CSS dans le HTML directement, mais ce n'est vraiment pas recommandé. -->
@@ -157,8 +156,8 @@ Le CSS s'écrit dans des fichiers `.css`.
    selecteur { propriete:valeur; }
 </style>
 
-<!-- ou directement sur l'élément HTML. 
-PS: À ne pas faire. -->
+<!-- ou directement sur l'élément HTML.
+PS : à ne pas faire. -->
 <div style='propriete:valeur;'>
 </div>
 
@@ -166,11 +165,11 @@ PS: À ne pas faire. -->
 
 ## Priorités
 
-Comme on vient de le voir, un élément peut être ciblé par plus qu'un seul sélécteur
+Comme on vient de le voir, un élément peut être ciblé par plus qu'un seul sélecteur
 et une même propriété peut être définie plusieurs fois.
 Dans ces cas, une des propriétés devient prioritaire.
 
-Voici du code CSS:
+Voici du code CSS :
 
 ```css
 /*A*/
@@ -197,7 +196,7 @@ et le code HTML:
 </p>
 ```
 
-Les priorités de style sont:
+Les priorités de style sont :
 Attention, les priorités s'appliquent aux **propriétés**, pas aux blocs entiers.
 
 * `E` a la priorité grâce à `!important`.  
@@ -210,8 +209,8 @@ Attention, les priorités s'appliquent aux **propriétés**, pas aux blocs entie
 
 ## Compatibilité
 
-La plupart des fonctionnalités de CSS2 (et de plus en plus CSS3) sont compatibles 
-avec tous les navigateurs. Mais c'est important de vérifier la compatibilité.
+La plupart des fonctionnalités de CSS2 (et de plus en plus CSS3) sont compatibles
+avec tous les navigateurs. Mais il est important de vérifier la compatibilité.
 
 [QuirksMode CSS](http://www.quirksmode.org/css/) est une très bonne source pour cela.
 
@@ -220,4 +219,3 @@ avec tous les navigateurs. Mais c'est important de vérifier la compatibilité.
 * [Understanding Style Precedence in CSS: Specificity, Inheritance, and the Cascade](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/)
 * [QuirksMode CSS](http://www.quirksmode.org/css/)
 * [Z-Index - The stacking context](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Understanding_z_index/The_stacking_context)
-
-- 
cgit v1.2.3


From 79f7d3100f50cc1479c0dab63606a0103470d580 Mon Sep 17 00:00:00 2001
From: Pierre-Arnaud Baciocchini <pierre.baciocchini@gmail.com>
Date: Thu, 18 Sep 2014 16:01:42 +0200
Subject: Fixed typo

---
 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 bff922df..bdab9715 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 developemnt des navigateurs,
+Au début du web, il n'y avait pas d'élements visuels, simplement du texte pure. 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.
-- 
cgit v1.2.3


From 8cf99735a03e4b021dad37f721d0930ad7bc2ecb Mon Sep 17 00:00:00 2001
From: Geoffrey Liu <liug.2012@gmail.com>
Date: Sun, 12 Oct 2014 00:08:04 -0700
Subject: A translation to French for XML

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

(limited to 'fr-fr')

diff --git a/fr-fr/xml-fr.html.markdown b/fr-fr/xml-fr.html.markdown
new file mode 100644
index 00000000..4dd09937
--- /dev/null
+++ b/fr-fr/xml-fr.html.markdown
@@ -0,0 +1,127 @@
+---
+language: xml
+contributors:
+  - ["João Farias", "https://github.com/JoaoGFarias"]
+translators:
+  - ["Geoffrey Liu", "https://github.com/g-liu"]
+filename: learnxml.xml
+---
+
+XML est un langage de balisage conçu pour stocker et transporter les informations.
+
+Contrairement à HTML, XML ne spécifie pas comment afficher ou formater les informations, juste comment le porter.
+
+* La syntaxe XML
+
+```xml
+<!-- Les commentaires en XML ressemblent ceci -->
+
+<?xml version="1.0" encoding="UTF-8"?>
+<librarie>
+  <livre categorie="CUISINE">
+    <titre lang="en">Everyday Italian</titre>
+    <auteur>Giada De Laurentiis</auteur>
+    <an>2005</an>
+    <prix>30.00</prix>
+  </livre>
+  <livre category="ENFANTS">
+    <titre lang="en">Harry Potter</titre>
+    <auteur>J. K. Rowling</auteur>
+    <an>2005</an>
+    <prix>29.99</prix>
+  </livre>
+  <livre category="WEB">
+    <titre lang="en">Learning XML</titre>
+    <auteur>Erik T. Ray</auteur>
+    <an>2003</an>
+    <prix>39.95</prix>
+  </livre>
+</librarie>
+
+<!-- Ce qui précède est un fichier XML typique.
+  Il commence par une déclaration, qui informe certaines métadonées (en option).
+
+XML utilise une structure arborescente. Ci-dessus, le nœud racine est «librairie», qui a 
+   trois nœuds enfants, qui sont appelés «livres». Ces nœuds a plus de nœuds enfants, et ainsi de suite ...
+
+On crée les nœuds avec des balises d'ouverture / fermeture, et les enfants sont les nœuds juste entre 
+   les balises d'ouverture et de fermeture. -->
+
+
+<!-- XML porte deux types d'informations:
+  1 - Les attributs -> les metadonnées sur un nœud.
+      Habituellement, l'analyseur XML utilise cette information pour bien stocker les donnés.
+  2 - Les éléments -> les informations pures.
+      C'est ce que l'analyseur retrouvera du fichier XML.
+      Les éléments apparaissent entre les balises d'ouverture et de fermeture, sans parenthèses. -->
+      
+  
+<!-- Ci-dessous, un élément avec deux attributs -->
+<fichier type="gif" id="4293">ordinateur.gif</fichier>
+
+
+```
+
+* Un document bien-formaté & le validation
+
+Un document XML est bien formaté s'il est syntaxiquement correcte. 
+Cependant, il est possible d'injecter plus de contraintes dans le document, 
+en utilisant les définitions de documents, tels que les schémas DTD et XML.
+
+Un document XML qui suit une définition de document est dit valide, 
+en ce qui concerne ce document.
+
+Avec cet outil, vous pouvez vérifier les données XML en dehors de la logique de l'application.
+
+```xml
+
+<!-- Ci-dessous, vous pouvez voir une version simplifiée du document de librairie, 
+   avec l'addition de définition DTD. -->
+
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE note SYSTEM "Librarie.dtd">
+<librarie>
+  <livre categorie="CUISINE">
+    <titre>Everyday Italian</titre>
+    <prix>30.00</prix>
+  </livre>
+</librarie>
+
+<!-- Cette DTD pourrait être quelque chose comme: -->
+
+<!DOCTYPE note
+[
+<!ELEMENT librarie (livre+)>
+<!ELEMENT livre (titre,prix)>
+<!ATTLIST livre categorie CDATA "Littérature">
+<!ELEMENT titre (#PCDATA)>
+<!ELEMENT prix (#PCDATA)>
+]>
+
+<!-- La DTD commence par une déclaration.
+   Après, le nœud racine est déclaré, qui exige un ou plusieurs nœuds enfants. 
+   Chaque «livre» doit contenir exactement un «titre» et «prix» et un attribut 
+   appelé «catégorie», avec «littérature» comme valeur par défaut. 
+   Les nœuds de «titre» et «prix» contiennent des informations de caractère analysés
+   (anglais: «parsed character data») -->
+
+<!-- La DTD pourrait être déclaré dans le fichier XML lui-même -->
+
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!DOCTYPE note
+[
+<!ELEMENT librarie (livre+)>
+<!ELEMENT livre (titre,prix)>
+<!ATTLIST livre categorie CDATA "Littérature">
+<!ELEMENT titre (#PCDATA)>
+<!ELEMENT prix (#PCDATA)>
+]>
+
+<librarie>
+  <livre categorie="CUISINE">
+    <titre>Everyday Italian</titre>
+    <prix>30.00</prix>
+  </livre>
+</librarie>
+```
-- 
cgit v1.2.3


From 4feb1f380a4e86b36a4ba6b6541ee6137ce1c52f Mon Sep 17 00:00:00 2001
From: Adam Bard <github@adambard.com>
Date: Sun, 12 Oct 2014 12:48:32 +0300
Subject: Update scala.html.markdown

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

(limited to 'fr-fr')

diff --git a/fr-fr/scala.html.markdown b/fr-fr/scala.html.markdown
index da562138..a43edf16 100644
--- a/fr-fr/scala.html.markdown
+++ b/fr-fr/scala.html.markdown
@@ -1,12 +1,11 @@
 ---
 language: Scala
-filename: learnscala.scala
 contributors:
     - ["George Petrov", "http://github.com/petrovg"]
     - ["Dominic Bou-Samra", "http://dbousamra.github.com"]
 translators:
-	- ["Anne-Catherine Dehier", "https://github.com/spellart"]
-filename: learn.scala
+    - ["Anne-Catherine Dehier", "https://github.com/spellart"]
+filename: learnscala-fr.scala
 lang: fr-fr
 ---
 
-- 
cgit v1.2.3


From e2913890cbc9d79d7840cead6157ff8e0f3216f9 Mon Sep 17 00:00:00 2001
From: Geoffrey Liu <liug.2012@gmail.com>
Date: Sun, 12 Oct 2014 13:43:05 -0700
Subject: Corrections

Merci @Oire !
---
 fr-fr/xml-fr.html.markdown | 42 +++++++++++++++++++++---------------------
 1 file changed, 21 insertions(+), 21 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/xml-fr.html.markdown b/fr-fr/xml-fr.html.markdown
index 4dd09937..d7e76892 100644
--- a/fr-fr/xml-fr.html.markdown
+++ b/fr-fr/xml-fr.html.markdown
@@ -9,7 +9,7 @@ filename: learnxml.xml
 
 XML est un langage de balisage conçu pour stocker et transporter les informations.
 
-Contrairement à HTML, XML ne spécifie pas comment afficher ou formater les informations, juste comment le porter.
+Contrairement à HTML, XML ne spécifie pas comment afficher ou formater les informations, juste comment les porter.
 
 * La syntaxe XML
 
@@ -17,40 +17,40 @@ Contrairement à HTML, XML ne spécifie pas comment afficher ou formater les inf
 <!-- Les commentaires en XML ressemblent ceci -->
 
 <?xml version="1.0" encoding="UTF-8"?>
-<librarie>
+<librairie>
   <livre categorie="CUISINE">
     <titre lang="en">Everyday Italian</titre>
     <auteur>Giada De Laurentiis</auteur>
     <an>2005</an>
     <prix>30.00</prix>
   </livre>
-  <livre category="ENFANTS">
+  <livre categorie="ENFANTS">
     <titre lang="en">Harry Potter</titre>
     <auteur>J. K. Rowling</auteur>
     <an>2005</an>
     <prix>29.99</prix>
   </livre>
-  <livre category="WEB">
+  <livre categorie="WEB">
     <titre lang="en">Learning XML</titre>
     <auteur>Erik T. Ray</auteur>
     <an>2003</an>
     <prix>39.95</prix>
   </livre>
-</librarie>
+</librairie>
 
-<!-- Ce qui précède est un fichier XML typique.
-  Il commence par une déclaration, qui informe certaines métadonées (en option).
+<!-- Ce qui suit est un fichier XML typique.
+  Il commence par une déclaration, qui informe certaines métadonnées (en option).
 
 XML utilise une structure arborescente. Ci-dessus, le nœud racine est «librairie», qui a 
-   trois nœuds enfants, qui sont appelés «livres». Ces nœuds a plus de nœuds enfants, et ainsi de suite ...
+   trois nœuds enfants, qui sont appelés «livres». Ces nœuds ont plus de nœuds enfants, et ainsi de suite ...
 
 On crée les nœuds avec des balises d'ouverture / fermeture, et les enfants sont les nœuds juste entre 
    les balises d'ouverture et de fermeture. -->
 
 
 <!-- XML porte deux types d'informations:
-  1 - Les attributs -> les metadonnées sur un nœud.
-      Habituellement, l'analyseur XML utilise cette information pour bien stocker les donnés.
+  1 - Les attributs -> les métadonnées sur un nœud.
+      Habituellement, l'analyseur XML utilise cette information pour bien stocker les données.
   2 - Les éléments -> les informations pures.
       C'est ce que l'analyseur retrouvera du fichier XML.
       Les éléments apparaissent entre les balises d'ouverture et de fermeture, sans parenthèses. -->
@@ -62,9 +62,9 @@ On crée les nœuds avec des balises d'ouverture / fermeture, et les enfants son
 
 ```
 
-* Un document bien-formaté & le validation
+* Un document bien formaté & le validation
 
-Un document XML est bien formaté s'il est syntaxiquement correcte. 
+Un document XML est bien formaté s'il est syntaxiquement correct. 
 Cependant, il est possible d'injecter plus de contraintes dans le document, 
 en utilisant les définitions de documents, tels que les schémas DTD et XML.
 
@@ -79,19 +79,19 @@ Avec cet outil, vous pouvez vérifier les données XML en dehors de la logique d
    avec l'addition de définition DTD. -->
 
 <?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE note SYSTEM "Librarie.dtd">
-<librarie>
+<!DOCTYPE note SYSTEM "Librairie.dtd">
+<librairie>
   <livre categorie="CUISINE">
     <titre>Everyday Italian</titre>
     <prix>30.00</prix>
   </livre>
-</librarie>
+</librairie>
 
 <!-- Cette DTD pourrait être quelque chose comme: -->
 
 <!DOCTYPE note
 [
-<!ELEMENT librarie (livre+)>
+<!ELEMENT librairie (livre+)>
 <!ELEMENT livre (titre,prix)>
 <!ATTLIST livre categorie CDATA "Littérature">
 <!ELEMENT titre (#PCDATA)>
@@ -103,25 +103,25 @@ Avec cet outil, vous pouvez vérifier les données XML en dehors de la logique d
    Chaque «livre» doit contenir exactement un «titre» et «prix» et un attribut 
    appelé «catégorie», avec «littérature» comme valeur par défaut. 
    Les nœuds de «titre» et «prix» contiennent des informations de caractère analysés
-   (anglais: «parsed character data») -->
+   (Anglais: «parsed character data») -->
 
-<!-- La DTD pourrait être déclaré dans le fichier XML lui-même -->
+<!-- La DTD pourrait être déclarée dans le fichier XML lui-même -->
 
 <?xml version="1.0" encoding="UTF-8"?>
 
 <!DOCTYPE note
 [
-<!ELEMENT librarie (livre+)>
+<!ELEMENT librairie (livre+)>
 <!ELEMENT livre (titre,prix)>
 <!ATTLIST livre categorie CDATA "Littérature">
 <!ELEMENT titre (#PCDATA)>
 <!ELEMENT prix (#PCDATA)>
 ]>
 
-<librarie>
+<librairie>
   <livre categorie="CUISINE">
     <titre>Everyday Italian</titre>
     <prix>30.00</prix>
   </livre>
-</librarie>
+</librairie>
 ```
-- 
cgit v1.2.3


From ef6544a8868d3b19a115804b2db3962d91ad7979 Mon Sep 17 00:00:00 2001
From: Geoffrey Liu <liug.2012@gmail.com>
Date: Sun, 12 Oct 2014 14:24:42 -0700
Subject: Capitalize language names for translations.

#137
---
 fr-fr/haskell.html.markdown | 2 +-
 fr-fr/lua-fr.html.markdown  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/haskell.html.markdown b/fr-fr/haskell.html.markdown
index 989db1d5..d9d3151f 100644
--- a/fr-fr/haskell.html.markdown
+++ b/fr-fr/haskell.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: haskell
+language: Haskell
 contributors:
     - ["Adit Bhargava", "http://adit.io"]
 translators:
diff --git a/fr-fr/lua-fr.html.markdown b/fr-fr/lua-fr.html.markdown
index 922d6ebc..b4e2a161 100644
--- a/fr-fr/lua-fr.html.markdown
+++ b/fr-fr/lua-fr.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: lua
+language: Lua
 filename: learnlua-fr.lua
 contributors:
     - ["Tyler Neylon", "http://tylerneylon.com/"]
-- 
cgit v1.2.3


From 8e723a5f456403911b512c92979c9417a972406c Mon Sep 17 00:00:00 2001
From: Levi Bostian <levi.bostian@gmail.com>
Date: Fri, 17 Oct 2014 21:43:23 -0500
Subject: Update language type for XML fr

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

(limited to 'fr-fr')

diff --git a/fr-fr/xml-fr.html.markdown b/fr-fr/xml-fr.html.markdown
index d7e76892..ed5f55ff 100644
--- a/fr-fr/xml-fr.html.markdown
+++ b/fr-fr/xml-fr.html.markdown
@@ -4,7 +4,8 @@ contributors:
   - ["João Farias", "https://github.com/JoaoGFarias"]
 translators:
   - ["Geoffrey Liu", "https://github.com/g-liu"]
-filename: learnxml.xml
+filename: learnxml-fr.xml
+lang: fr-fr
 ---
 
 XML est un langage de balisage conçu pour stocker et transporter les informations.
-- 
cgit v1.2.3


From b4e5719ae90dbba989b1f3f5b9018d436d99e25d Mon Sep 17 00:00:00 2001
From: Andrei Curelaru <andrei@infinidad.fr>
Date: Sat, 25 Oct 2014 01:28:23 +0200
Subject: =?UTF-8?q?D=C3=A9but=20de=20traduction=20Markdown?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

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

(limited to 'fr-fr')

diff --git a/fr-fr/markdown.html.markdown b/fr-fr/markdown.html.markdown
new file mode 100644
index 00000000..32806054
--- /dev/null
+++ b/fr-fr/markdown.html.markdown
@@ -0,0 +1,255 @@
+---
+language: markdown
+contributors:
+    - ["Andrei Curelaru", "http://infinidad.fr/"]
+filename: markdown.md
+---
+
+Markdown a été crée par Jhon Gruber en 2004. Ceci se veut être une syntaxe facile à lire et à écrire, aisément convertible en HTML(et beaucoup d'autres formats aussi à present).
+
+Donnez moi autant de retours que vous voulez! 
+Sentez vous libre de forker et envoyer des pull request!
+
+
+```markdown
+<!-- Markdown is a superset of HTML, so any HTML file is valid Markdown, that
+means we can use HTML elements in Markdown, such as the comment element, and
+they won't be affected by a markdown parser. However, if you create an HTML
+element in your markdown file, you cannot use markdown syntax within that
+element's contents. -->
+
+<!-- Markdown also varies in implementation from one parser to a next. This
+guide will attempt to clarify when features are universal or when they are
+specific to a certain parser. -->
+
+<!-- Headers -->
+<!-- You can create HTML elements <h1> through <h6> easily by prepending the
+text you want to be in that element by a number of hashes (#) -->
+# Ceci est un <h1>
+## Ceci est un <h2>
+### Ceci est un <h3>
+#### Ceci est un <h4>
+##### Ceci est un <h5>
+###### Ceci est un <h6>
+
+<!-- Markdown also provides us with two alternative ways of indicating h1 and h2 -->
+Ceci est un h1
+=============
+
+Ceci est un h2
+-------------
+
+<!-- Simple text styles -->
+<!-- Text can be easily styled as italic or bold using markdown -->
+
+*This text is in italics.*
+_And so is this text._
+
+**This text is in bold.**
+__And so is this text.__
+
+***This text is in both.***
+**_As is this!_**
+*__And this!__*
+
+<!-- In Github Flavored Markdown, which is used to render markdown files on
+Github, we also have strikethrough: -->
+
+~~This text is rendered with strikethrough.~~
+
+<!-- Paragraphs are a one or multiple adjacent lines of text separated by one or
+multiple blank lines. -->
+
+This is a paragraph. I'm typing in a paragraph isn't this fun?
+
+Now I'm in paragraph 2.
+I'm still in paragraph 2 too!
+
+
+I'm in paragraph three!
+
+<!-- Should you ever want to insert an HTML <br /> tag, you can end a paragraph
+with two or more spaces and then begin a new paragraph. -->
+
+I end with two spaces (highlight me to see them).  
+
+There's a <br /> above me!
+
+<!-- Block quotes are easy and done with the > character. -->
+
+> This is a block quote. You can either
+> manually wrap your lines and put a `>` before every line or you can let your lines get really long and wrap on their own.
+> It doesn't make a difference so long as they start with a `>`.
+
+> You can also use more than one level
+>> of indentation?
+> How neat is that?
+
+<!-- Lists -->
+<!-- Unordered lists can be made using asterisks, pluses, or hyphens -->
+
+* Item
+* Item
+* Another item
+
+or
+
++ Item
++ Item
++ One more item
+
+or 
+
+- Item
+- Item
+- One last item
+
+<!-- Ordered lists are done with a number followed by a period -->
+
+1. Item one
+2. Item two
+3. Item three
+
+<!-- You don't even have to label the items correctly and markdown will still
+render the numbers in order, but this may not be a good idea -->
+
+1. Item one
+1. Item two
+1. Item three
+<!-- (This renders the same as the above example) -->
+
+<!-- You can also use sublists -->
+
+1. Item one
+2. Item two
+3. Item three
+    * Sub-item
+    * Sub-item
+4. Item four
+
+<!-- There are even task lists. This creates HTML checkboxes. -->
+
+Boxes below without the 'x' are unchecked HTML checkboxes.
+- [ ] First task to complete. 
+- [ ] Second task that needs done
+This checkbox below will be a checked HTML checkbox.
+- [x] This task has been completed
+
+<!-- Code blocks -->
+<!-- You can indicate a code block (which uses the <code> element) by indenting
+a line with four spaces or a tab -->
+
+    This is code
+    So is this
+
+<!-- You can also re-tab (or add an additional four spaces) for indentation
+inside your code -->
+
+    my_array.each do |item|
+        puts item
+    end
+
+<!-- Inline code can be created using the backtick character ` -->
+
+John didn't even know what the `go_to()` function did!
+
+<!-- In Github Flavored Markdown, you can use a special syntax for code -->
+
+\`\`\`ruby <!-- except remove those backslashes when you do this, just ```ruby ! -->
+def foobar
+    puts "Hello world!"
+end
+\`\`\` <!-- here too, no backslashes, just ``` -->
+
+<-- The above text doesn't require indenting, plus Github will use syntax
+highlighting of the language you specify after the ``` -->
+
+<!-- Horizontal rule (<hr />) -->
+<!-- Horizontal rules are easily added with three or more asterisks or hyphens,
+with or without spaces. -->
+
+***
+---
+- - - 
+****************
+
+<!-- Links -->
+<!-- One of the best things about markdown is how easy it is to make links. Put
+the text to display in hard brackets [] followed by the url in parentheses () -->
+
+[Click me!](http://test.com/)
+
+<!-- You can also add a link title using quotes inside the parentheses -->
+
+[Click me!](http://test.com/ "Link to Test.com")
+
+<!-- Relative paths work too. -->
+
+[Go to music](/music/).
+
+<!-- Markdown also supports reference style links -->
+
+[Click this link][link1] for more info about it!
+[Also check out this link][foobar] if you want to.
+
+[link1]: http://test.com/ "Cool!"
+[foobar]: http://foobar.biz/ "Alright!"
+
+<!-- The title can also be in single quotes or in parentheses, or omitted
+entirely. The references can be anywhere in your document and the reference IDs
+can be anything so long as they are unique. -->
+
+<!-- There is also "implicit naming" which lets you use the link text as the id -->
+
+[This][] is a link.
+
+[this]: http://thisisalink.com/
+
+<!-- But it's not that commonly used. -->
+
+<!-- Images -->
+<!-- Images are done the same way as links but with an exclamation point in front! -->
+
+![This is the alt-attribute for my image](http://imgur.com/myimage.jpg "An optional title")
+
+<!-- And reference style works as expected -->
+
+![This is the alt-attribute.][myimage]
+
+[myimage]: relative/urls/cool/image.jpg "if you need a title, it's here"
+
+<!-- Miscellany -->
+<!-- Auto-links -->
+
+<http://testwebsite.com/> is equivalent to
+[http://testwebsite.com/](http://testwebsite.com/)
+
+<!-- Auto-links for emails -->
+
+<foo@bar.com>
+
+<!-- Escaping characters -->
+
+I want to type *this text surrounded by asterisks* but I don't want it to be
+in italics, so I do this: \*this text surrounded by asterisks\*.
+
+<!-- Tables -->
+<!-- Tables are only available in Github Flavored Markdown and are slightly
+cumbersome, but if you really want it: -->
+
+| Col1         | Col2     | Col3          |
+| :----------- | :------: | ------------: |
+| Left-aligned | Centered | Right-aligned |
+| blah         | blah     | blah          |
+
+<!-- or, for the same results -->
+
+Col 1 | Col2 | Col3
+:-- | :-: | --:
+Ugh this is so ugly | make it | stop
+
+<!-- The end! -->
+
+```
+
+For more info, check out John Gruber's official post of syntax [here](http://daringfireball.net/projects/markdown/syntax) and Adam Pritchard's great cheatsheet [here](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
-- 
cgit v1.2.3


From e4889157c7e1f0550b0f2b57b46bc7c085a917f4 Mon Sep 17 00:00:00 2001
From: Andrei Curelaru <andrei@infinidad.fr>
Date: Sat, 25 Oct 2014 14:56:07 +0200
Subject: mi chemin

---
 fr-fr/markdown.html.markdown | 174 +++++++++++++++++++++----------------------
 1 file changed, 87 insertions(+), 87 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/markdown.html.markdown b/fr-fr/markdown.html.markdown
index 32806054..82c26bb0 100644
--- a/fr-fr/markdown.html.markdown
+++ b/fr-fr/markdown.html.markdown
@@ -1,30 +1,27 @@
 ---
 language: markdown
 contributors:
-    - ["Andrei Curelaru", "http://infinidad.fr/"]
+- ["Andrei Curelaru", "http://www.infinidad.fr"]
 filename: markdown.md
 ---
 
-Markdown a été crée par Jhon Gruber en 2004. Ceci se veut être une syntaxe facile à lire et à écrire, aisément convertible en HTML(et beaucoup d'autres formats aussi à present).
+Markdown a été crée par Jhon Gruber en 2004. Ceci se veut être d'une syntaxe facile à lire et à écrire,
+aisément convertible en HTML(et beaucoup d'autres formats aussi à présent).
 
-Donnez moi autant de retours que vous voulez! 
-Sentez vous libre de forker et envoyer des pull request!
+Faites moi autant de retours que vous voulez! Sentez vous libre de "forker" et envoyer des pull request!
 
 
 ```markdown
-<!-- Markdown is a superset of HTML, so any HTML file is valid Markdown, that
-means we can use HTML elements in Markdown, such as the comment element, and
-they won't be affected by a markdown parser. However, if you create an HTML
-element in your markdown file, you cannot use markdown syntax within that
-element's contents. -->
-
-<!-- Markdown also varies in implementation from one parser to a next. This
-guide will attempt to clarify when features are universal or when they are
-specific to a certain parser. -->
+<!-- Markdown est une sorte de cousin du HTML, si bien que tout document HTML est un document Markdown valide.
+Autrement dit, nous pouvons utiliser des balises HTML dans un fichier Markdown, comme la balise commentaire dans laquelle
+nous sommes à présent, car celle-ci ne sera pas affectée par le parser Markdown.
+Toutefois, si l'on peut créer un élément HTML dans un fichier Markdown, on ne peut utiliser du Markdown à l'intérieur de ce dernier. -->
+<!--  Le Markdown est implémenté de différentes manières, selon le parser(analyseur syntaxique). Ce guide va alors tenter de trier
+les fonctionnalités universelles de celles spécifiques à un parser.  -->
 
 <!-- Headers -->
-<!-- You can create HTML elements <h1> through <h6> easily by prepending the
-text you want to be in that element by a number of hashes (#) -->
+<!-- Vous pouvez facilement créer des éléments HTML <h1> à <h6> en précédant le texte de votre futur titre par un ou plusieurs dièses (#),
+de un à six, selon le niveau de titre souhaité. -->
 # Ceci est un <h1>
 ## Ceci est un <h2>
 ### Ceci est un <h3>
@@ -32,122 +29,125 @@ text you want to be in that element by a number of hashes (#) -->
 ##### Ceci est un <h5>
 ###### Ceci est un <h6>
 
-<!-- Markdown also provides us with two alternative ways of indicating h1 and h2 -->
+<!-- Markdown fournit également une façon alternative de marquer les h1 et h2 -->
 Ceci est un h1
 =============
 
 Ceci est un h2
 -------------
 
-<!-- Simple text styles -->
-<!-- Text can be easily styled as italic or bold using markdown -->
-
-*This text is in italics.*
-_And so is this text._
+<!-- Styles basiques pour du texte -->
+<!-- On peut facilement rendre un texte "gras" ou "italique" en Markdown -->
 
-**This text is in bold.**
-__And so is this text.__
+*Ce texte est en italique.*
+_Celui-ci aussi._
 
-***This text is in both.***
-**_As is this!_**
-*__And this!__*
+**CE texte est en gras.**
+__Celui-là aussi.__
 
-<!-- In Github Flavored Markdown, which is used to render markdown files on
-Github, we also have strikethrough: -->
+***Ce texte a les deux styles.***
+**_Pareil ici_**
+*__Et là!__*
 
-~~This text is rendered with strikethrough.~~
+<!--Dans le  "Github Flavored Markdown", utilisé pour interpréter le Markdown sur Github
+,on a également le strikethrough(texte barré) : -->
 
-<!-- Paragraphs are a one or multiple adjacent lines of text separated by one or
-multiple blank lines. -->
+~~Ce texte est barré avec strikethrough.~~
+<!--  Les Paragraphes sont représentés par une ou plusieurs lignes de texte
+séparées par une ou plusieurs lignes vides.   -->
 
-This is a paragraph. I'm typing in a paragraph isn't this fun?
+Ceci est un paragraphe. J'écris dans un paragraphe, marrant non?
 
-Now I'm in paragraph 2.
-I'm still in paragraph 2 too!
+Maintenant je suis dans le paragraphe 2.
+Je suis toujours dans le paragraphe 2 ici aussi!
 
 
-I'm in paragraph three!
+Puis là, eh oui, le paragraphe3!
 
 <!-- Should you ever want to insert an HTML <br /> tag, you can end a paragraph
 with two or more spaces and then begin a new paragraph. -->
+<!--  
+Si jamais vous souhaitez insérer une balise HTML <br />, vous pouvez ajouter un ou plusieurs espaces
+à la fin de votre paragraphe, et en commencer un nouveau.
+-->
 
-I end with two spaces (highlight me to see them).  
+J'ai deux espaces vides à la fin (sélectionnez moi pour les voir). 
 
-There's a <br /> above me!
+Bigre, il y a un <br /> au dessus de moi!
 
-<!-- Block quotes are easy and done with the > character. -->
+<!-- Les 'Blocs de Citations' sont générés simplement aussi, grâce au caractère >. -->
 
-> This is a block quote. You can either
-> manually wrap your lines and put a `>` before every line or you can let your lines get really long and wrap on their own.
-> It doesn't make a difference so long as they start with a `>`.
+> Ceci est une superbe citation. Vous pouvez même
+> revenir à la ligne quand ça vous chante, et placer un  `>` devant chaque bout de ligne faisant partie
+> de la citation.
+> La taille ne compte pas^^ tant que chaque ligne commence par un `>`.
 
-> You can also use more than one level
->> of indentation?
-> How neat is that?
+> Vous pouvez aussi utiliser plus d'un niveau
+>> d'imbrication!
+> Class et facile, pas vrai?
 
-<!-- Lists -->
-<!-- Unordered lists can be made using asterisks, pluses, or hyphens -->
+<!-- les Listes -->
+<!-- Les listes non ordonnées sont marquées par des asterix (heuu astérisques), signes plus ou signes moins. -->
 
 * Item
 * Item
-* Another item
+* Un autre item
 
 or
 
 + Item
 + Item
-+ One more item
++ Encore un item
 
-or 
+or
 
 - Item
 - Item
-- One last item
+- Un dernier item
 
-<!-- Ordered lists are done with a number followed by a period -->
+<!-- les listes Ordonnées sont générées via un nombre suivi d'un point -->
 
-1. Item one
-2. Item two
-3. Item three
+1. Item un
+2. Item deux
+3. Item trois
 
-<!-- You don't even have to label the items correctly and markdown will still
-render the numbers in order, but this may not be a good idea -->
+<!-- Vous pouvez même vous passer de tout numéroter, et Markdown générera les bons chiffres.
+Ceci dit, cette variante perds en clarté lors de la rédaction.-->
 
-1. Item one
-1. Item two
-1. Item three
-<!-- (This renders the same as the above example) -->
+1. Item un
+1. Item deux
+1. Item trois
+<!-- (Cette liste sera interprétée de la même façon que celle juste au dessus.) -->
 
-<!-- You can also use sublists -->
+<!-- Vous pouvez également utiliser des sous-listes -->
 
-1. Item one
-2. Item two
-3. Item three
-    * Sub-item
-    * Sub-item
-4. Item four
+1. Item un
+2. Item deux
+3. Item trois
+* Sub-item
+* Sub-item
+4. Item quatre
 
-<!-- There are even task lists. This creates HTML checkboxes. -->
+<!-- Il y a même des "listes de Taches". Elles génèrent des champs HTML de type checkbox. -->
 
-Boxes below without the 'x' are unchecked HTML checkboxes.
-- [ ] First task to complete. 
-- [ ] Second task that needs done
-This checkbox below will be a checked HTML checkbox.
-- [x] This task has been completed
+Les [ ] ci dessous, n'ayant pas de [ x ], deviendront des cases à cocher HTML non-cochées.
+- [ ] Première tache à réaliser.
+- [ ] Une autre chose à faire.
+La case suivante sera une case à cocher HTML cochée.
+- [x] Ca ... c'est fait!
 
-<!-- Code blocks -->
-<!-- You can indicate a code block (which uses the <code> element) by indenting
-a line with four spaces or a tab -->
+<!-- les Blocs de Code -->
+<!-- Pour marquer du texte comme étant du code, il suffit de -->
 
-    This is code
-    So is this
+This is code
+So is this
 
 <!-- You can also re-tab (or add an additional four spaces) for indentation
 inside your code -->
 
-    my_array.each do |item|
-        puts item
-    end
+my_array.each do |item|
+puts item
+end
 
 <!-- Inline code can be created using the backtick character ` -->
 
@@ -157,7 +157,7 @@ John didn't even know what the `go_to()` function did!
 
 \`\`\`ruby <!-- except remove those backslashes when you do this, just ```ruby ! -->
 def foobar
-    puts "Hello world!"
+puts "Hello world!"
 end
 \`\`\` <!-- here too, no backslashes, just ``` -->
 
@@ -170,7 +170,7 @@ with or without spaces. -->
 
 ***
 ---
-- - - 
+- - -
 ****************
 
 <!-- Links -->
@@ -237,10 +237,10 @@ in italics, so I do this: \*this text surrounded by asterisks\*.
 <!-- Tables are only available in Github Flavored Markdown and are slightly
 cumbersome, but if you really want it: -->
 
-| Col1         | Col2     | Col3          |
+| Col1 | Col2 | Col3 |
 | :----------- | :------: | ------------: |
 | Left-aligned | Centered | Right-aligned |
-| blah         | blah     | blah          |
+| blah | blah | blah |
 
 <!-- or, for the same results -->
 
@@ -248,8 +248,8 @@ Col 1 | Col2 | Col3
 :-- | :-: | --:
 Ugh this is so ugly | make it | stop
 
-<!-- The end! -->
+<!-- Fin! -->
 
 ```
 
-For more info, check out John Gruber's official post of syntax [here](http://daringfireball.net/projects/markdown/syntax) and Adam Pritchard's great cheatsheet [here](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
+For more info, check out John Gruber's official post of syntax [here](http://daringfireball.net/projects/markdown/syntax) and Adam Pritchard's great cheatsheet [here](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
\ No newline at end of file
-- 
cgit v1.2.3


From 476c3a21c6f38c4497c968f8b8d2a946542da137 Mon Sep 17 00:00:00 2001
From: Andrei Curelaru <andrei@infinidad.fr>
Date: Sat, 25 Oct 2014 16:43:50 +0200
Subject: =?UTF-8?q?ay=C3=A9=20c'est=20fait?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 fr-fr/markdown.html.markdown | 155 ++++++++++++++++++++-----------------------
 1 file changed, 72 insertions(+), 83 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/markdown.html.markdown b/fr-fr/markdown.html.markdown
index 82c26bb0..b1b000fa 100644
--- a/fr-fr/markdown.html.markdown
+++ b/fr-fr/markdown.html.markdown
@@ -5,23 +5,20 @@ contributors:
 filename: markdown.md
 ---
 
-Markdown a été crée par Jhon Gruber en 2004. Ceci se veut être d'une syntaxe facile à lire et à écrire,
-aisément convertible en HTML(et beaucoup d'autres formats aussi à présent).
+Markdown a été crée par Jhon Gruber en 2004. Ceci se veut être d'une syntaxe facile à lire et à écrire, aisément convertible en HTML (et beaucoup d'autres formats aussi à présent).
 
 Faites moi autant de retours que vous voulez! Sentez vous libre de "forker" et envoyer des pull request!
 
 
 ```markdown
-<!-- Markdown est une sorte de cousin du HTML, si bien que tout document HTML est un document Markdown valide.
-Autrement dit, nous pouvons utiliser des balises HTML dans un fichier Markdown, comme la balise commentaire dans laquelle
-nous sommes à présent, car celle-ci ne sera pas affectée par le parser Markdown.
-Toutefois, si l'on peut créer un élément HTML dans un fichier Markdown, on ne peut utiliser du Markdown à l'intérieur de ce dernier. -->
-<!--  Le Markdown est implémenté de différentes manières, selon le parser(analyseur syntaxique). Ce guide va alors tenter de trier
-les fonctionnalités universelles de celles spécifiques à un parser.  -->
+<!-- Markdown est une sorte de cousin du HTML, si bien que tout document HTML est un document Markdown valide. Autrement dit, vous pouvez utiliser des balises HTML dans un fichier Markdown, comme la balise commentaire dans laquelle nous sommes à présent, car celle-ci ne sera pas affectée par le parser(analyseur syntaxique) Markdown. -->
+
+<!-- Toutefois, si vous pouvez créer un élément HTML dans un fichier Markdown, vous ne pouvez pas utiliser du Markdown à l'intérieur de ce dernier. -->
+
+<!--  Le Markdown est implémenté de différentes manières, selon le parser. Ce guide va alors tenter de trier les fonctionnalités universelles de celles spécifiques à un parser.  -->
 
 <!-- Headers -->
-<!-- Vous pouvez facilement créer des éléments HTML <h1> à <h6> en précédant le texte de votre futur titre par un ou plusieurs dièses (#),
-de un à six, selon le niveau de titre souhaité. -->
+<!-- Vous pouvez facilement créer des éléments HTML <h1> à <h6> en précédant le texte de votre futur titre par un ou plusieurs dièses (#), de un à six, selon le niveau de titre souhaité. -->
 # Ceci est un <h1>
 ## Ceci est un <h2>
 ### Ceci est un <h3>
@@ -42,40 +39,37 @@ Ceci est un h2
 *Ce texte est en italique.*
 _Celui-ci aussi._
 
-**CE texte est en gras.**
+**Ce texte est en gras.**
 __Celui-là aussi.__
 
 ***Ce texte a les deux styles.***
 **_Pareil ici_**
 *__Et là!__*
 
-<!--Dans le  "Github Flavored Markdown", utilisé pour interpréter le Markdown sur Github
-,on a également le strikethrough(texte barré) : -->
+<!-- Dans le  "Github Flavored Markdown", utilisé pour interpréter le Markdown sur Github ,on a également le strikethrough(texte barré) : -->
 
 ~~Ce texte est barré avec strikethrough.~~
+
 <!--  Les Paragraphes sont représentés par une ou plusieurs lignes de texte
-séparées par une ou plusieurs lignes vides.   -->
+séparées par une ou plusieurs lignes vides. -->
 
-Ceci est un paragraphe. J'écris dans un paragraphe, marrant non?
+Ceci est un paragraphe. Là, je suis dans un paragraphe, facile non?
 
 Maintenant je suis dans le paragraphe 2.
 Je suis toujours dans le paragraphe 2 ici aussi!
 
 
-Puis là, eh oui, le paragraphe3!
+Puis là, eh oui, le paragraphe 3!
 
-<!-- Should you ever want to insert an HTML <br /> tag, you can end a paragraph
-with two or more spaces and then begin a new paragraph. -->
 <!--  
-Si jamais vous souhaitez insérer une balise HTML <br />, vous pouvez ajouter un ou plusieurs espaces
-à la fin de votre paragraphe, et en commencer un nouveau.
+Si jamais vous souhaitez insérer une balise HTML <br />, vous pouvez ajouter un ou plusieurs espaces à la fin de votre paragraphe, et en commencer un nouveau.
 -->
 
 J'ai deux espaces vides à la fin (sélectionnez moi pour les voir). 
 
 Bigre, il y a un <br /> au dessus de moi!
 
-<!-- Les 'Blocs de Citations' sont générés simplement aussi, grâce au caractère >. -->
+<!-- Les 'Blocs de Citations' sont générés simplement aussi, grâce au caractère > -->
 
 > Ceci est une superbe citation. Vous pouvez même
 > revenir à la ligne quand ça vous chante, et placer un  `>` devant chaque bout de ligne faisant partie
@@ -87,32 +81,31 @@ Bigre, il y a un <br /> au dessus de moi!
 > Class et facile, pas vrai?
 
 <!-- les Listes -->
-<!-- Les listes non ordonnées sont marquées par des asterix (heuu astérisques), signes plus ou signes moins. -->
+<!-- les Listes non ordonnées sont marquées par des asterix (heuu astérisques), signes plus ou signes moins. -->
 
 * Item
 * Item
 * Un autre item
 
-or
+ou
 
 + Item
 + Item
 + Encore un item
 
-or
+ou
 
 - Item
 - Item
 - Un dernier item
 
-<!-- les listes Ordonnées sont générées via un nombre suivi d'un point -->
+<!-- les Listes Ordonnées sont générées via un nombre suivi d'un point -->
 
 1. Item un
 2. Item deux
 3. Item trois
 
-<!-- Vous pouvez même vous passer de tout numéroter, et Markdown générera les bons chiffres.
-Ceci dit, cette variante perds en clarté lors de la rédaction.-->
+<!-- Vous pouvez même vous passer de tout numéroter, et Markdown générera les bons chiffres. Ceci dit, cette variante perds en clarté lors de la rédaction.-->
 
 1. Item un
 1. Item deux
@@ -137,119 +130,115 @@ La case suivante sera une case à cocher HTML cochée.
 - [x] Ca ... c'est fait!
 
 <!-- les Blocs de Code -->
-<!-- Pour marquer du texte comme étant du code, il suffit de -->
+<!-- Pour marquer du texte comme étant du code, il suffit de commencer chaque ligne en tapant 4 espaces (ou un Tab) -->
 
-This is code
-So is this
+    echo "Ca, c'est du Code!";
+    var Ca = "aussi !";
 
-<!-- You can also re-tab (or add an additional four spaces) for indentation
-inside your code -->
+<!-- L'indentation par tab ou séries de quatre espaces 
+fonctionne aussi à l'intérieur du bloc de code -->
 
-my_array.each do |item|
-puts item
-end
+    my_array.each do |item|
+       puts item
+    end
 
-<!-- Inline code can be created using the backtick character ` -->
+<!-- Des bouts de code en mode 'inline' s'ajoutent en les entourant de ` -->
 
-John didn't even know what the `go_to()` function did!
+La fonction `run()` ne vous oblige pas d'aller courir!
 
-<!-- In Github Flavored Markdown, you can use a special syntax for code -->
+<!-- Via Github Flavored Markdown, vous pouvez utiliser des syntaxes spécifiques -->
 
-\`\`\`ruby <!-- except remove those backslashes when you do this, just ```ruby ! -->
+\`\`\`ruby <!-- mais enlevez les backslashes quand vous faites ça, juste ```ruby ! -->
 def foobar
 puts "Hello world!"
 end
-\`\`\` <!-- here too, no backslashes, just ``` -->
+\`\`\` <!-- pareil, no backslashes, juste ``` -->
 
-<-- The above text doesn't require indenting, plus Github will use syntax
-highlighting of the language you specify after the ``` -->
+<-- Pas besoin d'indentation pour le code juste au dessus, de plus, Github va utiliser une coloration syntaxique pour le langage indiqué après les ``` -->
 
-<!-- Horizontal rule (<hr />) -->
-<!-- Horizontal rules are easily added with three or more asterisks or hyphens,
-with or without spaces. -->
+<!-- Ligne Horizontale (<hr />) -->
+<!-- Pour en insérer une, utilisez trois ou plusieurs astérisques ou tirets,
+avec ou sans espaces entre chaque un. -->
 
 ***
 ---
 - - -
 ****************
 
-<!-- Links -->
-<!-- One of the best things about markdown is how easy it is to make links. Put
-the text to display in hard brackets [] followed by the url in parentheses () -->
+<!-- Liens -->
+<!-- Une des fonctionnalités sympathiques du Markdown est la facilité d'ajouter des liens. Le texte du lien entre [ ], l'url entre ( ), et voilà l'travail.
+-->
 
-[Click me!](http://test.com/)
+[Clic moi!](http://test.com/)
 
-<!-- You can also add a link title using quotes inside the parentheses -->
+<!-- Pour ajouter un attribut Title, collez le entre guillemets, avec le lien. -->
 
-[Click me!](http://test.com/ "Link to Test.com")
+[Clic moi!](http://test.com/ "Lien vers Test.com")
 
-<!-- Relative paths work too. -->
+<!-- les Liens Relatifs marchent aussi -->
 
-[Go to music](/music/).
+[En avant la musique](/music/).
 
-<!-- Markdown also supports reference style links -->
+<!-- Les liens façon "références" sont eux aussi disponibles en Markdown -->
 
-[Click this link][link1] for more info about it!
-[Also check out this link][foobar] if you want to.
+[Cliquez ici][link1] pour plus d'information!
+[Regardez aussi par ici][foobar] si vous voulez.
 
 [link1]: http://test.com/ "Cool!"
 [foobar]: http://foobar.biz/ "Alright!"
 
-<!-- The title can also be in single quotes or in parentheses, or omitted
-entirely. The references can be anywhere in your document and the reference IDs
-can be anything so long as they are unique. -->
+<!--  Le titre peut aussi être entouré de guillemets simples, entre parenthèses ou absent. Les références peuvent être placées un peu où vous voulez dans le document, et les identifiants (link1, foobar, ...) quoi que ce soit tant qu'ils sont uniques -->
 
-<!-- There is also "implicit naming" which lets you use the link text as the id -->
+<!-- Il y a également le "nommage implicite" qui transforme le texte du lien en identifiant -->
 
-[This][] is a link.
+[Ceci][] est un lien.
 
-[this]: http://thisisalink.com/
+[ceci]: http://ceciestunlien.com/
 
-<!-- But it's not that commonly used. -->
+<!-- mais ce n'est pas beaucoup utilisé. -->
 
 <!-- Images -->
-<!-- Images are done the same way as links but with an exclamation point in front! -->
+<!-- Pour les images, la syntaxe est identique aux liens, sauf que précédée d'un point d'exclamation! -->
 
-![This is the alt-attribute for my image](http://imgur.com/myimage.jpg "An optional title")
+![Ceci est l'attribut ALT de l'image](http://imgur.com/monimage.jpg "Titre optionnel")
 
-<!-- And reference style works as expected -->
+<!-- Là aussi, on peut utiliser le mode "références" -->
 
-![This is the alt-attribute.][myimage]
+![Ceci est l'attribut ALT de l'image][monimage]
 
-[myimage]: relative/urls/cool/image.jpg "if you need a title, it's here"
+[monimage]: relative/urls/cool/image.jpg "si vous voulez un titre, c'est ici."
 
-<!-- Miscellany -->
-<!-- Auto-links -->
+<!-- Divers -->
+<!-- Liens Automatiques -->
 
-<http://testwebsite.com/> is equivalent to
+<http://testwebsite.com/> est équivalent à :
 [http://testwebsite.com/](http://testwebsite.com/)
 
-<!-- Auto-links for emails -->
+<!-- Liens Automatiques pour emails -->
 
 <foo@bar.com>
 
-<!-- Escaping characters -->
+<!-- Escaping -->
+Il suffit de précéder les caractères spécifiques à ignorer par des backslash \
 
-I want to type *this text surrounded by asterisks* but I don't want it to be
-in italics, so I do this: \*this text surrounded by asterisks\*.
+Pour taper *ce texte* entouré d'astérisques mais pas en italique : Tapez \*ce texte\*.
 
-<!-- Tables -->
-<!-- Tables are only available in Github Flavored Markdown and are slightly
-cumbersome, but if you really want it: -->
+<!-- Tableaux -->
+<!-- les Tableaux ne sont disponibles que dans le Github Flavored Markdown et c'est ce n'est pas super agréable d'utilisation. Mais si vous en avez besoin : -->
 
 | Col1 | Col2 | Col3 |
 | :----------- | :------: | ------------: |
-| Left-aligned | Centered | Right-aligned |
-| blah | blah | blah |
+| Alignement Gauche | Centé | Alignement Droite |
+| bla | bla | bla |
 
-<!-- or, for the same results -->
+<!-- ou bien, pour un résultat équivalent : -->
 
 Col 1 | Col2 | Col3
 :-- | :-: | --:
-Ugh this is so ugly | make it | stop
+Ough que c'est moche | svp | arrêtez
 
 <!-- Fin! -->
 
 ```
 
-For more info, check out John Gruber's official post of syntax [here](http://daringfireball.net/projects/markdown/syntax) and Adam Pritchard's great cheatsheet [here](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
\ No newline at end of file
+Pour plus d'information, consultez [ici](http://daringfireball.net/projects/markdown/syntax) le post officiel de Jhon Gruber à propos de la syntaxe, et [là](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet)  la superbe cheatsheet de Adam Pritchard.
\ No newline at end of file
-- 
cgit v1.2.3


From f7aadaff81b3d0c55c4ea2fbea65774590daa2e6 Mon Sep 17 00:00:00 2001
From: Andrei Curelaru <andrei@infinidad.fr>
Date: Sat, 25 Oct 2014 16:59:58 +0200
Subject: some fixes on line-length

---
 fr-fr/markdown.html.markdown | 106 ++++++++++++++++++++++++++++++-------------
 1 file changed, 75 insertions(+), 31 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/markdown.html.markdown b/fr-fr/markdown.html.markdown
index b1b000fa..ba6c038d 100644
--- a/fr-fr/markdown.html.markdown
+++ b/fr-fr/markdown.html.markdown
@@ -5,20 +5,32 @@ contributors:
 filename: markdown.md
 ---
 
-Markdown a été crée par Jhon Gruber en 2004. Ceci se veut être d'une syntaxe facile à lire et à écrire, aisément convertible en HTML (et beaucoup d'autres formats aussi à présent).
+Markdown a été crée par Jhon Gruber en 2004. Ceci se veut être d'une syntaxe
+facile à lire et à écrire, aisément convertible en HTML,
+(et beaucoup d'autres formats aussi à présent).
 
-Faites moi autant de retours que vous voulez! Sentez vous libre de "forker" et envoyer des pull request!
+Faites moi autant de retours que vous voulez! Sentez vous libre de "forker" 
+et envoyer des pull request!
 
 
 ```markdown
-<!-- Markdown est une sorte de cousin du HTML, si bien que tout document HTML est un document Markdown valide. Autrement dit, vous pouvez utiliser des balises HTML dans un fichier Markdown, comme la balise commentaire dans laquelle nous sommes à présent, car celle-ci ne sera pas affectée par le parser(analyseur syntaxique) Markdown. -->
+<!-- Markdown est une sorte de cousin du HTML, si bien que tout document HTML 
+est un document Markdown valide. Autrement dit, vous pouvez utiliser des 
+balises HTML dans un fichier Markdown, comme la balise commentaire dans 
+laquelle nous sommes à présent, car celle-ci ne sera pas affectée par 
+le parser(analyseur syntaxique) Markdown. -->
 
-<!-- Toutefois, si vous pouvez créer un élément HTML dans un fichier Markdown, vous ne pouvez pas utiliser du Markdown à l'intérieur de ce dernier. -->
+<!-- Toutefois, si vous pouvez créer un élément HTML dans un fichier Markdown,
+ vous ne pouvez pas utiliser du Markdown à l'intérieur de ce dernier. -->
 
-<!--  Le Markdown est implémenté de différentes manières, selon le parser. Ce guide va alors tenter de trier les fonctionnalités universelles de celles spécifiques à un parser.  -->
+<!--  Le Markdown est implémenté de différentes manières, selon le parser. 
+Ce guide va alors tenter de trier les fonctionnalités universelles de celles
+spécifiques à un parser.  -->
 
 <!-- Headers -->
-<!-- Vous pouvez facilement créer des éléments HTML <h1> à <h6> en précédant le texte de votre futur titre par un ou plusieurs dièses (#), de un à six, selon le niveau de titre souhaité. -->
+<!-- Vous pouvez facilement créer des éléments HTML <h1> à <h6> en précédant
+ le texte de votre futur titre par un ou plusieurs dièses (#), de un à six,
+  selon le niveau de titre souhaité. -->
 # Ceci est un <h1>
 ## Ceci est un <h2>
 ### Ceci est un <h3>
@@ -26,7 +38,10 @@ Faites moi autant de retours que vous voulez! Sentez vous libre de "forker" et e
 ##### Ceci est un <h5>
 ###### Ceci est un <h6>
 
-<!-- Markdown fournit également une façon alternative de marquer les h1 et h2 -->
+<!-- 
+Markdown fournit également une façon alternative de marquer les h1 et h2 
+-->
+
 Ceci est un h1
 =============
 
@@ -46,11 +61,12 @@ __Celui-là aussi.__
 **_Pareil ici_**
 *__Et là!__*
 
-<!-- Dans le  "Github Flavored Markdown", utilisé pour interpréter le Markdown sur Github ,on a également le strikethrough(texte barré) : -->
+<!-- Dans le  "Github Flavored Markdown", utilisé pour interpréter le Markdown 
+sur Github ,on a également le strikethrough(texte barré) : -->
 
 ~~Ce texte est barré avec strikethrough.~~
 
-<!--  Les Paragraphes sont représentés par une ou plusieurs lignes de texte
+<!--  Les Paragraphes sont représentés par une ou plusieurs lignes de texte 
 séparées par une ou plusieurs lignes vides. -->
 
 Ceci est un paragraphe. Là, je suis dans un paragraphe, facile non?
@@ -62,17 +78,21 @@ Je suis toujours dans le paragraphe 2 ici aussi!
 Puis là, eh oui, le paragraphe 3!
 
 <!--  
-Si jamais vous souhaitez insérer une balise HTML <br />, vous pouvez ajouter un ou plusieurs espaces à la fin de votre paragraphe, et en commencer un nouveau.
+Si jamais vous souhaitez insérer une balise HTML <br />, vous pouvez ajouter 
+un ou plusieurs espaces à la fin de votre paragraphe, et en commencer 
+un nouveau.
 -->
 
 J'ai deux espaces vides à la fin (sélectionnez moi pour les voir). 
 
 Bigre, il y a un <br /> au dessus de moi!
 
-<!-- Les 'Blocs de Citations' sont générés simplement aussi, grâce au caractère > -->
+<!-- Les 'Blocs de Citations' sont générés simplement aussi, 
+grâce au caractère > -->
 
 > Ceci est une superbe citation. Vous pouvez même
-> revenir à la ligne quand ça vous chante, et placer un  `>` devant chaque bout de ligne faisant partie
+> revenir à la ligne quand ça vous chante, et placer un  `>` 
+> devant chaque bout de ligne faisant partie
 > de la citation.
 > La taille ne compte pas^^ tant que chaque ligne commence par un `>`.
 
@@ -81,7 +101,8 @@ Bigre, il y a un <br /> au dessus de moi!
 > Class et facile, pas vrai?
 
 <!-- les Listes -->
-<!-- les Listes non ordonnées sont marquées par des asterix (heuu astérisques), signes plus ou signes moins. -->
+<!-- les Listes non ordonnées sont marquées par des asterix 
+(heuu astérisques), signes plus ou signes moins. -->
 
 * Item
 * Item
@@ -105,12 +126,13 @@ ou
 2. Item deux
 3. Item trois
 
-<!-- Vous pouvez même vous passer de tout numéroter, et Markdown générera les bons chiffres. Ceci dit, cette variante perds en clarté lors de la rédaction.-->
+<!-- Vous pouvez même vous passer de tout numéroter, et Markdown générera 
+les bons chiffres. Ceci dit, cette variante perds en clarté.-->
 
 1. Item un
 1. Item deux
 1. Item trois
-<!-- (Cette liste sera interprétée de la même façon que celle juste au dessus.) -->
+<!-- (Cette liste sera interprétée de la même façon que celle au dessus.) -->
 
 <!-- Vous pouvez également utiliser des sous-listes -->
 
@@ -121,16 +143,20 @@ ou
 * Sub-item
 4. Item quatre
 
-<!-- Il y a même des "listes de Taches". Elles génèrent des champs HTML de type checkbox. -->
+<!-- Il y a même des "listes de Taches". Elles génèrent des champs HTML 
+de type checkbox. -->
+
+Les [ ] ci dessous, n'ayant pas de [ x ], 
+deviendront des cases à cocher HTML non-cochées.
 
-Les [ ] ci dessous, n'ayant pas de [ x ], deviendront des cases à cocher HTML non-cochées.
 - [ ] Première tache à réaliser.
 - [ ] Une autre chose à faire.
 La case suivante sera une case à cocher HTML cochée.
 - [x] Ca ... c'est fait!
 
 <!-- les Blocs de Code -->
-<!-- Pour marquer du texte comme étant du code, il suffit de commencer chaque ligne en tapant 4 espaces (ou un Tab) -->
+<!-- Pour marquer du texte comme étant du code, il suffit de commencer 
+chaque ligne en tapant 4 espaces (ou un Tab) -->
 
     echo "Ca, c'est du Code!";
     var Ca = "aussi !";
@@ -146,18 +172,21 @@ fonctionne aussi à l'intérieur du bloc de code -->
 
 La fonction `run()` ne vous oblige pas d'aller courir!
 
-<!-- Via Github Flavored Markdown, vous pouvez utiliser des syntaxes spécifiques -->
+<!-- Via Github Flavored Markdown, vous pouvez utiliser 
+des syntaxes spécifiques -->
 
-\`\`\`ruby <!-- mais enlevez les backslashes quand vous faites ça, juste ```ruby ! -->
+\`\`\`ruby 
+<!-- mais enlevez les backslashes quand vous faites ça, juste ```ruby ! -->
 def foobar
 puts "Hello world!"
 end
 \`\`\` <!-- pareil, no backslashes, juste ``` -->
 
-<-- Pas besoin d'indentation pour le code juste au dessus, de plus, Github va utiliser une coloration syntaxique pour le langage indiqué après les ``` -->
+<-- Pas besoin d'indentation pour le code juste au dessus, de plus, Github 
+va utiliser une coloration syntaxique pour le langage indiqué après les ``` -->
 
 <!-- Ligne Horizontale (<hr />) -->
-<!-- Pour en insérer une, utilisez trois ou plusieurs astérisques ou tirets,
+<!-- Pour en insérer une, utilisez trois ou plusieurs astérisques ou tirets, 
 avec ou sans espaces entre chaque un. -->
 
 ***
@@ -166,12 +195,16 @@ avec ou sans espaces entre chaque un. -->
 ****************
 
 <!-- Liens -->
-<!-- Une des fonctionnalités sympathiques du Markdown est la facilité d'ajouter des liens. Le texte du lien entre [ ], l'url entre ( ), et voilà l'travail.
+<!-- Une des fonctionnalités sympathiques du Markdown est la facilité 
+d'ajouter des liens. Le texte du lien entre [ ], l'url entre ( ), 
+et voilà l'travail.
 -->
 
 [Clic moi!](http://test.com/)
 
-<!-- Pour ajouter un attribut Title, collez le entre guillemets, avec le lien. -->
+<!-- 
+Pour ajouter un attribut Title, collez le entre guillemets, avec le lien. 
+-->
 
 [Clic moi!](http://test.com/ "Lien vers Test.com")
 
@@ -187,9 +220,13 @@ avec ou sans espaces entre chaque un. -->
 [link1]: http://test.com/ "Cool!"
 [foobar]: http://foobar.biz/ "Alright!"
 
-<!--  Le titre peut aussi être entouré de guillemets simples, entre parenthèses ou absent. Les références peuvent être placées un peu où vous voulez dans le document, et les identifiants (link1, foobar, ...) quoi que ce soit tant qu'ils sont uniques -->
+<!--  Le titre peut aussi être entouré de guillemets simples, 
+entre parenthèses ou absent. Les références peuvent être placées 
+un peu où vous voulez dans le document, et les identifiants 
+(link1, foobar, ...) quoi que ce soit tant qu'ils sont uniques -->
 
-<!-- Il y a également le "nommage implicite" qui transforme le texte du lien en identifiant -->
+<!-- Il y a également le "nommage implicite" qui transforme le texte du lien
+ en identifiant -->
 
 [Ceci][] est un lien.
 
@@ -198,9 +235,10 @@ avec ou sans espaces entre chaque un. -->
 <!-- mais ce n'est pas beaucoup utilisé. -->
 
 <!-- Images -->
-<!-- Pour les images, la syntaxe est identique aux liens, sauf que précédée d'un point d'exclamation! -->
+<!-- Pour les images, la syntaxe est identique aux liens, sauf que précédée
+ d'un point d'exclamation! -->
 
-![Ceci est l'attribut ALT de l'image](http://imgur.com/monimage.jpg "Titre optionnel")
+![Attribut ALT de l'image](http://imgur.com/monimage.jpg "Titre optionnel")
 
 <!-- Là aussi, on peut utiliser le mode "références" -->
 
@@ -221,10 +259,14 @@ avec ou sans espaces entre chaque un. -->
 <!-- Escaping -->
 Il suffit de précéder les caractères spécifiques à ignorer par des backslash \
 
-Pour taper *ce texte* entouré d'astérisques mais pas en italique : Tapez \*ce texte\*.
+Pour taper *ce texte* entouré d'astérisques mais pas en italique : 
+Tapez \*ce texte\*.
 
 <!-- Tableaux -->
-<!-- les Tableaux ne sont disponibles que dans le Github Flavored Markdown et c'est ce n'est pas super agréable d'utilisation. Mais si vous en avez besoin : -->
+<!-- les Tableaux ne sont disponibles que dans le Github Flavored Markdown
+ et c'est ce n'est pas super agréable d'utilisation. 
+ Mais si vous en avez besoin :
+ -->
 
 | Col1 | Col2 | Col3 |
 | :----------- | :------: | ------------: |
@@ -241,4 +283,6 @@ Ough que c'est moche | svp | arrêtez
 
 ```
 
-Pour plus d'information, consultez [ici](http://daringfireball.net/projects/markdown/syntax) le post officiel de Jhon Gruber à propos de la syntaxe, et [là](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet)  la superbe cheatsheet de Adam Pritchard.
\ No newline at end of file
+Pour plus d'information :
+ consultez [ici](http://daringfireball.net/projects/markdown/syntax) le post officiel de Jhon Gruber à propos de la syntaxe, 
+ et [là](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) la superbe cheatsheet de Adam Pritchard.
\ No newline at end of file
-- 
cgit v1.2.3


From 9bfb86a75df37132f915d964990d25862d9ded7d Mon Sep 17 00:00:00 2001
From: Andrei Curelaru <andrei@infinidad.fr>
Date: Sat, 25 Oct 2014 19:47:24 +0200
Subject: typographic and other fixes

---
 fr-fr/markdown.html.markdown | 43 +++++++++++++++++++++----------------------
 1 file changed, 21 insertions(+), 22 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/markdown.html.markdown b/fr-fr/markdown.html.markdown
index ba6c038d..edd3f025 100644
--- a/fr-fr/markdown.html.markdown
+++ b/fr-fr/markdown.html.markdown
@@ -5,9 +5,9 @@ contributors:
 filename: markdown.md
 ---
 
-Markdown a été crée par Jhon Gruber en 2004. Ceci se veut être d'une syntaxe
-facile à lire et à écrire, aisément convertible en HTML,
-(et beaucoup d'autres formats aussi à présent).
+Markdown a été créé par Jhon Gruber en 2004. Il se veut être d'une syntaxe
+facile à lire et à écrire, aisément convertible en HTML
+ (et beaucoup d'autres formats aussi à présent).
 
 Faites moi autant de retours que vous voulez! Sentez vous libre de "forker" 
 et envoyer des pull request!
@@ -18,18 +18,18 @@ et envoyer des pull request!
 est un document Markdown valide. Autrement dit, vous pouvez utiliser des 
 balises HTML dans un fichier Markdown, comme la balise commentaire dans 
 laquelle nous sommes à présent, car celle-ci ne sera pas affectée par 
-le parser(analyseur syntaxique) Markdown. -->
+le parser( analyseur syntaxique ) Markdown. -->
 
-<!-- Toutefois, si vous pouvez créer un élément HTML dans un fichier Markdown,
- vous ne pouvez pas utiliser du Markdown à l'intérieur de ce dernier. -->
+<!-- Toutefois, si vous voulez créer un élément HTML dans un fichier Markdown,
+ vous ne pourrez pas utiliser du Markdown à l'intérieur de ce dernier. -->
 
 <!--  Le Markdown est implémenté de différentes manières, selon le parser. 
 Ce guide va alors tenter de trier les fonctionnalités universelles de celles
 spécifiques à un parser.  -->
 
-<!-- Headers -->
+<!-- Headers ( En-têtes ) -->
 <!-- Vous pouvez facilement créer des éléments HTML <h1> à <h6> en précédant
- le texte de votre futur titre par un ou plusieurs dièses (#), de un à six,
+ le texte de votre futur titre par un ou plusieurs dièses ( # ), de un à six,
   selon le niveau de titre souhaité. -->
 # Ceci est un <h1>
 ## Ceci est un <h2>
@@ -61,8 +61,8 @@ __Celui-là aussi.__
 **_Pareil ici_**
 *__Et là!__*
 
-<!-- Dans le  "Github Flavored Markdown", utilisé pour interpréter le Markdown 
-sur Github ,on a également le strikethrough(texte barré) : -->
+<!-- Dans le "Github Flavored Markdown", utilisé pour interpréter le Markdown 
+sur Github, on a également le strikethrough ( texte barré ) : -->
 
 ~~Ce texte est barré avec strikethrough.~~
 
@@ -72,7 +72,7 @@ séparées par une ou plusieurs lignes vides. -->
 Ceci est un paragraphe. Là, je suis dans un paragraphe, facile non?
 
 Maintenant je suis dans le paragraphe 2.
-Je suis toujours dans le paragraphe 2 ici aussi!
+Je suis toujours dans le paragraphe 2!
 
 
 Puis là, eh oui, le paragraphe 3!
@@ -87,18 +87,17 @@ J'ai deux espaces vides à la fin (sélectionnez moi pour les voir).
 
 Bigre, il y a un <br /> au dessus de moi!
 
-<!-- Les 'Blocs de Citations' sont générés simplement aussi, 
-grâce au caractère > -->
+<!-- Les 'Blocs de Citations' sont générés aisément, grâce au caractère > -->
 
 > Ceci est une superbe citation. Vous pouvez même
-> revenir à la ligne quand ça vous chante, et placer un  `>` 
+> revenir à la ligne quand ça vous chante, et placer un `>` 
 > devant chaque bout de ligne faisant partie
 > de la citation.
 > La taille ne compte pas^^ tant que chaque ligne commence par un `>`.
 
 > Vous pouvez aussi utiliser plus d'un niveau
 >> d'imbrication!
-> Class et facile, pas vrai?
+> Classe et facile, pas vrai?
 
 <!-- les Listes -->
 <!-- les Listes non ordonnées sont marquées par des asterix 
@@ -127,12 +126,12 @@ ou
 3. Item trois
 
 <!-- Vous pouvez même vous passer de tout numéroter, et Markdown générera 
-les bons chiffres. Ceci dit, cette variante perds en clarté.-->
+les bons chiffres. Ceci dit, cette variante perd en clarté.-->
 
 1. Item un
 1. Item deux
 1. Item trois
-<!-- (Cette liste sera interprétée de la même façon que celle au dessus.) -->
+<!-- ( cette liste sera interprétée de la même façon que celle au dessus ) -->
 
 <!-- Vous pouvez également utiliser des sous-listes -->
 
@@ -152,16 +151,16 @@ deviendront des cases à cocher HTML non-cochées.
 - [ ] Première tache à réaliser.
 - [ ] Une autre chose à faire.
 La case suivante sera une case à cocher HTML cochée.
-- [x] Ca ... c'est fait!
+- [x] Ça ... c'est fait!
 
 <!-- les Blocs de Code -->
 <!-- Pour marquer du texte comme étant du code, il suffit de commencer 
 chaque ligne en tapant 4 espaces (ou un Tab) -->
 
-    echo "Ca, c'est du Code!";
-    var Ca = "aussi !";
+    echo "Ça, c'est du Code!";
+    var Ça = "aussi !";
 
-<!-- L'indentation par tab ou séries de quatre espaces 
+<!-- L'indentation par tab ou série de quatre espaces 
 fonctionne aussi à l'intérieur du bloc de code -->
 
     my_array.each do |item|
@@ -170,7 +169,7 @@ fonctionne aussi à l'intérieur du bloc de code -->
 
 <!-- Des bouts de code en mode 'inline' s'ajoutent en les entourant de ` -->
 
-La fonction `run()` ne vous oblige pas d'aller courir!
+La fonction `run()` ne vous oblige pas à aller courir!
 
 <!-- Via Github Flavored Markdown, vous pouvez utiliser 
 des syntaxes spécifiques -->
-- 
cgit v1.2.3


From 10fad1328574fdadef79b3e960dc759cebea8770 Mon Sep 17 00:00:00 2001
From: Andrei Curelaru <andrei@infinidad.fr>
Date: Sat, 25 Oct 2014 19:51:39 +0200
Subject: Good bye Asterix

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

(limited to 'fr-fr')

diff --git a/fr-fr/markdown.html.markdown b/fr-fr/markdown.html.markdown
index edd3f025..fa10e62f 100644
--- a/fr-fr/markdown.html.markdown
+++ b/fr-fr/markdown.html.markdown
@@ -100,8 +100,8 @@ Bigre, il y a un <br /> au dessus de moi!
 > Classe et facile, pas vrai?
 
 <!-- les Listes -->
-<!-- les Listes non ordonnées sont marquées par des asterix 
-(heuu astérisques), signes plus ou signes moins. -->
+<!-- les Listes non ordonnées sont marquées par des asterisques, 
+signes plus ou signes moins. -->
 
 * Item
 * Item
-- 
cgit v1.2.3


From b4edd938235f139dcacd555121a1f755f55482f3 Mon Sep 17 00:00:00 2001
From: Andrei Curelaru <andrei@infinidad.fr>
Date: Sat, 25 Oct 2014 22:36:40 +0200
Subject: other fixes

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

(limited to 'fr-fr')

diff --git a/fr-fr/markdown.html.markdown b/fr-fr/markdown.html.markdown
index fa10e62f..e3ac5a92 100644
--- a/fr-fr/markdown.html.markdown
+++ b/fr-fr/markdown.html.markdown
@@ -175,11 +175,12 @@ La fonction `run()` ne vous oblige pas à aller courir!
 des syntaxes spécifiques -->
 
 \`\`\`ruby 
-<!-- mais enlevez les backslashes quand vous faites ça, juste ```ruby ! -->
+<!-- mais enlevez les backslashes quand vous faites ça, 
+gardez juste ```ruby ( ou nom de la synatxe correspondant à votre code )-->
 def foobar
 puts "Hello world!"
 end
-\`\`\` <!-- pareil, no backslashes, juste ``` -->
+\`\`\` <!-- pareil, pas de backslashes, juste ``` en guise de fin -->
 
 <-- Pas besoin d'indentation pour le code juste au dessus, de plus, Github 
 va utiliser une coloration syntaxique pour le langage indiqué après les ``` -->
-- 
cgit v1.2.3


From 928fdd34b03a3e5ef5f30327a3072c242c549fd7 Mon Sep 17 00:00:00 2001
From: Baptiste Fontaine <b@ptistefontaine.fr>
Date: Sun, 26 Oct 2014 12:57:49 +0100
Subject: [markdown/en] Fixed typo in language author
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

It’s “John Gruber”, not “Jhon Gruber”.
---
 fr-fr/markdown.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/markdown.html.markdown b/fr-fr/markdown.html.markdown
index e3ac5a92..50e507cd 100644
--- a/fr-fr/markdown.html.markdown
+++ b/fr-fr/markdown.html.markdown
@@ -5,7 +5,7 @@ contributors:
 filename: markdown.md
 ---
 
-Markdown a été créé par Jhon Gruber en 2004. Il se veut être d'une syntaxe
+Markdown a été créé par John Gruber en 2004. Il se veut être d'une syntaxe
 facile à lire et à écrire, aisément convertible en HTML
  (et beaucoup d'autres formats aussi à présent).
 
@@ -285,4 +285,4 @@ Ough que c'est moche | svp | arrêtez
 
 Pour plus d'information :
  consultez [ici](http://daringfireball.net/projects/markdown/syntax) le post officiel de Jhon Gruber à propos de la syntaxe, 
- et [là](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) la superbe cheatsheet de Adam Pritchard.
\ No newline at end of file
+ et [là](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) la superbe cheatsheet de Adam Pritchard.
-- 
cgit v1.2.3


From ff43d607bd22a7125658e28eb623e537a96b52a5 Mon Sep 17 00:00:00 2001
From: Baptiste Fontaine <batifon@yahoo.fr>
Date: Sun, 26 Oct 2014 13:44:38 +0100
Subject: Bash French translation added

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

(limited to 'fr-fr')

diff --git a/fr-fr/bash-fr.html.markdown b/fr-fr/bash-fr.html.markdown
new file mode 100644
index 00000000..d4685124
--- /dev/null
+++ b/fr-fr/bash-fr.html.markdown
@@ -0,0 +1,228 @@
+---
+category: tool
+tool: bash
+contributors:
+    - ["Max Yankov", "https://github.com/golergka"]
+    - ["Darren Lin", "https://github.com/CogBear"]
+    - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"]
+    - ["Denis Arh", "https://github.com/darh"]
+    - ["akirahirose", "https://twitter.com/akirahirose"]
+    - ["Anton Strömkvist", "http://lutic.org/"]
+    - ["Rahil Momin", "https://github.com/iamrahil"]
+    - ["Gregrory Kielian", "https://github.com/gskielian"]
+    - ["Baptiste Fontaine", "http://bfontaine.net"]
+filename: LearnBash-fr.sh
+lang: fr-fr
+---
+
+Bash est le nom du shell UNIX, qui était aussi distribué avec le système
+d’exploitation GNU et est le shell par défaut sur Linux et Mac OS X.
+
+Presque tous les exemples ci-dessous peuvent être écrits dans un script shell
+ou exécutés directement dans le terminal.
+
+[Plus d’informations ici.](http://www.gnu.org/software/bash/manual/bashref.html)
+
+```bash
+#!/bin/bash
+# La première ligne du script s’appelle le « shebang, » qui indique au système
+# comment exécuter le script : http://fr.wikipedia.org/wiki/Shebang
+# Comme vous pouvez le remarquer, les commentaires commencent par #. Le shebang
+# est aussi un commentaire
+
+# Un exemple simple qui affiche « Hello world! » :
+echo Hello world!
+
+# Chaque commande commence sur une nouvelle ligne ou après un point-virgule :
+echo 'Ceci est la première ligne'; echo 'Ceci est la seconde ligne'
+
+# La déclaration d’une variable ressemble à ça :
+VARIABLE="Du texte"
+
+# Mais pas comme ça :
+VARIABLE = "Du texte"
+# Bash va penser que VARIABLE est une commande qu’il doit exécuter et va
+# afficher une erreur parce qu’elle est introuvable.
+
+# Utiliser la variable :
+echo $VARIABLE
+echo "$VARIABLE"
+echo '$VARIABLE'
+# Quand vous utilisez la variable en elle-même – en lui assignant une valeur,
+# en l’exportant ou autre – vous écrivez son nom sans $. Si vous voulez
+# utiliser sa valeur, vous devez utiliser $.
+# Notez que ' (guillemet droit simple) empêche l’expansion des variables !
+
+# Substitution de chaîne de caractères dans les variables
+echo ${VARIABLE/Some/A}
+# Ceci va remplacer la première occurrence de « Some »  par « A »
+
+# Sous-chaîne d’une variable
+echo ${VARIABLE:0:7}
+# Ceci va retourner seulement les 7 premiers caractères de la valeur
+
+# Valeur par défaut d’une variable
+echo ${FOO:-"ValeurParDefautSiFOOestVideOuInexistant"}
+# Ceci marche pour null (FOO=), la chaîne de caractères vide (FOO=""). Zéro
+# (FOO=0) retourne 0
+
+# Variables pré-remplies :
+# Il y a quelques variables pré-remplies utiles, comme :
+echo "La valeur de retour du dernier programme : $?"
+echo "Le PID du script : $$"
+echo "Nombre d’arguments : $#"
+echo "Arguments du script : $@"
+echo "Arguments du script séparés en plusieurs variables : $1 $2..."
+
+# Lire une valeur depuis l’entrée standard :
+echo "Quel est votre nom ?"
+read NAME # Notez que l’on a pas eu à déclarer une nouvelle variable
+echo Bonjour, $NAME!
+
+# Nous avons l’habituelle structure « if » :
+# Utilisez 'man test' pour plus d’informations à propos des conditions
+if [ $NAME -ne $USER ]
+then
+    echo "Votre nom n’est pas votre pseudo"
+else
+    echo "Votre nom est votre pseudo"
+fi
+
+# Il y a aussi l’exécution conditionnelle
+echo "Toujours exécuté" || echo "Exécuté si la première commande ne réussit pas"
+echo "Toujours exécuté" && echo "Exécuté si la première commande réussit"
+
+# Pour utiliser && et || avec des commandes « if, » vous devez utiliser
+# plusieurs paires de crochets :
+if [ $NAME == "Steve" ] && [ $AGE -eq 15 ]
+then
+    echo "Ceci sera exécuté si $NAME est Steve ET $AGE est 15."
+fi
+
+if [ $NAME == "Daniya" ] || [ $NAME == "Zach" ]
+then
+    echo "Ceci sera exécuté si $NAME est Daniya OU Zach."
+fi
+
+# Les expressions sont écrites dans le format suivant :
+echo $(( 10 + 5 ))
+
+# Contrairement aux autres langages de programmation, Bash est un shell — il
+# est donc exécuté dans le contexte du répertoire courant. Vous pouvez lister
+# les fichiers et dossiers dans le répertoire courant avec la commande `ls` :
+ls
+
+# Ces commandes ont des options qui contrôlent leur exécution :
+ls -l # Liste tous les fichiers et répertoires sur des lignes séparées
+
+# Les résultat de la commande précédente peuvent être passés à la commande
+# suivante en entrée.
+# La commande grep filtre l’entrée avec les motifs donnés. On peut ainsi lister
+# les fichiers .txt dans le répertoire courant :
+ls -l | grep "\.txt"
+
+# Vous pouvez aussi rediriger l’entrée et les sorties standards et d’erreur
+# d’une commande :
+python2 hello.py < "entrée.in"
+python2 hello.py > "sortie.out"
+python2 hello.py 2> "erreur.err"
+# Ceci va écraser le fichier s'il existe; si vous préférez écrire à la fin de
+celui-ci, utilisez >> à la place.
+
+# Les commandes peuvent se substituer à l’intérieur d’autres commandes en
+# utilisant $( ) :
+# La commande ci-dessous affiche le nombre de fichiers et répertoires dans le
+# répertoire courant :
+echo "Il y a $(ls | wc -l) choses ici."
+
+# On peut faire la même chose avec les accents graves `` mais on ne peut pas
+# les imbriquer — la façon la plus courante est d’utiliser $( ).
+echo "There are `ls | wc -l` items here."
+
+# Bash a une commande case qui marche de façon similaire au switch de Java et
+# C++ :
+case "$VARIABLE" in
+    #List patterns for the conditions you want to meet
+    0) echo "There is a zero.";;
+    1) echo "There is a one.";;
+    *) echo "It is not null.";;
+esac
+
+# La boucle for itère autant de fois qu’elle a d’arguments :
+# Le contenu de $VARIABLE est affiché trois fois.
+for VARIABLE in {1..3}
+do
+    echo "$VARIABLE"
+done
+
+# Ou écrivez-la de façon « traditionnelle » :
+for ((a=1; a <= 3; a++))
+do
+    echo $a
+done
+
+# Elles peuvent aussi être utilisées pour agir sur des fichiers :
+# Cette boucle va exécuter la commande 'cat' sur fichier1 et fichier2
+for VARIABLE in fichier1 fichier2
+do
+    cat "$VARIABLE"
+done
+
+# …ou la sortie d’une commande :
+# Ceci va afficher la sortie de ls.
+for OUTPUT in $(ls)
+do
+    cat "$OUTPUT"
+done
+
+# Boucle while :
+while [ true ]
+do
+    echo "corps de la boucle ..."
+    break
+done
+
+# Vous pouvez aussi définir des fonctions
+# Définition :
+function foo ()
+{
+    echo "Les arguments fonctionnent comme les arguments de script : $@"
+    echo "Et : $1 $2..."
+    echo "Ceci est une fonction"
+    return 0
+}
+
+# Ou plus simplement :
+bar ()
+{
+    echo "Une autre façon de définir des fonctions !"
+    return 0
+}
+
+# Appeler votre fonction
+foo "Mon nom est" $NAME
+
+# Il y a plein de commandes utiles que vous devriez apprendre :
+# affiche les 10 dernières lignes de fichier.txt
+tail -n 10 fichier.txt
+# affiche les 10 premières lignes de fichier.txt
+head -n 10 fichier.txt
+# trie les lignes de fichier.txt
+sort fichier.txt
+# montre ou omet les lignes répétées, avec -d pour les montrer
+uniq -d fichier.txt
+# affiche uniquement la première colonne avant le caractère « , »
+cut -d ',' -f 1 fichier.txt
+# remplace chaque occurrence de 'okay' par 'super' dans fichier.txt
+# (compatible avec les expression rationnelles)
+sed -i 's/okay/super/g' fichier.txt
+# affiche toutes les lignes de fichier.txt qui correspondent à une expression
+# rationnelle, dans cet exemple les lignes qui commencent par « foo » et
+# finissent par « bar »
+grep "^foo.*bar$" fichier.txt
+# ajoutez l’option « -c » pour afficher le nombre de lignes concernées
+grep -c "^foo.*bar$" fichier.txt
+# Si vous voulez vraiment chercher une chaîne de caractères, et non
+# l’expression rationnelle, utilisez fgrep (ou grep -F)
+fgrep "^foo.*bar$" fichier.txt
+```
-- 
cgit v1.2.3


From c7e8b6f06bdb11e611277b24d140542794d4a201 Mon Sep 17 00:00:00 2001
From: Andrei Curelaru <andrei@infinidad.fr>
Date: Sun, 26 Oct 2014 17:07:25 +0100
Subject: Added yaml-fr

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

(limited to 'fr-fr')

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


From ef30c1918c9d1b208c0f2206d40d8cd3ca075ef3 Mon Sep 17 00:00:00 2001
From: Andrei Curelaru <andrei@infinidad.fr>
Date: Sun, 26 Oct 2014 17:16:25 +0100
Subject: first fixes

---
 fr-fr/yaml-fr.html.markdown | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/yaml-fr.html.markdown b/fr-fr/yaml-fr.html.markdown
index 6bdcb6e8..7f962f61 100644
--- a/fr-fr/yaml-fr.html.markdown
+++ b/fr-fr/yaml-fr.html.markdown
@@ -46,7 +46,8 @@ bloc_littéral: |
 
     Le littéral continue jusqu'à ce que l'indentation soit annulée.
 
-        Toutes lignes qui serait "d'avantage indentées" conservent leur indentation, constituée de 4 espaces.
+        Toutes lignes qui serait "d'avantage indentées" conservent leur 
+        indentation, constituée de 4 espaces.
 bloc_replié: >
     Tout ce bloc de texte sera la valeur de la clé 'bloc_replié', mais 
     cette fois ci, toutes les nouvelles lignes deviendront un simple espace.
@@ -148,9 +149,8 @@ set2:
 
 ```
 
-  \//||\/||
-  // ||  ||__ Références Externes et outils :
+Quelques références et outils :
 
-[Specs YAML 1.2](http://www.yaml.org/spec/1.2/spec.html) *anglais*
-[Introduction à YAML](http://sweetohm.net/html/introduction-yaml.html)
-[Online YAML parser](http://yaml-online-parser.appspot.com/)
+- Doc officielle [YAML 1.2](http://www.yaml.org/spec/1.2/spec.html) *anglais*,
+- Une [Introduction à YAML](http://sweetohm.net/html/introduction-yaml.html) très bien construite et claire,
+- Un outil pour tester [live](http://yaml-online-parser.appspot.com/) la syntaxe YAML, avec des exemples.
\ No newline at end of file
-- 
cgit v1.2.3


From 78bea60c369ff2a02b28024a29409938cfdff686 Mon Sep 17 00:00:00 2001
From: Baptiste Fontaine <batifon@yahoo.fr>
Date: Sun, 26 Oct 2014 21:33:31 +0100
Subject: [bash/fr] translators section added

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

(limited to 'fr-fr')

diff --git a/fr-fr/bash-fr.html.markdown b/fr-fr/bash-fr.html.markdown
index d4685124..4678237d 100644
--- a/fr-fr/bash-fr.html.markdown
+++ b/fr-fr/bash-fr.html.markdown
@@ -10,6 +10,7 @@ contributors:
     - ["Anton Strömkvist", "http://lutic.org/"]
     - ["Rahil Momin", "https://github.com/iamrahil"]
     - ["Gregrory Kielian", "https://github.com/gskielian"]
+translators:
     - ["Baptiste Fontaine", "http://bfontaine.net"]
 filename: LearnBash-fr.sh
 lang: fr-fr
-- 
cgit v1.2.3


From 9f2d4d80277bd8d420f002b4214fcd48cadad49e Mon Sep 17 00:00:00 2001
From: Baptiste Fontaine <batifon@yahoo.fr>
Date: Sun, 26 Oct 2014 13:58:11 +0100
Subject: Brainfuck French translation added

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

(limited to 'fr-fr')

diff --git a/fr-fr/brainfuck-fr.html.markdown b/fr-fr/brainfuck-fr.html.markdown
new file mode 100644
index 00000000..4b8e918f
--- /dev/null
+++ b/fr-fr/brainfuck-fr.html.markdown
@@ -0,0 +1,87 @@
+---
+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 guillements) 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 cette valeur 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 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 122b9ab40855ad386e398e8f71cb539eeab47b85 Mon Sep 17 00:00:00 2001
From: Baptiste Fontaine <batifon@yahoo.fr>
Date: Mon, 27 Oct 2014 12:25:34 +0100
Subject: Brainfuck/fr: a couple fixes after proof-reading

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

(limited to 'fr-fr')

diff --git a/fr-fr/brainfuck-fr.html.markdown b/fr-fr/brainfuck-fr.html.markdown
index 4b8e918f..3882734d 100644
--- a/fr-fr/brainfuck-fr.html.markdown
+++ b/fr-fr/brainfuck-fr.html.markdown
@@ -54,12 +54,12 @@ 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 cette valeur 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.
+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 pour favoriser la lisibilité,
+Souvenez-vous que les espaces sont uniquement là pour favoriser la lisibilité,
 vous pourriez tout aussi aisément écrire le programme comme ceci :
 
 ,[>+<-]>.
-- 
cgit v1.2.3


From b3cceac37eefae7cfeac73fad7eefde3e40a5fce Mon Sep 17 00:00:00 2001
From: Adam Bard <github@adambard.com>
Date: Tue, 28 Oct 2014 23:12:58 +0200
Subject: Update markdown.html.markdown

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

(limited to 'fr-fr')

diff --git a/fr-fr/markdown.html.markdown b/fr-fr/markdown.html.markdown
index 50e507cd..29c0d65d 100644
--- a/fr-fr/markdown.html.markdown
+++ b/fr-fr/markdown.html.markdown
@@ -3,6 +3,7 @@ language: markdown
 contributors:
 - ["Andrei Curelaru", "http://www.infinidad.fr"]
 filename: markdown.md
+lang: fr-fr
 ---
 
 Markdown a été créé par John Gruber en 2004. Il se veut être d'une syntaxe
-- 
cgit v1.2.3


From 8f7ad2af1ebab9ebffe5aee1c7f6325acb8ddd3e Mon Sep 17 00:00:00 2001
From: Baptiste Fontaine <batifon@yahoo.fr>
Date: Wed, 12 Nov 2014 21:40:15 +0100
Subject: [bash/fr] A couple formatting/phrasing issues fixed
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Thanks to @vendethiel’s feedback on #824.
---
 fr-fr/bash-fr.html.markdown | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/bash-fr.html.markdown b/fr-fr/bash-fr.html.markdown
index 4678237d..0e764d7d 100644
--- a/fr-fr/bash-fr.html.markdown
+++ b/fr-fr/bash-fr.html.markdown
@@ -45,18 +45,19 @@ VARIABLE = "Du texte"
 # Bash va penser que VARIABLE est une commande qu’il doit exécuter et va
 # afficher une erreur parce qu’elle est introuvable.
 
-# Utiliser la variable :
+# Utiliser une variable :
 echo $VARIABLE
 echo "$VARIABLE"
 echo '$VARIABLE'
 # Quand vous utilisez la variable en elle-même – en lui assignant une valeur,
 # en l’exportant ou autre – vous écrivez son nom sans $. Si vous voulez
 # utiliser sa valeur, vous devez utiliser $.
-# Notez que ' (guillemet droit simple) empêche l’expansion des variables !
+# Notez qu’entourer une variable de deux guillemets simples (') empêche
+# l’expansion des variables !
 
-# Substitution de chaîne de caractères dans les variables
+# Substitution de chaîne de caractères dans une variable
 echo ${VARIABLE/Some/A}
-# Ceci va remplacer la première occurrence de « Some »  par « A »
+# Ceci va remplacer la première occurrence de « Some » par « A »
 
 # Sous-chaîne d’une variable
 echo ${VARIABLE:0:7}
@@ -77,7 +78,7 @@ echo "Arguments du script séparés en plusieurs variables : $1 $2..."
 
 # Lire une valeur depuis l’entrée standard :
 echo "Quel est votre nom ?"
-read NAME # Notez que l’on a pas eu à déclarer une nouvelle variable
+read NAME # Notez que l’on n’a pas eu à déclarer une nouvelle variable
 echo Bonjour, $NAME!
 
 # Nous avons l’habituelle structure « if » :
@@ -128,7 +129,7 @@ python2 hello.py < "entrée.in"
 python2 hello.py > "sortie.out"
 python2 hello.py 2> "erreur.err"
 # Ceci va écraser le fichier s'il existe; si vous préférez écrire à la fin de
-celui-ci, utilisez >> à la place.
+# celui-ci, utilisez >> à la place.
 
 # Les commandes peuvent se substituer à l’intérieur d’autres commandes en
 # utilisant $( ) :
-- 
cgit v1.2.3


From e53b98a1187633c09d0b702464efbb435fe3f1c0 Mon Sep 17 00:00:00 2001
From: Andrei Curelaru <andrei@infinidad.fr>
Date: Wed, 12 Nov 2014 23:59:32 +0100
Subject: yaml-fr fixes

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

(limited to 'fr-fr')

diff --git a/fr-fr/yaml-fr.html.markdown b/fr-fr/yaml-fr.html.markdown
index 7f962f61..0b4ba032 100644
--- a/fr-fr/yaml-fr.html.markdown
+++ b/fr-fr/yaml-fr.html.markdown
@@ -81,7 +81,7 @@ une_map_imbriquée:
 # YAML autorise aussi l'usage des collections à l'intérieur des clés,
 # mais certains langages de programmation ne le tolère pas si bien.
 
-# les Séquences ( équivalent des listes ou tableaux ) ressemblent à cela:
+# les Séquences( équivalent des listes ou tableaux )ressemblent à cela:
 une_séquence:
     - Item 1
     - Item 2
@@ -99,7 +99,7 @@ json_map: {"clé": "valeur"}
 json_seq: [1, 2, 3, "soleil"]
 
 #################################
-# AUTRES FONCTIONNALITEES YAML #
+# AUTRES FONCTIONNALITÉES YAML #
 #################################
 
 # YAML possède une fonctionnalité fort utile nommée 'ancres'. Celle-ci 
@@ -120,14 +120,14 @@ python_complex_number: !!python/complex 1+2j
 # AUTRES TYPES YAML #
 #####################
 
-# YAML comprends aussi les données formatées ISO de type date et datetime,
+# YAML interprète également les données formatées ISO de type date et datetime,
 # pas seulement les chaînes et nombres. 
 datetime: 2001-12-15T02:59:43.1Z
 datetime_avec_espaces: 2001-12-14 21:59:43.10 -5
 date: 2002-12-14
 
 # Le tag !!binary indique que la chaîne à suivre est la représentation binaire
-# d'un blob encodé en base64. En clair ? Une image!
+# d'un blob encodé en base64. En clair ? Une image !
 fichier_gif: !!binary |
     R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
     OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+
@@ -140,7 +140,7 @@ set:
     ? item2
     ? item3
 
-# Comme dans Python, les sets ne sont que des maps contenant des valeurs null;
+# Comme dans Python, les sets ne sont que des maps contenant des valeurs null ;
 # le set précédent est l'équivalent du suivant:
 set2:
     item1: null
-- 
cgit v1.2.3


From 9d0aa8abf6f5824272c84adf814d2d7a2c5608fe Mon Sep 17 00:00:00 2001
From: Andrei Curelaru <andrei@infinidad.fr>
Date: Thu, 13 Nov 2014 00:18:42 +0100
Subject: yaml-fr fixes

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

(limited to 'fr-fr')

diff --git a/fr-fr/yaml-fr.html.markdown b/fr-fr/yaml-fr.html.markdown
index 0b4ba032..d9b94aa6 100644
--- a/fr-fr/yaml-fr.html.markdown
+++ b/fr-fr/yaml-fr.html.markdown
@@ -81,7 +81,7 @@ une_map_imbriquée:
 # YAML autorise aussi l'usage des collections à l'intérieur des clés,
 # mais certains langages de programmation ne le tolère pas si bien.
 
-# les Séquences( équivalent des listes ou tableaux )ressemblent à cela:
+# les Séquences (équivalent des listes ou tableaux) ressemblent à cela:
 une_séquence:
     - Item 1
     - Item 2
-- 
cgit v1.2.3


From bfabbc0923a22d42dabc8e5516955d2cb789c358 Mon Sep 17 00:00:00 2001
From: Adam Bard <github@adambard.com>
Date: Fri, 14 Nov 2014 17:08:27 +0200
Subject: Update yaml-fr.html.markdown

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

(limited to 'fr-fr')

diff --git a/fr-fr/yaml-fr.html.markdown b/fr-fr/yaml-fr.html.markdown
index d9b94aa6..43b1df54 100644
--- a/fr-fr/yaml-fr.html.markdown
+++ b/fr-fr/yaml-fr.html.markdown
@@ -3,6 +3,7 @@ language: yaml
 filename: learnyaml.yaml
 contributors:
   - ["Andrei Curelaru", "http://www.infinidad.fr"]
+lang: fr-fr
 ---
 
 Proposé à l'origine par Clark Evans en Mai 2001, YAML est un un format de 
@@ -153,4 +154,4 @@ Quelques références et outils :
 
 - Doc officielle [YAML 1.2](http://www.yaml.org/spec/1.2/spec.html) *anglais*,
 - Une [Introduction à YAML](http://sweetohm.net/html/introduction-yaml.html) très bien construite et claire,
-- Un outil pour tester [live](http://yaml-online-parser.appspot.com/) la syntaxe YAML, avec des exemples.
\ No newline at end of file
+- Un outil pour tester [live](http://yaml-online-parser.appspot.com/) la syntaxe YAML, avec des exemples.
-- 
cgit v1.2.3


From c5723d5e2a6302b3047569aa94c7974cad868287 Mon Sep 17 00:00:00 2001
From: Adam Bard <github@adambard.com>
Date: Fri, 5 Dec 2014 22:45:17 +0100
Subject: Fixes #882

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

(limited to 'fr-fr')

diff --git a/fr-fr/brainfuck-fr.html.markdown b/fr-fr/brainfuck-fr.html.markdown
index 3882734d..545e407e 100644
--- a/fr-fr/brainfuck-fr.html.markdown
+++ b/fr-fr/brainfuck-fr.html.markdown
@@ -13,7 +13,7 @@ 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 guillements) est ignoré.
+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.
-- 
cgit v1.2.3


From 22d0cb02a8e08532555edde1f5ccf9a34a2b6a77 Mon Sep 17 00:00:00 2001
From: Fla <flaburgan@geexxx.fr>
Date: Mon, 12 Jan 2015 14:10:41 +0100
Subject: Typo

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

(limited to 'fr-fr')

diff --git a/fr-fr/ruby-fr.html.markdown b/fr-fr/ruby-fr.html.markdown
index 75c8d0d3..1564d2b6 100644
--- a/fr-fr/ruby-fr.html.markdown
+++ b/fr-fr/ruby-fr.html.markdown
@@ -268,7 +268,7 @@ end
 # implicitement la valeur de la dernière instruction évaluée
 double(2) #=> 4
 
-# Les paranthèses sont facultative
+# Les parenthèses sont facultatives
 # lorsqu'il n'y a pas d'ambiguïté sur le résultat
 double 3 #=> 6
 
-- 
cgit v1.2.3


From abce4e0a2fd8598a2768bcef86623a02e5f572e5 Mon Sep 17 00:00:00 2001
From: Jean-Philippe Monette <contact@jpmonette.net>
Date: Tue, 17 Mar 2015 20:25:44 +0000
Subject: Adding Go French translation

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

(limited to 'fr-fr')

diff --git a/fr-fr/go-fr.html.markdown b/fr-fr/go-fr.html.markdown
new file mode 100644
index 00000000..1d2b656b
--- /dev/null
+++ b/fr-fr/go-fr.html.markdown
@@ -0,0 +1,430 @@
+---
+name: Go
+category: language
+language: Go
+filename: learngo.go
+contributors:
+    - ["Sonia Keys", "https://github.com/soniakeys"]
+    - ["Christopher Bess", "https://github.com/cbess"]
+    - ["Jesse Johnson", "https://github.com/holocronweaver"]
+    - ["Quint Guvernator", "https://github.com/qguv"]
+    - ["Jose Donizetti", "https://github.com/josedonizetti"]
+    - ["Alexej Friesen", "https://github.com/heyalexej"]
+    - ["Jean-Philippe Monette", "http://blogue.jpmonette.net/"]
+---
+
+Go a été créé dans l'optique de déveloper de façcon efficace. Ce n'est pas la
+dernière tendance en ce qui au développement, mais c'est la nouvelle façon de
+régler des défis réels de façcon rapide.
+
+Le langage possède des concepts familiers à la programmation impérative avec
+typage. Il est rapide à compiler et exécuter, ajoute une concurrence facile à
+comprendre pour les processeurs multi coeurs d'aujourd'hui et apporte des
+fonctionnalités facilitant le développement à grande échelle.
+
+Développer avec Go, c'est bénéficier d'une riche librairie standard et d'une
+communauté active.
+
+```go
+// Commentaire ligne simple
+/* Commentaire
+ multiligne */
+
+// Un paquet débute avec une clause "package"
+// "Main" est un nom spécial déclarant un paquet de type exécutable plutôt
+// qu'une librairie
+package main
+
+// "Import" déclare les paquets référencés dans ce fichier.
+import (
+  "fmt"       // Un paquet dans la librairie standard.
+  "io/ioutil" // Implémente des fonctions utilitaires I/O.
+  m "math"    // Librairie mathématique utilisant un alias local "m".
+  "net/http"  // Un serveur Web!
+  "strconv"   // Librairie pour convertir les chaînes de caractères.
+)
+
+// Une définition de fonction. La fonction "main" est spéciale - c'est le point
+// d'entrée du binaire. Celle-ci est encapsulée par des accolades.
+func main() {
+  // Println retourne une ligne à stdout.
+  // Associez la fonction avec son paquet respectif, fmt.
+  fmt.Println("Hello world!")
+
+  // Appelez une fonction différente à partir de ce paquet.
+  beyondHello()
+}
+
+// Les fonctions ont des paramètres entre parenthèses.
+// Les parenthèses sont nécessaires avec ou sans paramètre.
+func beyondHello() {
+  var x int // Déclaration de variable. Les variables doivent être déclarées
+            // avant leur utilisation.
+  x = 3     // Assignation de valeur.
+  // Les déclarations courtes utilisent := pour inférer le type, déclarer et
+  // assigner.
+  y := 4
+  sum, prod := learnMultiple(x, y)        // La fonction retourne deux valeurs.
+  fmt.Println("sum:", sum, "prod:", prod) // Affichage simple.
+  learnTypes()                            // < y minutes, en savoir plus!
+}
+
+// Les fonctions peuvent avoir des paramètres et plusieurs valeurs retournées.
+func learnMultiple(x, y int) (sum, prod int) {
+  return x + y, x * y // Deux valeurs retournées.
+}
+
+// Quelques types inclus et littéraux.
+func learnTypes() {
+  // Déclaration courte produit généralement le type désiré.
+  str := "Learn Go!" // Type string.
+
+  s2 := `Une chaîne de caractères peut contenir des
+sauts de ligne.` // Chaîne de caractère.
+
+  // Littéral non-ASCII. Les sources Go utilisent le charset UTF-8.
+  g := 'Σ' // type rune, un alias pour le type int32, contenant un caractère
+           // unicode.
+
+  f := 3.14195 // float64, un nombre flottant IEEE-754 de 64-bit.
+  c := 3 + 4i  // complex128, représenté à l'interne par deux float64.
+
+  // Syntaxe "var" avec une valeur d'initialisation.
+  var u uint = 7 // Non signé, mais la taille dépend selon l'entier.
+  var pi float32 = 22. / 7
+
+  // Conversion avec syntaxe courte.
+  n := byte('\n') // byte est un alias du type uint8.
+
+  // Les tableaux ont des tailles fixes à la compilation.
+  var a4 [4]int           // Un tableau de 4 ints, tous initialisés à 0.
+  a3 := [...]int{3, 1, 5} // Un tableau initialisé avec une taille fixe de 3
+  // éléments, contenant les valeurs 3, 1 et 5.
+
+  // Les slices ont des tailles dynamiques. Les tableaux et slices ont chacun
+  // des avantages, mais les usages des slices sont plus communs.
+  s3 := []int{4, 5, 9}    // Comparable à a3.
+  s4 := make([]int, 4)    // Alloue un slice de 4 ints, initialisés à 0.
+  var d2 [][]float64      // Déclaration seulement, sans allocation de mémoire.
+  bs := []byte("a slice") // Conversion d'une chaîne en slice de bytes.
+
+  // Parce qu'elles sont dynamiques, les slices peuvent être jointes sur
+  // demande. Pour joindre un élément à une slice, la fonction standard append()
+  // est utilisée. Le premier argument est la slice à utiliser. Habituellement,
+  // la variable tableau est mise à jour sur place, voir ci-bas.
+  s := []int{1, 2, 3}   // Le résultat est une slice de taille 3.
+  s = append(s, 4, 5, 6)  // Ajout de 3 valeurs. La taille est de 6.
+  fmt.Println(s) // La valeur est maintenant de [1 2 3 4 5 6]
+  // Pour ajouter une autre slice, au lieu d'utiliser une liste de valeurs
+  // atomiques, il est possible de mettre en argument une référence de
+  // slice littérale de cette façon, avec des points de suspension, signifiant
+  // qu'il faut prendre les éléments de la slice et les ajouter à la slice s.
+  s = append(s, []int{7, 8, 9}...) // Le deuxième argument est une slice
+                                   // littérale.
+  fmt.Println(s)  // La slice contient [1 2 3 4 5 6 7 8 9]
+
+  p, q := learnMemory() // Déclare p, q comme étant des pointeurs de type int.
+  fmt.Println(*p, *q)   // * suit un pointeur. Ceci retourne deux ints.
+
+  // Les maps sont des tableaux associatifs de taille dynamique, comme les
+  // hash ou les types dictionnaires de certains langages.
+  m := map[string]int{"trois": 3, "quatre": 4}
+  m["un"] = 1
+
+  // Les valeurs inutilisées sont des erreurs en Go.
+  // Un tiret bas permet d'utiliser une variable, mais d'en jeter la valeur.
+  _, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a3, s4, bs
+  // L'affichage est considéré comme une utilisation de la variable.
+  fmt.Println(s, c, a4, s3, d2, m)
+
+  learnFlowControl() // De retour dans le flux.
+}
+
+// Il est possible, à l'opposée de plusieurs autres langages, à des fonctions
+// en go d'avoir des valeurs retournées avec nom.
+// Assigner un nom à un type retourné par une fonction permet de retrouver sa
+// valeur ainsi que d'utiliser le mot-clé "return" uniquement, sans plus.
+func learnNamedReturns(x, y int) (z int) {
+  z = x * y
+  return // z est implicite, car la variable a été définie précédemment.
+}
+
+// La récupération de la mémoire est automatique en Go. Le langage possède des
+// pointeurs, mais aucun pointeur arithmétique. Vous pouvez faire une erreur
+// avec un pointeur nil, mais pas en incrémentant un pointeur.
+func learnMemory() (p, q *int) {
+  // Les valeurs retournées définies p et q ont le type pointeur int.
+  p = new(int) // Fonction standard "new" alloue la mémoire.
+  // Le int alloué est initialisé à 0, p n'est plus nil.
+  s := make([]int, 20) // Alloue 20 ints en un seul bloc de mémoire.
+  s[3] = 7             // Assigne l'un des entiers.
+  r := -2              // Déclare une autre variable locale.
+  return &s[3], &r     // & retourne l'adresse d'un objet.
+}
+
+func expensiveComputation() float64 {
+  return m.Exp(10)
+}
+
+func learnFlowControl() {
+  // Bien que les "if" requiert des accolades, les parenthèses ne le sont pas.
+  if true {
+    fmt.Println("voilà!")
+  }
+  // Le formate est standardisé par la commande shell "go fmt."
+  if false {
+    // bing.
+  } else {
+    // bang.
+  }
+  // Utilisez "switch" au lieu des "if" en chaîne
+  x := 42.0
+  switch x {
+  case 0:
+  case 1:
+  case 42:
+    // Les "case" n'ont pas besoin de "break;".
+  case 43:
+    // Non-exécuté.
+  }
+  // Comme les "if", "for" n'utilise pas de parenthèses.
+  // Les variables déclarées dans "for" et "if" sont locales à leur portée.
+  for x := 0; x < 3; x++ { // ++ est une incrémentation.
+    fmt.Println("itération ", x)
+  }
+  // x == 42 ici.
+
+  // "For" est le seul type de boucle en Go, mais possède différentes formes.
+  for { // Boucle infinie
+    break    // C'est une farce
+    continue // Non atteint.
+  }
+
+  // Vous pouvez utiliser un "range" pour itérer dans un tableau, une slice, une
+  // chaîne, une map ou un channel. Les "range" retournent un canal ou deux
+  // valeurs (tableau, slice, chaîne et map).
+  for key, value := range map[string]int{"une": 1, "deux": 2, "trois": 3} {
+    // pour chaque pair dans une map, affichage de la valeur et clé
+    fmt.Printf("clé=%s, valeur=%d\n", key, value)
+  }
+
+  // À l'opposé du "for", := dans un "if" signifie la déclaration et
+  // l'assignation y en premier, et ensuite y > x
+  if y := expensiveComputation(); y > x {
+    x = y
+  }
+  // Les fonctions littérales est une fermeture (closure).
+  xBig := func() bool {
+    return x > 10000 // Réfère à la variable x déclarée en haut du "switch".
+  }
+  fmt.Println("xBig:", xBig()) // true (la valeur e^10 a été assignée à x).
+  x = 1.3e3                    // Ceci fait x == 1300
+  fmt.Println("xBig:", xBig()) // Maintenant false.
+
+  // De plus, les fonctions littérales peuvent être définies et appelée
+  // sur la même ligne, agissant comme argument de fonctions, tant que:
+  // a) la fonction littérale est appelée suite à (),
+  // b) le résultat correspond au type de l'argument.
+  fmt.Println("Ajoute + multiplie deux nombres: ",
+    func(a, b int) int {
+      return (a + b) * 2
+    }(10, 2)) // Appelé avec les arguments 10 et 2
+  // => Ajoute + double deux nombres: 24
+
+  // Quand vous en aurez besoin, vous allez l'adorer.
+  goto love
+love:
+
+  learnFunctionFactory() // func retournant func correspond à fun(3)(3).
+  learnDefer()      // Un survol de cette instruction important.
+  learnInterfaces() // Incontournable!
+}
+
+func learnFunctionFactory() {
+  // Les deux syntaxes sont identiques, bien que la seconde est plus pratique.
+  fmt.Println(sentenceFactory("été")("Une matinée d'", "agréable!"))
+
+  d := sentenceFactory("été")
+  fmt.Println(d("Une matinée d'", "agréable!"))
+  fmt.Println(d("Une soirée d'", "relaxante!"))
+}
+
+// Le décorateur est un patron de conception commun dans d'autres langages.
+// Il est possible de faire de même en Go avec des fonctions littérales
+// acceptant des arguments.
+func sentenceFactory(mystring string) func(before, after string) string {
+  return func(before, after string) string {
+    return fmt.Sprintf("%s %s %s", before, mystring, after) // nouvelle chaîne
+  }
+}
+
+func learnDefer() (ok bool) {
+  // Les déclarations différées sont exécutées avant la sortie d'une fonction.
+  defer fmt.Println("les déclarations différées s'exécutent en ordre LIFO.")
+  defer fmt.Println("\nCette ligne est affichée en premier parce que")
+  // Les déclarations différées sont utilisées fréquemment pour fermer un
+  // fichier, afin que la fonction ferme le fichier en fin d'exécution.
+  return true
+}
+
+// Défini Stringer comme étant une interface avec une méthode, String.
+type Stringer interface {
+  String() string
+}
+
+// Défini pair comme étant une structure contenant deux entiers, x et y.
+type pair struct {
+  x, y int
+}
+
+// Défini une méthode associée au type pair. Pair implémente maintenant Stringer
+func (p pair) String() string { // p s'appelle le "destinataire"
+  // Sprintf est une autre fonction publique dans le paquet fmt.
+  // La syntaxe avec point permet de faire référence aux valeurs de p.
+  return fmt.Sprintf("(%d, %d)", p.x, p.y)
+}
+
+func learnInterfaces() {
+  // La syntaxe avec accolade défini une "structure littérale". Ceci s'évalue
+  // comme étant une strucutre. La syntaxe := déclare et initialise p comme
+  // étant cette structure.
+  p := pair{3, 4}
+  fmt.Println(p.String()) // Appelle la méthode String de p, de type pair.
+  var i Stringer          // Déclare i de l'interface de type Stringer.
+  i = p                   // Valide, car pair implémente Stringer.
+  // Appelle la méthode String de i, de type Stringer. Retourne la même valeur
+  // que ci-haut.
+  fmt.Println(i.String())
+
+  // Les fonctions dans le paquet fmt appellent la méthode String, demandant
+  // aux objets d'afficher une représentation de leur structure.
+  fmt.Println(p) // Affiche la même chose que ci-haut. Println appelle la
+                 // méthode String.
+  fmt.Println(i) // Affiche la même chose que ci-haut.
+
+  learnVariadicParams("apprentissage", "génial", "ici!")
+}
+
+// Les fonctions peuvent avoir des paramètres variables.
+func learnVariadicParams(myStrings ...interface{}) {
+  // Itère chaque valeur du paramètre variable.
+  // Le tiret bas sert à ignorer l'index retourné du tableau.
+  for _, param := range myStrings {
+    fmt.Println("paramètre:", param)
+  }
+
+  // Passe une valeur variadique comme paramètre variadique.
+  fmt.Println("paramètres:", fmt.Sprintln(myStrings...))
+
+  learnErrorHandling()
+}
+
+func learnErrorHandling() {
+  // ", ok" expression utilisée pour définir si quelque chose a fonctionné ou
+  // non.
+  m := map[int]string{3: "trois", 4: "quatre"}
+  if x, ok := m[1]; !ok { // ok sera faux, car 1 n'est pas dans la map.
+    fmt.Println("inexistant")
+  } else {
+    fmt.Print(x) // x serait la valeur, si elle se trouvait dans la map.
+  }
+  // Une erreur ne retourne qu'un "ok", mais également plus d'information
+  // par rapport à un problème survenu.
+  if _, err := strconv.Atoi("non-int"); err != nil { // _ discarte la valeur
+    // retourne: 'strconv.ParseInt: parsing "non-int": invalid syntax'
+    fmt.Println(err)
+  }
+  // Nous réviserons les interfaces un peu plus tard. Maintenant,
+  learnConcurrency()
+}
+
+// c est un canal, un objet permettant de communiquer en simultané de façon
+// sécuritaire.
+func inc(i int, c chan int) {
+  c <- i + 1 // <- est l'opérateur "destination" quand un canal apparaît à
+             // gauche.
+}
+
+// Nous utiliserons inc pour incrémenter des nombres en même temps.
+func learnConcurrency() {
+  // La fonction "make" utilisée précédemment pour générer un slice. Elle
+  // alloue et initialise les slices, maps et les canaux.
+  c := make(chan int)
+  // Démarrage de trois goroutines simultanées. Les nombres seront incrémentés
+  // simultanément, peut-être en paralèle si la machine le permet et configurée
+  // correctement. Les trois utilisent le même canal.
+  go inc(0, c) // go est une déclaration démarrant une nouvelle goroutine.
+  go inc(10, c)
+  go inc(-805, c)
+  // Lis et affiche trois résultats du canal - impossible de savoir dans quel
+  // ordre!
+  fmt.Println(<-c, <-c, <-c) // Canal à droite, <- est l'opérateur de
+                             // "réception".
+
+  cs := make(chan string)       // Un autre canal, celui-ci gère des chaînes.
+  ccs := make(chan chan string) // Un canal de canaux de chaînes.
+  go func() { c <- 84 }()       // Démarre une nouvelle goroutine, pour
+                                // envoyer une valeur.
+  go func() { cs <- "wordy" }() // De nouveau, pour cs cette fois-ci.
+  // Select possède une syntaxe similaire au switch, mais chaque cas requiert
+  // une opération impliquant un canal. Il sélectionne un cas aléatoirement
+  // prêt à communiquer.
+  select {
+  case i := <-c: // La valeur reçue peut être assignée à une variable,
+    fmt.Printf("c'est un %T", i)
+  case <-cs: // ou la valeur reçue peut être discartée.
+    fmt.Println("c'est une chaîne")
+  case <-ccs: // Un canal vide, indisponible à la communication.
+    fmt.Println("ne surviendra pas.")
+  }
+  // À ce point, une valeur a été prise de c ou cs. L'une des deux goroutines
+  // démarrée plus haut a complété, la seconde restera bloquée.
+
+  learnWebProgramming() // Go permet la programmation Web.
+}
+
+// Une seule fonction du paquet http démarre un serveur Web.
+func learnWebProgramming() {
+
+  // Le premier paramètre de ListenAndServe is une adresse TCP à écouter.
+  // Le second est une interface, de type http.Handler.
+  go func() {
+    err := http.ListenAndServe(":8080", pair{})
+    fmt.Println(err) // n'ignorez pas les erreurs!
+  }()
+
+  requestServer()
+}
+
+// Fait de pair un http.Handler en implémentant sa seule méthode: ServeHTTP.
+func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+  // Répondez à une requête à l'aide de la méthode http.ResponseWriter.
+  w.Write([]byte("Vous avez appris Go en Y minutes!"))
+}
+
+func requestServer() {
+  resp, err := http.Get("http://localhost:8080")
+  fmt.Println(err)
+  defer resp.Body.Close()
+  body, err := ioutil.ReadAll(resp.Body)
+  fmt.Printf("\nLe serveur Web a dit: `%s`", string(body))
+}
+```
+
+## En savoir plus
+
+La référence Go se trouve sur [le site officiel de Go](http://golang.org/).
+Vous pourrez y suivre le tutoriel interactif et en apprendre beaucoup plus.
+
+Une lecture de la documentation du langage est grandement conseillée. C'est
+facile à lire et très court (comparé aux autres langages).
+
+Vous pouvez exécuter modifier le code sur [Go playground](https://play.golang.org/p/tnWMjr16Mm). Essayez de le modifier et de l'exécuter à partir de votre navigateur! Prennez en note que vous pouvez utiliser [https://play.golang.org](https://play.golang.org) comme un [REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop) pour tester et coder dans votre navigateur, sans même avoir à installer Go.
+
+Sur la liste de lecteur des étudiants de Go se trouve le [code source de la
+librairie standard](http://golang.org/src/pkg/). Bien documentée, elle démontre
+le meilleur de la clarté de Go, le style ainsi que ses expressions. Sinon, vous
+pouvez cliquer sur le nom d'une fonction dans [la
+documentation](http://golang.org/pkg/) et le code source apparaît!
+
+Une autre excellente ressource pour apprendre est [Go par l'exemple](https://gobyexample.com/).
-- 
cgit v1.2.3


From 290c0956d00ddfe23a8cad9ce17f2eaed3a099c0 Mon Sep 17 00:00:00 2001
From: Jean-Philippe Monette <contact@jpmonette.net>
Date: Tue, 17 Mar 2015 20:29:01 +0000
Subject: updating translators information

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

(limited to 'fr-fr')

diff --git a/fr-fr/go-fr.html.markdown b/fr-fr/go-fr.html.markdown
index 1d2b656b..31e1e92b 100644
--- a/fr-fr/go-fr.html.markdown
+++ b/fr-fr/go-fr.html.markdown
@@ -2,7 +2,7 @@
 name: Go
 category: language
 language: Go
-filename: learngo.go
+filename: learngo-fr.go
 contributors:
     - ["Sonia Keys", "https://github.com/soniakeys"]
     - ["Christopher Bess", "https://github.com/cbess"]
@@ -10,7 +10,9 @@ contributors:
     - ["Quint Guvernator", "https://github.com/qguv"]
     - ["Jose Donizetti", "https://github.com/josedonizetti"]
     - ["Alexej Friesen", "https://github.com/heyalexej"]
+translators:
     - ["Jean-Philippe Monette", "http://blogue.jpmonette.net/"]
+lang: fr-fr
 ---
 
 Go a été créé dans l'optique de déveloper de façcon efficace. Ce n'est pas la
-- 
cgit v1.2.3


From 9922336a9df1359b57695bd5df538d98b8ab2dc0 Mon Sep 17 00:00:00 2001
From: Jean-Philippe Monette <contact@jpmonette.net>
Date: Tue, 17 Mar 2015 23:17:50 +0000
Subject: Updating French translation

Thanks vendethiel for all the suggestions!
---
 fr-fr/go-fr.html.markdown | 140 ++++++++++++++++++++++++----------------------
 1 file changed, 73 insertions(+), 67 deletions(-)

(limited to 'fr-fr')

diff --git a/fr-fr/go-fr.html.markdown b/fr-fr/go-fr.html.markdown
index 31e1e92b..2ff5902f 100644
--- a/fr-fr/go-fr.html.markdown
+++ b/fr-fr/go-fr.html.markdown
@@ -2,7 +2,7 @@
 name: Go
 category: language
 language: Go
-filename: learngo-fr.go
+filename: learngo.go
 contributors:
     - ["Sonia Keys", "https://github.com/soniakeys"]
     - ["Christopher Bess", "https://github.com/cbess"]
@@ -10,21 +10,19 @@ contributors:
     - ["Quint Guvernator", "https://github.com/qguv"]
     - ["Jose Donizetti", "https://github.com/josedonizetti"]
     - ["Alexej Friesen", "https://github.com/heyalexej"]
-translators:
     - ["Jean-Philippe Monette", "http://blogue.jpmonette.net/"]
-lang: fr-fr
 ---
 
-Go a été créé dans l'optique de déveloper de façcon efficace. Ce n'est pas la
-dernière tendance en ce qui au développement, mais c'est la nouvelle façon de
-régler des défis réels de façcon rapide.
+Go a été créé dans l'optique de développer de façon efficace. Ce n'est pas la
+dernière tendance en ce qui est au développement, mais c'est la nouvelle façon
+de régler des défis réels de façon rapide.
 
 Le langage possède des concepts familiers à la programmation impérative avec
 typage. Il est rapide à compiler et exécuter, ajoute une concurrence facile à
-comprendre pour les processeurs multi coeurs d'aujourd'hui et apporte des
+comprendre, pour les processeurs multi coeurs d'aujourd'hui et apporte des
 fonctionnalités facilitant le développement à grande échelle.
 
-Développer avec Go, c'est bénéficier d'une riche librairie standard et d'une
+Développer avec Go, c'est bénéficier d'une riche bibliothèque standard et d'une
 communauté active.
 
 ```go
@@ -34,22 +32,22 @@ communauté active.
 
 // Un paquet débute avec une clause "package"
 // "Main" est un nom spécial déclarant un paquet de type exécutable plutôt
-// qu'une librairie
+// qu'une bibliothèque
 package main
 
 // "Import" déclare les paquets référencés dans ce fichier.
 import (
-  "fmt"       // Un paquet dans la librairie standard.
+  "fmt"       // Un paquet dans la bibliothèque standard.
   "io/ioutil" // Implémente des fonctions utilitaires I/O.
-  m "math"    // Librairie mathématique utilisant un alias local "m".
+  m "math"    // Bibliothèque mathématique utilisant un alias local "m".
   "net/http"  // Un serveur Web!
-  "strconv"   // Librairie pour convertir les chaînes de caractères.
+  "strconv"   // Bibliothèque pour convertir les chaînes de caractères.
 )
 
 // Une définition de fonction. La fonction "main" est spéciale - c'est le point
-// d'entrée du binaire. Celle-ci est encapsulée par des accolades.
+// d'entrée du binaire.
 func main() {
-  // Println retourne une ligne à stdout.
+  // Println retournera la valeur à la console.
   // Associez la fonction avec son paquet respectif, fmt.
   fmt.Println("Hello world!")
 
@@ -78,7 +76,7 @@ func learnMultiple(x, y int) (sum, prod int) {
 
 // Quelques types inclus et littéraux.
 func learnTypes() {
-  // Déclaration courte produit généralement le type désiré.
+  // Une déclaration courte infère généralement le type désiré.
   str := "Learn Go!" // Type string.
 
   s2 := `Une chaîne de caractères peut contenir des
@@ -89,7 +87,7 @@ sauts de ligne.` // Chaîne de caractère.
            // unicode.
 
   f := 3.14195 // float64, un nombre flottant IEEE-754 de 64-bit.
-  c := 3 + 4i  // complex128, représenté à l'interne par deux float64.
+  c := 3 + 4i  // complex128, considéré comme deux float64 par le compilateur.
 
   // Syntaxe "var" avec une valeur d'initialisation.
   var u uint = 7 // Non signé, mais la taille dépend selon l'entier.
@@ -98,13 +96,13 @@ sauts de ligne.` // Chaîne de caractère.
   // Conversion avec syntaxe courte.
   n := byte('\n') // byte est un alias du type uint8.
 
-  // Les tableaux ont des tailles fixes à la compilation.
+  // Les tableaux ont une taille fixe déclarée à la compilation.
   var a4 [4]int           // Un tableau de 4 ints, tous initialisés à 0.
   a3 := [...]int{3, 1, 5} // Un tableau initialisé avec une taille fixe de 3
   // éléments, contenant les valeurs 3, 1 et 5.
 
   // Les slices ont des tailles dynamiques. Les tableaux et slices ont chacun
-  // des avantages, mais les usages des slices sont plus communs.
+  // des avantages, mais les cas d'utilisation des slices sont plus fréquents.
   s3 := []int{4, 5, 9}    // Comparable à a3.
   s4 := make([]int, 4)    // Alloue un slice de 4 ints, initialisés à 0.
   var d2 [][]float64      // Déclaration seulement, sans allocation de mémoire.
@@ -114,13 +112,13 @@ sauts de ligne.` // Chaîne de caractère.
   // demande. Pour joindre un élément à une slice, la fonction standard append()
   // est utilisée. Le premier argument est la slice à utiliser. Habituellement,
   // la variable tableau est mise à jour sur place, voir ci-bas.
-  s := []int{1, 2, 3}   // Le résultat est une slice de taille 3.
+  s := []int{1, 2, 3}     // Le résultat est une slice de taille 3.
   s = append(s, 4, 5, 6)  // Ajout de 3 valeurs. La taille est de 6.
-  fmt.Println(s) // La valeur est maintenant de [1 2 3 4 5 6]
-  // Pour ajouter une autre slice, au lieu d'utiliser une liste de valeurs
+  fmt.Println(s)          // La valeur est de [1 2 3 4 5 6]
+
+  // Pour ajouter une slice à une autre, au lieu d'utiliser une liste de valeurs
   // atomiques, il est possible de mettre en argument une référence de
-  // slice littérale de cette façon, avec des points de suspension, signifiant
-  // qu'il faut prendre les éléments de la slice et les ajouter à la slice s.
+  // slice littérale grâce aux points de suspension.
   s = append(s, []int{7, 8, 9}...) // Le deuxième argument est une slice
                                    // littérale.
   fmt.Println(s)  // La slice contient [1 2 3 4 5 6 7 8 9]
@@ -133,17 +131,19 @@ sauts de ligne.` // Chaîne de caractère.
   m := map[string]int{"trois": 3, "quatre": 4}
   m["un"] = 1
 
-  // Les valeurs inutilisées sont des erreurs en Go.
-  // Un tiret bas permet d'utiliser une variable, mais d'en jeter la valeur.
+  // Les valeurs inutilisées sont considérées comme des erreurs en Go.
+  // Un tiret bas permet d'ignorer une valeur inutilisée, évitant une erreur.
   _, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a3, s4, bs
-  // L'affichage est considéré comme une utilisation de la variable.
+
+  // Cependant, son affichage en console est considéré comme une utilisation,
+  // ce qui ne sera pas considéré comme une erreur à la compilation.
   fmt.Println(s, c, a4, s3, d2, m)
 
   learnFlowControl() // De retour dans le flux.
 }
 
-// Il est possible, à l'opposée de plusieurs autres langages, à des fonctions
-// en go d'avoir des valeurs retournées avec nom.
+// Il est possible, à l'opposé de plusieurs autres langages, de retourner des
+// variables par leur nom à partir de fonctions.
 // Assigner un nom à un type retourné par une fonction permet de retrouver sa
 // valeur ainsi que d'utiliser le mot-clé "return" uniquement, sans plus.
 func learnNamedReturns(x, y int) (z int) {
@@ -152,10 +152,11 @@ func learnNamedReturns(x, y int) (z int) {
 }
 
 // La récupération de la mémoire est automatique en Go. Le langage possède des
-// pointeurs, mais aucun pointeur arithmétique. Vous pouvez faire une erreur
-// avec un pointeur nil, mais pas en incrémentant un pointeur.
+// pointeurs, mais aucune arithmétique des pointeurs (*(a + b) en C). Vous
+// pouvez produire une erreur avec un pointeur nil, mais pas en incrémentant un
+// pointeur.
 func learnMemory() (p, q *int) {
-  // Les valeurs retournées définies p et q ont le type pointeur int.
+  // Les valeurs retournées p et q auront le type pointeur int.
   p = new(int) // Fonction standard "new" alloue la mémoire.
   // Le int alloué est initialisé à 0, p n'est plus nil.
   s := make([]int, 20) // Alloue 20 ints en un seul bloc de mémoire.
@@ -169,11 +170,12 @@ func expensiveComputation() float64 {
 }
 
 func learnFlowControl() {
-  // Bien que les "if" requiert des accolades, les parenthèses ne le sont pas.
+  // Bien que les "if" requièrent des accolades, les parenthèses ne sont pas
+  // nécessaires pour contenir le test booléen.
   if true {
     fmt.Println("voilà!")
   }
-  // Le formate est standardisé par la commande shell "go fmt."
+  // Le formatage du code est standardisé par la commande shell "go fmt."
   if false {
     // bing.
   } else {
@@ -189,8 +191,9 @@ func learnFlowControl() {
   case 43:
     // Non-exécuté.
   }
-  // Comme les "if", "for" n'utilise pas de parenthèses.
-  // Les variables déclarées dans "for" et "if" sont locales à leur portée.
+  // Comme les "if", les "for" n'utilisent pas de parenthèses.
+  // Les variables déclarées dans les "for" et les "if" sont locales à leur
+  // portée.
   for x := 0; x < 3; x++ { // ++ est une incrémentation.
     fmt.Println("itération ", x)
   }
@@ -202,8 +205,8 @@ func learnFlowControl() {
     continue // Non atteint.
   }
 
-  // Vous pouvez utiliser un "range" pour itérer dans un tableau, une slice, une
-  // chaîne, une map ou un channel. Les "range" retournent un canal ou deux
+  // Vous pouvez utiliser une "range" pour itérer dans un tableau, une slice, une
+  // chaîne, une map ou un canal. Les "range" retournent un canal ou deux
   // valeurs (tableau, slice, chaîne et map).
   for key, value := range map[string]int{"une": 1, "deux": 2, "trois": 3} {
     // pour chaque pair dans une map, affichage de la valeur et clé
@@ -215,35 +218,35 @@ func learnFlowControl() {
   if y := expensiveComputation(); y > x {
     x = y
   }
-  // Les fonctions littérales est une fermeture (closure).
+  // Les fonctions littérales sont des fermetures.
   xBig := func() bool {
-    return x > 10000 // Réfère à la variable x déclarée en haut du "switch".
+    return x > 10000
   }
   fmt.Println("xBig:", xBig()) // true (la valeur e^10 a été assignée à x).
   x = 1.3e3                    // Ceci fait x == 1300
   fmt.Println("xBig:", xBig()) // Maintenant false.
 
-  // De plus, les fonctions littérales peuvent être définies et appelée
-  // sur la même ligne, agissant comme argument de fonctions, tant que:
+  // De plus, les fonctions littérales peuvent être définies et appelées
+  // sur la même ligne, agissant comme argument à cette fonction, tant que:
   // a) la fonction littérale est appelée suite à (),
   // b) le résultat correspond au type de l'argument.
-  fmt.Println("Ajoute + multiplie deux nombres: ",
+  fmt.Println("Ajoute + multiplie deux nombres : ",
     func(a, b int) int {
       return (a + b) * 2
-    }(10, 2)) // Appelé avec les arguments 10 et 2
-  // => Ajoute + double deux nombres: 24
+    }(10, 2)) // Appelle la fonction avec les arguments 10 et 2
+  // => Ajoute + double deux nombres : 24
 
   // Quand vous en aurez besoin, vous allez l'adorer.
   goto love
 love:
 
-  learnFunctionFactory() // func retournant func correspond à fun(3)(3).
-  learnDefer()      // Un survol de cette instruction important.
-  learnInterfaces() // Incontournable!
+  learnFunctionFactory() // func retournant func correspondant à fun(3)(3).
+  learnDefer()           // Un survol de cette instruction importante.
+  learnInterfaces()      // Incontournable !
 }
 
 func learnFunctionFactory() {
-  // Les deux syntaxes sont identiques, bien que la seconde est plus pratique.
+  // Les deux syntaxes sont identiques, bien que la seconde soit plus pratique.
   fmt.Println(sentenceFactory("été")("Une matinée d'", "agréable!"))
 
   d := sentenceFactory("été")
@@ -287,12 +290,12 @@ func (p pair) String() string { // p s'appelle le "destinataire"
 }
 
 func learnInterfaces() {
-  // La syntaxe avec accolade défini une "structure littérale". Ceci s'évalue
-  // comme étant une strucutre. La syntaxe := déclare et initialise p comme
-  // étant cette structure.
+  // La syntaxe avec accolade défini une "structure littérale". Celle-ci
+  // s'évalue comme étant une structure. La syntaxe := déclare et initialise p
+  // comme étant une instance.
   p := pair{3, 4}
   fmt.Println(p.String()) // Appelle la méthode String de p, de type pair.
-  var i Stringer          // Déclare i de l'interface de type Stringer.
+  var i Stringer          // Déclare i instance de l'interface Stringer.
   i = p                   // Valide, car pair implémente Stringer.
   // Appelle la méthode String de i, de type Stringer. Retourne la même valeur
   // que ci-haut.
@@ -307,9 +310,11 @@ func learnInterfaces() {
   learnVariadicParams("apprentissage", "génial", "ici!")
 }
 
-// Les fonctions peuvent avoir des paramètres variables.
+// Les fonctions peuvent être définie de façon à accepter un ou plusieurs
+// paramètres grâce aux points de suspension, offrant une flexibilité lors de
+// son appel.
 func learnVariadicParams(myStrings ...interface{}) {
-  // Itère chaque valeur du paramètre variable.
+  // Itère chaque paramètre dans la range.
   // Le tiret bas sert à ignorer l'index retourné du tableau.
   for _, param := range myStrings {
     fmt.Println("paramètre:", param)
@@ -322,8 +327,8 @@ func learnVariadicParams(myStrings ...interface{}) {
 }
 
 func learnErrorHandling() {
-  // ", ok" expression utilisée pour définir si quelque chose a fonctionné ou
-  // non.
+  // ", ok" idiome utilisée pour définir si l'opération s'est déroulée avec
+  // succès ou non
   m := map[int]string{3: "trois", 4: "quatre"}
   if x, ok := m[1]; !ok { // ok sera faux, car 1 n'est pas dans la map.
     fmt.Println("inexistant")
@@ -336,14 +341,14 @@ func learnErrorHandling() {
     // retourne: 'strconv.ParseInt: parsing "non-int": invalid syntax'
     fmt.Println(err)
   }
-  // Nous réviserons les interfaces un peu plus tard. Maintenant,
+  // Nous réviserons les interfaces un peu plus tard. Pour l'instant,
   learnConcurrency()
 }
 
 // c est un canal, un objet permettant de communiquer en simultané de façon
-// sécuritaire.
+// sécurisée.
 func inc(i int, c chan int) {
-  c <- i + 1 // <- est l'opérateur "destination" quand un canal apparaît à
+  c <- i + 1 // <- est l'opérateur "envoi" quand un canal apparaît à
              // gauche.
 }
 
@@ -355,11 +360,11 @@ func learnConcurrency() {
   // Démarrage de trois goroutines simultanées. Les nombres seront incrémentés
   // simultanément, peut-être en paralèle si la machine le permet et configurée
   // correctement. Les trois utilisent le même canal.
-  go inc(0, c) // go est une déclaration démarrant une nouvelle goroutine.
+  go inc(0, c) // go est une instruction démarrant une nouvelle goroutine.
   go inc(10, c)
   go inc(-805, c)
   // Lis et affiche trois résultats du canal - impossible de savoir dans quel
-  // ordre!
+  // ordre !
   fmt.Println(<-c, <-c, <-c) // Canal à droite, <- est l'opérateur de
                              // "réception".
 
@@ -374,13 +379,13 @@ func learnConcurrency() {
   select {
   case i := <-c: // La valeur reçue peut être assignée à une variable,
     fmt.Printf("c'est un %T", i)
-  case <-cs: // ou la valeur reçue peut être discartée.
+  case <-cs: // ou la valeur reçue peut être ignorée.
     fmt.Println("c'est une chaîne")
   case <-ccs: // Un canal vide, indisponible à la communication.
     fmt.Println("ne surviendra pas.")
   }
   // À ce point, une valeur a été prise de c ou cs. L'une des deux goroutines
-  // démarrée plus haut a complété, la seconde restera bloquée.
+  // démarrée plus haut a complétée, la seconde restera bloquée.
 
   learnWebProgramming() // Go permet la programmation Web.
 }
@@ -388,17 +393,18 @@ func learnConcurrency() {
 // Une seule fonction du paquet http démarre un serveur Web.
 func learnWebProgramming() {
 
-  // Le premier paramètre de ListenAndServe is une adresse TCP à écouter.
+  // Le premier paramètre de ListenAndServe est une adresse TCP à écouter.
   // Le second est une interface, de type http.Handler.
   go func() {
     err := http.ListenAndServe(":8080", pair{})
-    fmt.Println(err) // n'ignorez pas les erreurs!
+    fmt.Println(err) // n'ignorez pas les erreurs !
   }()
 
   requestServer()
 }
 
-// Fait de pair un http.Handler en implémentant sa seule méthode: ServeHTTP.
+// Implémente la méthode ServeHTTP de http.Handler à pair, la rendant compatible
+// avec les opérations utilisant l'interface http.Handler.
 func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
   // Répondez à une requête à l'aide de la méthode http.ResponseWriter.
   w.Write([]byte("Vous avez appris Go en Y minutes!"))
@@ -421,7 +427,7 @@ Vous pourrez y suivre le tutoriel interactif et en apprendre beaucoup plus.
 Une lecture de la documentation du langage est grandement conseillée. C'est
 facile à lire et très court (comparé aux autres langages).
 
-Vous pouvez exécuter modifier le code sur [Go playground](https://play.golang.org/p/tnWMjr16Mm). Essayez de le modifier et de l'exécuter à partir de votre navigateur! Prennez en note que vous pouvez utiliser [https://play.golang.org](https://play.golang.org) comme un [REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop) pour tester et coder dans votre navigateur, sans même avoir à installer Go.
+Vous pouvez exécuter et modifier le code sur [Go playground](https://play.golang.org/p/tnWMjr16Mm). Essayez de le modifier et de l'exécuter à partir de votre navigateur! Prennez en note que vous pouvez utiliser [https://play.golang.org](https://play.golang.org) comme un [REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop) pour tester et coder dans votre navigateur, sans même avoir à installer Go.
 
 Sur la liste de lecteur des étudiants de Go se trouve le [code source de la
 librairie standard](http://golang.org/src/pkg/). Bien documentée, elle démontre
-- 
cgit v1.2.3


From 5e79da614c98070cfbf908af1c7be9b6abf3b2ed Mon Sep 17 00:00:00 2001
From: Adam Bard <github@adambard.com>
Date: Tue, 31 Mar 2015 15:46:34 -0700
Subject: Added lang tag to go-fr

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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


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

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

(limited to 'fr-fr')

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