Apprendre X en Y minutes

-- Un commentaire en une ligne commence avec deux tirets.
{- Un commentaire sur plusieurs lignes peut être contenu dans
un bloc de cette façon.
-}

----------------------------------------------------
-- 1. Types de données primitifs et opérateurs
----------------------------------------------------

-- Vous avez les nombres
3 -- 3

-- Les maths sont comme vous vous y attendez
1 + 1 -- 2
8 - 1 -- 7
10 * 2 -- 20
35 / 5 -- 7.0

-- La division n'est pas entière par défaut
35 / 4 -- 8.75

-- division entière
35 `div` 4 -- 8

-- Les booléens sont primitifs
True
False

-- Opérations avec les booléens
not True -- False
not False -- True
1 == 1 -- True
1 /= 1 -- False
1 < 10 -- True

-- Dans les exemples plus hauts, `not` est une fonction qui prend une valeur.
-- Haskell n'a pas besoin de parenthèses pour appeler une fonction... tous
-- les arguments sont juste listés après la fonction. Le schéma général est
-- donc :
-- func arg1 arg2 arg3...
-- Voyez la section sur les fonctions pour savoir comment écrire les vôtres.

-- Caractères et chaînes de caractère
"Ceci est une chaîne de caractère."
'a' -- caractère
'Vous ne pouvez pas utiliser des apostrophes pour les chaînes de caractère.' -- erreur !

-- Les chaînes peuvent être concaténées
"Hello " ++ "world!" -- "Hello world!"

-- Une chaîne de caractère est *réellement* une liste
"Ceci est une chaîne." !! 0 -- 'C'


----------------------------------------------------
-- 2. Listes et tuples
----------------------------------------------------

-- Tous les éléments d'une liste doit avoir le même type.
-- les deux lignes suivantes sont semblables
[1, 2, 3, 4, 5]
[1..5]

-- Il y a aussi des listes infinies en Haskell !
[1..] -- une liste de tous les nombres naturels

-- Les listes infinies fonctionnent parce que Haskell est « paresseux »:
-- ça veut dire qu'il n'évalue que ce qui a besoin de l'être. Vous pouvez
-- donc vous demander le 1000e élément de votre liste et il vous le donnera :

[1..] !! 999 -- 1000

-- Et là, Haskell a évalué les éléments 1 à 1000 de la liste... mais le reste
-- de cette liste « infinie » n'existe pas encore ! En fait, Haskell ne va jamais 
-- le faire à moins qu'il ne le doive.

-- Adjoindre deux listes 
[1..5] ++ [6..10]

-- ajouter au début de la liste
0:[1..5] -- [0, 1, 2, 3, 4, 5]

-- l'indice d'une liste
[0..] !! 5 -- 5

-- d'autres opérations sur les listes
head [1..5] -- 1
tail [1..5] -- [2, 3, 4, 5]
init [1..5] -- [1, 2, 3, 4]
last [1..5] -- 5

--liste en compréhension
[x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10]

--avec un conditionnel
[x*2 | x <- [1..5], x*2 > 4] -- [6, 8, 10]

-- Chaque élément d'un tuple peut être d'un type différent, mais un
-- tuple a une longueur fixée.
-- Un tuple :
("haskell", 1)

-- accéder aux éléments d'un tuple
fst ("haskell", 1) -- "haskell"
snd ("haskell", 1) -- 1

----------------------------------------------------
-- 3. Functions
----------------------------------------------------
-- Une simple fonction qui prend deux paramètres
add a b = a + b

