diff --git a/.gitignore b/.gitignore
index 59b848b..443ee53 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,7 +5,6 @@ test2.html
 test.c
 fichier1.txt
 levallois.jpg
-fstfunc.hs
 
 *.aux
 *.log
diff --git a/HSK10.md b/HSK10.md
new file mode 100644
index 0000000..7991ae6
--- /dev/null
+++ b/HSK10.md
@@ -0,0 +1,28 @@
+# Haskell 10
+
+### Exercice 1
+1. OK
+2. Signifie «est du type»
+3. L'opérateur -> est un constructeur de types signifiant «type fonction de A vers B»
+4. Le type indiqué est donc «fonction de Int vers Int» ou «fonction prenant un entier et renvoyant un entier».
+5. OK
+6. La première est correcte car l'argument à une fonction de type `Int -> Int` est bien un `Int`. Dans la seconde expression, Haskelle râle parce que l'on essaie d'appliquer une fonction de type `Int -> Int` à un argument de type `Float`: il y a incompatibilité.
+7. Cette fois ci, les deux expressions sont valides car Int est une «sous-classe» de Float, c'est à dire qu'un entier peut toujours être compris comme un flottant.
+
+### Exercice 2
+1. `length` renvoie la taille de la liste passée en paramètre.
+2. `lenght` est polymorphique, ce qui signifie que son argument n'a pas de type précis, la seule contrainte étant que ce doit être une liste. Mais ça peut être une `Int list`, une `Float list`, ou même une `Float list list list list list`.
+3. La commande `:t` affiche le type de l'expression fournie en paramètre.
+4. `a` est une lettre dénotant n'importe quel type, la fonction length a donc le type `t a -> Int` où `t` représente un objet de classe `Foldable` (comme `list`).
+5. Les types comme `a` sont appelés *génériques*. Un objet ayant un type générique est par exemple la liste vide `[]` qui est liste vide pour n'importe quel type de contenu.
+6. L'opérateur `++` est du type `[a] -> [a] -> [a]`, c'est à dire qu'il prend en argument «deux listes» de même type et renvoie une liste du même type que les arguments.
+7. Le type des éléments en entrée et en sortie doit être le même, contrainte imposée par l'utilsation d'une même lettre pour décrire les types.
+8. Le type est alors écrit `[a] -> [a] -> ... −> [a] -> [a]` avec *n+1* fois le terme `[a]`.
+9. L'opérateur `!!` permet d'accéder aux éléments d'une liste à partir de leur indice. La fonction a donc le type `[a] -> Int -> [a]`.
+10. La fonction `head` perment d'accéder à l'élément en tête de la liste. Cette fonction a donc le type `[a] -> a`.
+
+### Exercice 3
+Voir fstfunc.hs
+
+### Exercice 4
+Voir fstfunc.hs
diff --git a/fstfunc.hs b/fstfunc.hs
new file mode 100644
index 0000000..309f91f
--- /dev/null
+++ b/fstfunc.hs
@@ -0,0 +1,8 @@
+addTwo :: Float -> Float
+addTwo x = x + 2
+
+threeParam :: Int -> Int -> Int -> Int
+threeParam x y z = let w = x+y in w*z
+
+myFirst :: (a,b) -> a
+myFirst t = let (x,y)=t in x