content: -- Fonctions et Opérateurs
  nom::type
  nom arguments = expression
  
  -- Exercice 1
  
  1. t == 'T' || y == "t"
  -- t est de type char
  -- y est de type String
  -- expression de type bool
  
  2. if x == 3.25 then [] else 3:[]
  -- x est un float
  -- expression de type liste
  
  3. if y then (2,y) else (3.5,y)
  -- y est de type bool
  -- expression de type tuple(float, bool)
  
  4. \x -> x * 19
  -- expression est un number (super-type de int et float)
  
  5. \x -> x ++ " et " ++ x
  -- x paramètre de type String
  -- expression de type String
  
  6. \x -> sin x - 3
  -- x paramètre de type float
  -- expression de type float
  
  7. \x -> x 6 - 1 
  -- x::Int->Int
  -- expression est de type (Int->Int)->Int
  
  8. \(x,y) -> x*x + if y then 12 else 11
  -- x paramètre de type Num
  -- y paramètre de type Bool
  -- (x,y) : tuple de (Num,Bool)
  -- Expression de type (Num,Bool)->Int
  
  9. \x -> \y -> x * 12.5 * y
  -- x est un Num
  -- y est un Num
  -- expression de type Num->Num->Float
  
  10. \x -> \y -> x && y == 33
  -- x est des Bool
  -- y est un Int
  -- expression de type Bool->Int->Bool
  
  11. \x -> \y -> x:"Puis":y
  -- x est un String
  -- y est liste[String]
  -- expression totale String->liste[String]->liste[String]
  
  12. \x (y,z) -> (x-y,x:z)
  -- x est de type Num
  -- tuple(y:Num, z:[Num])
  -- Expression de type Num->(Num, [Num])->(Num, [Num])
  
  13. \x y -> y:tail x
  -- x est de type [a]
  -- y est de type a
  -- Expression de type liste de a : [a]->a->[a]
  
  14. \x y -> x y + 1
  -- Fonction a deux argument qui doivent avoir le même type
  -- x est une fonction qui prends un paramètre un type a et qui renvoie un num (a->Num)
  -- y est de type a
  -- L'expresion est de type ((a->Num)->a->Num)
  
  15. (>5.5) x && (*2) y == z
  -- x est un Float
  -- y est un Num
  -- z est un Num
  -- Expression de type Booleene
  
  16. \x -> x.x
  -- x est une fonction 
  -- expression de type (Num->Num)->Num->Num
  
  17. \x y -> (x.head) y
  -- l'opérateur . permet d'appliquer 2 fonction en se suivant.
  ([a]->[a])->[a]->a
  
  -- Exercice 2
  
  2. f:: Int->Int
  3. f:: (Float, Float, a) -> Float
  4. f:: (Int,Int) -> Bool -> Bool
  5. f:: a->[a]->[a]
  6. f:: Num i => [a] -> i -> [a]
  7. f:: Int->Int->Int
  8. f:: Int->Int   --Ou Int a => a->a
  9. l:: [Int]->Int->[Int]
  10. f:: Num a => (b->a)->b->a
  11. f:: Num a => (a->b)->a->b  --La fonction x est appliquée à y+1
  12. f:: (a->b)->(c->a)->c->b
  13. f:: ((a->b)->c)->a->b->c
  14. f:: Int->Int
  
  -- Exercice 3
  
  1. Erreur --car on essaye de concatener une liste de char dans une liste de char
  2. Erreur --car on essaye de mettre un char dans un char et pas une liste de char
  3. "ab"
  4. [1,4,7] ++ 4:[[5]] => Erreur -- l'argument ++ fait une concaténation
  5. True:[] = [True] [True, [True]] => Erreur --Résultat contenant True et une liste (Une liste ne peut contenir des éléments que d'un seul type
  6. [True, True, False]
  
  -- Exercice 4
  
  1. [[]] ++ [[1,2]] = [[], [1,2]] /= xs
  2. [[]] ++ [[1],[2]] = [[], [1], [2]] /= [[],xs] ⇒ False
  3. [[]] ++ [[1,2]] = [[], [1,2]] ⇒ True
  4. False
  5. [3] ++ [] = [3, []] = [3]⇒ True (La liste vide est neutre pour la concaténation)
  6. True
  
  -- Faire des commandes en Haskell sur terminal : ghci
  
  -- Prépa
  
  sumBelow::Int->Int->Int->Int
  sumBelow a b max
   | max == 0 = 0
   | max > 0 = if ((mod(max-1) a == 0) || (mod(max-1) b == 0)) then (max + sumBelow a b (max-1)) else sumBelow a b (max-1)