29 lines
2.2 KiB
Markdown
29 lines
2.2 KiB
Markdown
# 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
|