diff --git a/HSK22.md b/HSK22.md
new file mode 100644
index 0000000..4e47ef6
--- /dev/null
+++ b/HSK22.md
@@ -0,0 +1,24 @@
+# Haskell 22
+
+### Exercice 1
+
+1. Cette expression crée un type appelé `Vector` qui peut être instancié avec un seul constructeur: `Vec3` qui prend en paramètre trois flottants.
+2. 
+```
+magnitude :: Vector -> Float
+magnitude (Vec3 a b c) = sqrt (a*a+b*b+c*c)^
+```
+
+### Exercice 2
+1. Cette expression crée un type polymorphique de vecteur à trois coordonées, qui peuvent être de n'importe quel type.
+2. L'expression donnée est donc du type `Vector [Char]`.
+3. Là où cette autre expression est du type `Vector Int` (ou plutôt `Num t => Vector t`)
+4. Celle ci est du type Vector Float (on a forcé le type d'un élément, donc de t, donc du vecteur).
+5. `data Liste t = Liste Integer [t]`
+6. `initListe = Liste 0 []`
+7. 
+```
+ajouteListe::Liste t -> t -> Liste t
+ajouteListe (Liste n s) x = Liste (n+1) (x:s)
+```
+8. Cette liste permet d'implémenter la fonction `length` en temps constant, au prix d'un coût à peine plus élevé lors du l'ajout et un petit peu plus de mémoire.
diff --git a/HSK23.md b/HSK23.md
new file mode 100644
index 0000000..3535a71
--- /dev/null
+++ b/HSK23.md
@@ -0,0 +1,24 @@
+# Haskell 23
+
+### Exercice 1
+
+1. L'expression crée le type `Verité` qui n'a que deux constructeurs d'arité 0.
+2. L'expression suivante crée un type `Arbre` défini inductivement comme étant soit une feuille, soit un nœud composé d'un flottant et de deux sous-arbres.
+3. L'expression donnée crée une instance du type arbre construite par le constructeur `Noeud` avec comme valeurs le flottant 5, une instance du type arbre consturite par le constructeur `Noeud` avec comme valeur le flottant 2 et deux fois l'arbre contstruit par le constructeur `Feuille`, ainsi que une instance du type arbre construite par le constructeur `Noeud` avec comme valeur le flottant 7 et deux fois l'arbre construit par le constructeur `Feuille`.
+4. On peut définir le type `data Arbre t = Noeud t (Arbre t) (Arbre t)`
+5. 
+```
+arbreSomme :: Num t => Arbre t -> t
+arbreSomme Feuille = 0
+arbreSomme (Noeud v a b) = v + (arbreSomme a) + (arbreSomme b)
+```
+6. Le type sur les arbres polymorphiques est donné ci-dessus. Pour les arbres Float, on aurait pour type `Arbre t -> t`
+7. Ce type correspond à une valeur de type `t` qui peut ne pas avoir été renvoyée. C'est un espèce de `null` du langagae fonctionnel. Il est ou bien présent (`Just a`) ou absent (`Nothing`).
+8. `head` sur une liste vide renvoie une exception.
+9. 
+```
+headSafe :: [t] -> Maybe t
+headSafe [] = Nothing
+headSafe (e:s) = Just e
+```
+10. `data Arbre t = Noeud t (Maybe (Arbre t)) (Maybe (Arbre t))`
diff --git a/HSK24.md b/HSK24.md
new file mode 100644
index 0000000..1c4960e
--- /dev/null
+++ b/HSK24.md
@@ -0,0 +1,14 @@
+# Haskell 24
+
+### Exercice 1
+1. Cette expression crée le type `Vector t` et appele `print` sur une instance de ce type. Sauf que Haskell râle car le type susnommé n'a pas la classe `Show`.
+2. En indiquant que Vector a la classe `Show`, alors ..... ben elle peut être affichée.
+
+### Exercice 2
+1. Dans la première expression, Haskell ne sait pas comment comparer ou tester l'égalité des éléments de type `Card` car le type n'est pas de la classe `Eq` ni `Ord`.
+Dans le second cas, on a précisé les classes, donc Haskell est capable d'inférer les opérateurs d'égalité et de définition (se basant sur l'ordre des déclarations des constructeurs).
+2. L'expression suivante crée un type Objet avec trois constructeurs, et définit comment l'objet instantie la classe `Eq`.
+3. 
+- Pour définir `Eq`, il faut définir `==`
+- Pour définir `Ord`, il faut définir `compare` de type `a -> a -> Ordering
+- Pour définir `Show`, il faut définir `show` de type `a -> String`.
diff --git a/fstfunc.hs b/fstfunc.hs
index d95c783..1214874 100644
--- a/fstfunc.hs
+++ b/fstfunc.hs
@@ -164,9 +164,20 @@ modifStrings l = [ case s of {
         _ -> [last s]
     } | s<-l]
 
-
-
-
+data Vector = Vec3 Float Float Float
+
+magnitude :: Vector -> Float
+magnitude (Vec3 a b c) = sqrt (a*a+b*b+c*c)
+
+data Arbre t = Noeud t (Arbre t) (Arbre t) | Feuille
+
+arbreSomme :: Num t => Arbre t -> t
+arbreSomme Feuille = 0
+arbreSomme (Noeud v a b) = v + (arbreSomme a) + (arbreSomme b)
+
+headSafe :: [t] -> Maybe t
+headSafe [] = Nothing
+headSafe (e:s) = Just e