Revert "Adding french translation of Haskell"

This reverts commit f400089013d99030e520c20735198273aed17b8e.

1 files changed, 0 insertions, 428 deletions

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/).