# 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