Applying corrections

fr-fr/haskell.html.markdown

@@ -2,7 +2,9 @@
 language: haskell
 contributors:
     - ["Adit Bhargava", "http://adit.io"]
+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
@@ -53,7 +55,7 @@ not False -- True
 -- 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,10 +65,10 @@ 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]
@@ -74,16 +76,15 @@ not False -- True
 -- 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.
+-- le faire à moins qu'il ne le doive.
 
 -- Adjoindre deux listes 
 [1..5] ++ [6..10]
@@ -138,14 +139,14 @@ add 1 2 -- 3
 (//) 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)
@@ -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.
 
@@ -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 :
 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
@@ -404,11 +405,11 @@ let foo = 5
 >: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!
+Ami
 Salut, Ami !
 
 ```