31 lines
2.9 KiB
Markdown
31 lines
2.9 KiB
Markdown
# Haskell 10
|
||
|
||
### Exercice 1
|
||
1. OK
|
||
2. Sans nous en rendre compte, nous avons utilisés deux fonctions différentes, l'une du type `Int -> Int -> Int` et l'autre du type `Float -> Float -> Float`. La surcharge d'opérateur est le fait que deux fonctions essensiellement différentes puissent exister sous un même nom, si il n'y a jamais ambiguité sur laquelle est appelée.
|
||
3. Il est possible de surcharger l'opérateur `+` car il a une signification très vague. En mathématique, il peut être l'opération de n'importe quel ensemble ayant une structure de groupe. Un utilisateur créant ses propres objets et leur conférant une telle structure est donc sémantiquement obligé d'utiliser l'opérateur `+` pour additionner ses objets.
|
||
4. OK
|
||
5. Le symbole `=>` est le symbole de l'implication logique. On peut ici le lire comme «dans les conditions ..., on a ...».
|
||
6. Le resultat de la commande nos dit que «pour tout type `a` de classe `Num` (donc représentant un nombre), la fonction `(+)` a pour type `a -> a -> a`.
|
||
|
||
### Exercice 2
|
||
1. OK
|
||
2. La classe `Eq` correspond aux types dont deux objets sont toujours ou bien égaux, ou bien distincts (et que l'on peut le déterminer). Les éléments doivent donc nécessairement posséder une méthode `==` et/ou `/=` permetteant de tester l'égalité entre deux objets (respectivenent, l'ingéalité).
|
||
3. De nombreux types étendent cette classe, par exemple `[Int]` (par l'implication `Eq Int => Eq [Int]`) ou encore des tuples d'éléments de classe Eq (par exemple `(Int, Float)`.
|
||
4. OK
|
||
5. Même chose Ici, les éléments de la classe Ord doivent obligatoirement étendre une fonction `compare` qui associe deux ordres totaux contraires au type.
|
||
6. OK
|
||
7. La classe `Show` correspond aux types qui sont «affichable», par exemple dans le terminal. Les types de cette classe doivent définir une méthode `show` qui à partir d'un objets crée une chaine de carctère que l'on peut afficher pour le représenter.
|
||
8. OK
|
||
9. La classe `Read` correspond aux types dont les objets peuvent être créé à partir de leur description donnée par `Show`. Ils doivent implémenter la méthode `readsPrec` qui à une précédence et une chaine de caractères associe un objet décrit par cette chaine.
|
||
10. La classe `Num` correspond aux type numériques. Ils doivent implémenter les fonctions `(+)`, `(-)`,`(*)`, `signum` donnant le signe et `fromInteger` permettant de créer un objet à partir d'un entier.
|
||
11. OK
|
||
12. La classe `Integral` correspond aux nombres «intégrables», c'est à dire divisibles par des nombres entiers. Ils doivent implémenter les méthodes `quot`,`rem`,`div`,`mod` et `toInteger`.
|
||
13. OK
|
||
14. La classe `Fractional` décrit les types dont les objets peuvent être divisés par des nombres entiers. Il doivent surcharger la méthode `(/)` de division, ainsi que `recip` donnant l'inverse multiplication et que `fromRational` permettant de créer l'objets à partir d'un rationnel.
|
||
### Exercice 3
|
||
Voir fstfunc.hs
|
||
|
||
### Exercice 4
|
||
Voir fstfunc.hs
|