58 lines
3.1 KiB
Markdown
58 lines
3.1 KiB
Markdown
# Haskell 19
|
||
|
||
### Exercice 1
|
||
1. Une fonction d'ordre superieur est une fonction qui prend d'autres fonctions en entrée, ou qui renvoie une fonction. C'est ce qui fait que les langages fonctionnels sont trops biens.
|
||
2. Dans le type de telles fonctions, il devra y avoir un parenthèsages des flèches `->` car on sera dans des cas ou la précédence à gauche fait défaut. Par exemple pour une fonction `(Int -> Int) -> Float -> [Float]`.
|
||
3.
|
||
```
|
||
apply3 :: (a -> a) -> a -> a
|
||
apply3 f x = f (f (f x))
|
||
```
|
||
4. La fonction d'entrée doit être une application interne afin de pouvoir la composer avec elle même (la loi de composition implique type entrée = type sortie).
|
||
|
||
5.
|
||
```
|
||
applyN :: Int -> (a->a) -> a -> a
|
||
applyN 0 f x = x
|
||
applyN n f x = f (applyN (n-1) f x)
|
||
```
|
||
|
||
### Exercice 2
|
||
1. L'expression crée une application square qui met au carrée et renvoie la liste [1..5] à laquelle on a appliqué `square` à chaque élément.
|
||
2. La fonction `map` sert à appliquer une fonction à tous les éléments d'une liste.
|
||
3. `map` est donc de type `(a -> b) -> [a] -> [b]` car elle prend en entrée une fonction «transformant les `a` en `b`» et l'applique à une liste de `a` pour en faire une liste de `b`.
|
||
4.
|
||
```
|
||
myMap :: (a -> b) -> [a] -> [b]
|
||
myMap f l = [f x | x <- l]
|
||
```
|
||
5.
|
||
```
|
||
myMap2 :: (a->b)->[a]->[b]
|
||
myMap2 f [] = []
|
||
myMap2 f (e:s) = (f e):(myMap2 f s)
|
||
```
|
||
6. L'expression renvoie la liste `[1..10]` privée de tous ses entiers non impairs.
|
||
7. La fonction `filter` permet de filtrer les éléments d'une liste selon un prédicat, c'est à dire une application du type `a -> Bool`.
|
||
8. La fonction `filter` est du type `(a -> Bool) -> [a] -> [a]` car elle prend en entrée un prédicat sur des `a` et une liste de `a` et renvoie une liste incluse, donc de même type `a`.
|
||
9.
|
||
```
|
||
myFilter :: (a -> Bool) -> [a] -> [a]
|
||
myFilter f [] = []
|
||
myFilter f (e:s)
|
||
| f e = e:(filter f s)
|
||
| otherwise = filter f s
|
||
```
|
||
10. L'expression renvoie la liste `[(1,'a'),(2,'b'),(3,'c')]`
|
||
11. La fonction `zip` transforme un couple de listes en une liste de couples tels que la liste résultat soit de la taille de la plus petite des listes d'entrée et que le ième élément de la premiere liste soit mis en couple avec le ième de la seconde.
|
||
12. La fonction `zip` est du type `[a] -> [b] -> [(a, b)]` car elle prend deux liste de types potentiellement différents, et crée une liste de couples contenant dans l'ordre les types des listes.
|
||
13. L'expression renvoie la liste `[1+4,2+5]`.
|
||
14. La fonction zipWith colle les données de deux listes comme zip, mais applique une fonction passée en paramètre pour la fusion des données.
|
||
15. La fonction zipWith est du type `(a -> b -> c) -> [a] -> [b] -> [c]` carre la fonction paramètre prend deux paramètres, un de chaque liste (de types a priori différents) et renvoie quelque chose de type ici aussi à priori différent. Il est appliqué ensuite à une liste du type de son premier paramètre, puis à une liste du type de son second paramètre et renvoie une liste du type son type de sortie.
|
||
16.
|
||
```
|
||
myZipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
|
||
myZipWith o l l' = map applicateur (zip l l')
|
||
where applicateur (x,y) = o x y
|
||
```
|