1 - Le paradigme fonctionnel repose sur la composition de fonctions pures, où l'accent est mis sur le traitement de données immuables, tandis que le paradigme impératif se concentre sur la séquence d'instructions modifiant l'état d'un programme en vue de produire un résultat.
2- Type Synonyme :
type TripletPoly a b c = (a, b, c)
first :: TripletPoly a b c -> a
first (x, _, _) = x
second :: TripletPoly a b c -> b
second (_, y, _) = y
third :: TripletPoly a b c -> c
third (_, _, z) = z
On ne peut pas préciser explicitement le type des fonctions en utilisant TripletPoly, car il s'agit d'un type synonyme et non d'un nouveau type.
3 -
L'évaluation paresseuse consiste à ne pas évaluer une expression tant que cela n'est pas nécessaire. Par exemple, si on a if True then 1 else 2, seule l'expression 1 sera évaluée car c'est la seule qui sera nécessaire.
L'instanciation partielle d'une fonction consiste à appliquer partiellement la fonction en lui fournissant certains arguments, pour obtenir une nouvelle fonction qui attend les arguments restants. Par exemple, si on a la fonction f x y z = x + y + z, on peut faire g = f 1, ce qui crée une nouvelle fonction g qui attend deux arguments au lieu de trois.
4-
drop :: Int -> [a] -> [a]
take :: Int -> [a] -> [a]
const :: a -> b -> a
foldr :: (a -> b -> b) -> b -> [a] -> b
foldl :: (b -> a -> b) -> b -> [a] -> b
5-
(a) [2, 4, 6]
(b) ['o', 'e', 'l', 'y', 'k']
(c) 1
(d) 1
6 -
Avec des gardes:
removeNegatives :: [Int] -> [Int]
removeNegatives [] = []
removeNegatives (x:xs)
| x >= 0 = x : removeNegatives xs
| otherwise = removeNegatives xs
Avec la récursivité:
removeNegatives :: [Int] -> [Int]
removeNegatives [] = []
removeNegatives (x:xs)
| x >= 0 = x : removeNegatives xs
| otherwise = removeNegatives xs
Avec la définition en compréhension:
removeNegatives :: [Int] -> [Int]
removeNegatives xs = [x | x <- xs, x >= 0]
7 -
(a) Les constructeurs de données ont le type a -> List a.
(b) Les fonctions de projections ont les types List a -> a et List a -> List a.
(c)
toList :: [a] -> List a
toList [] = Nil
toList (x:xs) = Build x (toList xs)
(d)
fromList :: List a -> [a]
fromList Nil = []
fromList (Build x xs) = x : fromList xs
(e) aList a le type [List a].
applyMap a le type Fractional b => List b -> [List b].
(f) Voici l'implémentation de la fonction map_ :
map_ :: (a -> b) -> List a -> List b
map_ f Nil = Nil
map_ f (Cons x xs) = Cons (f x) (map_ f xs)