-- Notez que si vous utilisez ghci (l'interpréteur Haskell)
-- vous devrez utiliser `let`. Par exemple :
-- let add a b = a + b

-- Utiliser une fonction
add 1 2 -- 3

-- Vous pouvez également mettre le nom de la fonction entre les
-- deux arguments avec des accents graves :
1 `add` 2 -- 3

-- Vous pouvez également définir des fonctions qui n'ont pas de
-- lettres ! Ça vous laisse créer vos propres opérateurs ! Voilà 
-- un opérateur qui fait une division entière :
(//) a b = a `div` b
35 // 4 -- 8

-- Gardes : Une façon de gérer la valeur de vos arguments en amont
fib x
  | x < 2 = x
  | otherwise = fib (x - 1) + fib (x - 2)

-- Le filtrage par motif est similaire. Là, on a donné trois 
-- définitions différentes de `fib`. Haskell appellera automatiquement
-- la première fonction qui correspond au motif de la valeur.
fib 1 = 1
fib 2 = 2
fib x = fib (x - 1) + fib (x - 2)

-- Filtrage par motif sur un tuple.
foo (x, y) = (x + 1, y + 2)

-- Filtrage par motif sur des listes. Ici, `x` est le premier
-- élément de la liste, et `xs` le reste. On peut écrire notre
-- propre fonction `map` :
myMap func [] = []
myMap func (x:xs) = func x:(myMap func xs)

-- Les fonctions anonymes sont créées avec des barres obliques 
-- inverses, suivies de tous les arguments.
myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7]

-- Une utilisation de fold (appelée `inject` dans quelques autres
-- langages) avec comme paramètre une fonction anonyme.
-- `foldl1` veut dire fold left -- soit littéralement pli gauche --
-- et utilise la première valeur de la liste comme accumulateur.
foldl1 (\acc x -> acc + x) [1..5] -- 15

----------------------------------------------------
-- 4. Plus de fonctions
----------------------------------------------------

-- curryfication : si vous n'appliquez pas tous les arguments à une
-- fonction, elle devient « curryfiée ». Ça veut dire qu'elle retourne
-- une fonction qui prend le reste des arguments.

add a b = a + b
foo = add 10 -- foo est une fonction qui prend un nombre et y ajoute 10
foo 5 -- 15

-- Une autre façon de l'écrire
foo = (+10)
foo 5 -- 15

-- Composition de fonctions
-- la fonction (.) enchaîne deux fonctions.
-- Par exemple, on a foo qui est une fonction qui prend une valeur, y ajoute
-- 10 et multiplie ce résultat par 5, et ensuite retourne la valeur finale.
foo = (*5) . (+10)

-- (5 + 10) * 5 = 75
foo 5 -- 75

-- fixation de priorité
-- Haskell a une autre fonction appelée `$`. Elle peut changer la priorité
-- de sorte que tout ce qu'il y a à sa gauche est calculé d'abord et ensuite 
-- appliqué à tout ce qu'il y a à droite. Vous pouvez utiliser `.` et `$` 
-- pour vous débarrasser de beaucoup de parenthèses :

-- avant
(even (fib 7)) -- False

-- ensuite
even . fib $ 7 -- False

----------------------------------------------------
-- 5. Signature de type
----------------------------------------------------

-- Haskell a un système de types très strict : par exemple, tout a un type.

-- Quelques types simples :
5 :: Integer
"hello" :: String
True :: Bool

-- Les fonctions ont également des types.
-- `not` prend un booléen et retourne un booléen.
-- not :: Bool -> Bool

-- Voilà une fonction qui prend deux paramètres.
-- add :: Integer -> Integer -> Integer

-- Quand vous définissez une valeur (souvenez-vous, tout est valeur en
-- Haskell), une bonne pratique est d'écrire son type explicitement
double :: Integer -> Integer
double x = x * 2

----------------------------------------------------
-- 6. Flux de contrôle et structures conditionnelles
----------------------------------------------------

-- structure conditionnelle if
haskell = if 1 == 1 then "awesome" else "awful" -- haskell = "awesome"

-- les structures if peuvent être écrites sur plusieurs lignes
haskell = if 1 == 1
            then "awesome"
            else "awful"

-- les structures case : voilà comment vous pourriez analyser les arguments de 
-- ligne de commande
case args of
  "help" -> printHelp
  "start" -> startProgram
  _ -> putStrLn "bad args"


-- Haskell n'a pas de boucles parce qu'il utilise la récursion.
-- `map` applique une fonction sur chaque élément d'une liste

map (*2) [1..5] -- [2, 4, 6, 8, 10]

-- vous pouvez créer une fonction `for` en utilisant `map`
for array func = map func array

-- et l'utiliser
for [0..5] $ \i -> show i

-- nous aurions pu l'écrire également ainsi
for [0..5] show

-- vous pouvez utiliser foldl et foldr pour 
-- réduire une liste
-- foldl <fonction> <valeur initiale> <liste>
foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43

-- C'est donc la même chose que 
(2 * (2 * (2 * 4 + 1) + 2) + 3)

-- foldl évalue de gauche à droite, foldr
-- de droite à gauche
foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16

-- Et c'est équivalent à
(2 * 3 + (2 * 2 + (2 * 1 + 4)))

----------------------------------------------------
-- 7. Types de données
----------------------------------------------------

-- Vous pouvez écrire vos propres types de données en Haskell

data Couleur = Rouge | Bleu | Vert

-- Et maintenant l'utiliser dans une fonction


say :: Couleur -> String
say Rouge = "Vous êtes Rouge !"
say Bleu = "Vous êtes Bleu !"
say Vert =  "Vous êtes Vert !"

-- Vos types peuvent également avoir des paramètres

data Maybe a = Nothing | Just a

-- Tous les exemples ci-dessous sont issus du type Maybe
Just "hello"    -- of type `Maybe String`
Just 1          -- of type `Maybe Int`
Nothing         -- of type `Maybe a` for any `a`

----------------------------------------------------
-- 8. Haskell IO
----------------------------------------------------

-- Tandis que l'IO ne peut pas être totalement expliqué pleinement
-- sans que les monades ne le soient, il n'est pas difficile
-- d'expliquer suffisamment pour commencer.

-- Quand un programme en Haskell est exécuté, la fonction `main`
-- est appelée. Il doit retourner une valeur de type `IO ()`.
-- Par exemple :

main :: IO ()
main = putStrLn $ "Bonjour, le ciel ! " ++ (say Blue) 
-- putStrLn a comme type String -> IO ()

-- La façon la plus simple pour faire de l'IO est de faire un programme 
-- fonction de String vers String. La fonction
--    interact :: (String -> String) -> IO ()
-- prend un texte, applique une fonction et affiche le résultat.

countLines :: String -> String
countLines = show . length . lines

main' = interact countLines

-- Vous pouvez considérer qu'une valeur de type `IO ()` représente
-- une séquence d'actions que l'ordinateur exécute, un peu comme 
-- dans un langage impératif. On peut utiliser la structure `do` 
-- pour enchaîner des actions. Par exemple :

sayHello :: IO ()
sayHello = do 
   putStrLn "Quel est ton nom ?"
   name <- getLine -- prend une ligne et assigne sa valeur à `name`
   putStrLn $ "Salut, " ++ name
   
-- Exercice : écrire votre propre version d'`interact` qui ne fait 
--           que de lire une ligne d'entrée.
   
-- Le code de `sayHello` ne sera jamais exécuté, cependant. La seule
-- action qui sera exécutée est la valeur de `main`.
-- Pour lancer `sayHello`, commentez l'ancienne définition de `main`
-- et remplacez-le par :
--   main = sayHello

-- Essaions de mieux comprendre comment la fonction `getLine` que 
-- nous venons d'utiliser. Son type est :
--    getLine :: IO String
-- vous pouvez considérer le type `IO a` comme un programme que
-- le programme va générer comme une valeur de type `a` quand
-- il sera exécuté. On peut l'enregistrer et la réutiliser en
-- utilisant `<-`. On peut aussi faire nos propres actions
-- de type `IO String` :

action :: IO String
action = do
   putStrLn "C'est une ligne. Heu"
   input1 <- getLine 
   input2 <- getLine
   -- Le type de la structure `do` est celui de sa dernière ligne.
   -- `return` n'est pas un mot clef, mais simplement une fonction.
   return (input1 ++ "\n" ++ input2) -- return :: String -> IO String

-- On peut maintenant l'utiliser comme on a utilisé `getLine`
-- tout à l'heure

main'' = do
    putStrLn "Je vais afficher deux lignes !"
    result <- action 
    putStrLn result
    putStrLn "C'était tout !"

-- Le type `IO` est un exemple de « monade ». La façon dont Haskell utilise
-- une monade pour faire de l'IO lui permet d'être purement fonctionnel. N'importe
-- quelle fonction qui interagit avec le « monde extérieur » (c'est à dire fait de l'IO)
-- devient marqué comme `IO` dans la signature de son type. Ça nous montre
-- quelles fonctions sont « pures » (n'interagissent pas avec le monde extérieur
-- ou ne changent pas d'état) et quelles fonctions ne le sont pas.

-- C'est une fonctionnalité très puissante, car il est facile d'exécuter 
-- des fonctions pures simultanément, et donc la concurrence en Haskell
-- est très facile.


----------------------------------------------------
-- 9. Le REPL de Haskell
----------------------------------------------------

-- Lancer le REPL en tapant `ghci`.
-- Vous pouvez maintenant taper du code Haskell.
-- Toutes les nouvelles valeurs peuvent être crées 
-- avec `let` :

let foo = 5

-- Vous pouvez voir le type de n'importe quelle valeur avec `:t` :

>:t foo
foo :: Integer

-- Vous pouvez également lancer des actions de type `IO ()`

> sayHello
Quel est ton nom ?
Ami
Salut, Ami !

qsort [] = []
qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater
    where lesser  = filter (< p) xs
          greater = filter (>= p) xs