Plus de Hsakell

HSK11.md

@@ -0,0 +1,30 @@
+# 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

HSK12.md

@@ -0,0 +1,48 @@
+# Haskell 12
+
+### Exercice 1
+1. Cela renvoie les 10 première éléments de la suite (infinie) arithmétique de premiers termes 4 puis 8.
+2. Cela renvoie la liste des entiers de 1 à 10 multipliés par 4 (aussi appelée table de 4).
+3. Dans la commande précédente, `x <- [1..10]` signifie «pour x prenant les valeurs de la liste `[1..10]`.
+4. La partie à gauche est la fonction à appliquer afin d'obtenir le résultat.
+5. Dans cet exemple, la partie a gauche signifie «multiplier chaque élément de la liste par 4».
+6. Cette liste est donc le multiplié par 4 de chaque élément de la liste `[1..10]`.
+
+### Exercice 2
+1. On obtient la liste `[20,24,28,32,36,40]`.
+2. La virgule signifie «tel que». La partie à gauche est une expression booléene formant un filtre sur les valeurs de la liste.
+3. On peut ajouter le prédicat `x/=6` donant l'expression `[x*4 | x <- [1..10],x*4 > 16,x/=4]`.
+
+### Exercice 3
+1. On obtient la liste `[999,999,999,999,666,666,666,666,666,666]`.
+2. En effet pour chaque élément de la liste `[1..10]`, si son quadruple est plus grand strictement que 16 (donc si le nombre est strictement plus grand que 4), alors afficher 666 sinon afficher 999.
+3. Les prédicats peuvent seulement limiter le nombre d'éléments en sortie, ce qui ne nous permet pas d'avoir les 10 éléments demandés.
+
+### Exercice 4
+`[x | x <- [1..35], mod x 2 /= 0]`
+
+### Exercice 5
+```
+okko :: [Int] -> [[Char]]
+okko xs = [if x<10 then "OK" else "KO" | x <- xs]
+```
+### Exercice 6
+```
+addList :: [Int] -> [Int] -> [Int]
+addList xs ys = [x+y | x <- xs, y <- ys]
+```
+Exemple: 
+```
+addList [1..5] [10,20..50]
+[11,21,31,41,51,12,22,32,42,52,13,23,33,43,53,14,24,34,44,54,15,25,35,45,55]
+```
+### Exercice 7
+Avec comme en-tête de fichier `{-# LANGUAGE ParallelListComp #-}`
+```
+length2 :: [a] -> Int
+length2 xs = last [n | _ <- xs | n <- [2,4..]]
+```
+Le symbole `_` signifie que l'on utilisera pas la valeur que cette variable prendra.
+
+### Exercice 8
+`[[x | x <- [1..10] , (mod x 2) == i] | i <- [0,1]]`

fstfunc.hs

@@ -1,8 +1,19 @@
-addTwo :: Float -> Float
+{-# LANGUAGE ParallelListComp #-}
+addTwo :: Num a => a -> a
 addTwo x = x + 2
 
-threeParam :: Int -> Int -> Int -> Int
+threeParam :: Num a => a -> a -> a -> a
 threeParam x y z = let w = x+y in w*z
 
 myFirst :: (a,b) -> a
 myFirst t = let (x,y)=t in x
+
+okko :: [Int] -> [[Char]]
+okko xs = [if x<10 then "OK" else "KO" | x <- xs]
+
+addList :: [Int] -> [Int] -> [Int]
+addList xs ys = [x+y | x <- xs, y <- ys]
+
+
+length2 :: [a] -> Int
+length2 xs = last [n | _ <- xs | n <- [2,4..]]