From 50586a7a9cdf6ccf0992471d505cf4415b12baf4 Mon Sep 17 00:00:00 2001 From: Mysaa Date: Wed, 5 Jan 2022 12:26:30 +0100 Subject: [PATCH] Plus de Haskell. On y est presque ! --- HSK14.md | 11 +++++ HSK15.md | 69 +++++++++++++++++++++++++++++++ HSK16.md | 50 +++++++++++++++++++++++ HSK17.md | 9 ++++ fstfunc.hs | 118 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 257 insertions(+) create mode 100644 HSK14.md create mode 100644 HSK15.md create mode 100644 HSK16.md create mode 100644 HSK17.md diff --git a/HSK14.md b/HSK14.md new file mode 100644 index 0000000..1781eab --- /dev/null +++ b/HSK14.md @@ -0,0 +1,11 @@ +# Haskell 14 + +### Exercice 1 + +1. Le pattern matching a pour objectif de «déconstruire» un objets en ses «composants». Là où un guarde a pour but de réagir différement selon certaines valeurs booléenes indiquées. +2. On peut approcher ce concept des structures `switch` présents dans certains langages impératifs, ou de suites `if`,`else if`, `else if` , … , `else if`,`else` +3. Les différents conditions d'un garde sont écrites en les commençant par un *pipe* `|`. La structure est `| expressionBooleene = valeurSiEvaluéeÀTrue` +4. Le `else` correspond au mot clé `otherwise` qui prend la place d'une expression booléenne. + +### Exercice 2 +Voir fstfunc.hs diff --git a/HSK15.md b/HSK15.md new file mode 100644 index 0000000..eaffcc1 --- /dev/null +++ b/HSK15.md @@ -0,0 +1,69 @@ +# Haskell 15 + +### Exercice 1 + +1. +``` +myMean :: Fractional a => Real a => a -> a -> String +myMean x y + | (x+y)/2>12 = "You are a good student" + | (x+y)/2>=10 = "You can be do what you want to do" + | otherwise = "You are a bad student" +``` +2. Le mot-clé `where` sert en Haskell à définir des variables temporaires afin d'éviter de réutiliser une expression à plusieurs emplacement du code. Cela permet d'assure que le calcul n'est effectué qu'une seule fois. +3. +``` +myMean2 :: Fractional a => Real a => a -> a -> String +myMean2 x y + | moy>12 = "You are a good student" + | moy>=10 = "You can be do what you want to do" + | otherwise = "You are a bad student" + where moy=(x+y)/2 +``` +L'intéret est que les variables on plus de sens (car elles ont maintenant un nom) que des formules. +4. +``` +myMean3 :: Fractional a => Real a => a -> a -> String +myMean3 x y + | moy>=acceptable = "You are a good student" + | moy>=pass = "You can be do what you want to do" + | otherwise = "You are a bad student" + where + moy=(x+y)/2 + pass=10 + acceptable=12 +``` + +### Exercice 2 + +1. Il est tout à fait possible d'utiliser le *pattern matching* dans un `where`. +2. +``` +myMean4 :: Fractional a => Real a => a -> a -> String +myMean4 x y + | moy>=acceptable = "You are a good student" + | moy>=pass = "You can be do what you want to do" + | otherwise = "You are a bad student" + where (moy,pass,acceptable)=((x+y)/2,10,12) +``` +3. +``` +whereList :: Show a => Show b => [a] -> [b] -> String +whereList l1 l2 + | length l1 > 1 && length l2 > 1 = show secondl1 ++ " " ++ show lastl2 + | length l1 <= 1 && length l2 <= 1 = "The lengths of l1 and l2 are too short" + | length l1 <= 1 = "The length of l1 is too short" + | length l2 <= 1 = "The length of l2 is too short" + where + _:secondl1:_ = l1 + lastl2 = last l2 +``` + +### Exercice 3 +1. Il est tout à fait possible de définir des fonctions dans un `where`. +2. +``` +listMean :: [(Double,Double)] -> [Double] +listMean l = [moy x y | (x,y) <- l] + where moy u v = (u+v)/2 +``` diff --git a/HSK16.md b/HSK16.md new file mode 100644 index 0000000..5feec26 --- /dev/null +++ b/HSK16.md @@ -0,0 +1,50 @@ +# Haskell 16 + +### Exercice 1 +1. `let` reste à travers l'execution (une définition) alors que `where` crée une définition uniquement valable dans le bloc le précédent. +2. On ne peut pas utiliser `let` dans un *pattern matching* car aucun pattern ne «correspond» à un `let`. +3. La syntaxe du `let` est la suivante: `let nomDeVariable = définition`. +4. Les noms sont disponibles avant les signes `=` et les définitions sont juste après. +5. +``` +Prelude> let a=2 +Prelude> let b=98 +Prelude> let c=34 +Prelude> let f="Bonjour" +Prelude> let g=" je suis " +Prelude> let h="un let." +Prelude> (a+b+c,f++g++h) +(134,"Bonjour je suis un let.") +``` + +6. +``` +Prelude> let pow3 x = x*x*x +Prelude> let t=(pow3 12, pow3 9) +Prelude> t +(1728,729) +``` + +### Exercice 2 + +1. +``` +listMeanlet :: [(Double,Double)] -> [Double] +listMeanlet l = [moy x y | d<-l, let (x,y) =d] + where moy u v = (u+v)/2 +``` +2. Le `let` utilise le *pattern matching* et crée des définitions utilisables uniquement à l'interieur de la liste en compréhension. +3. +``` +listMeanlet2 :: [(Double,Double)] -> [Double] +listMeanlet2 l = [let (x,y) =d in moy x y | d<-l] + where moy u v = (u+v)/2 +``` +4. Ici, le `let` est «à l'interieur» de la liste. Cette liste est comprise par haskell comme la liste des `let (x,y) = d in moy x y` pour `d` dans `l`. Le `let` crée une expression plutôt qu'une définition. +5. +``` +listMeanlet3 :: [(Double,Double)] -> [Double] +listMeanlet3 l = [m| d<-l, let (x,y) =d, let m = moy x y, m>=12] + where moy u v = (u+v)/2 +``` +6. On ne pourrait pas ajouter (simplement) cette condition sans réécrire une décomposition dans `listMeanlet2` car les variables `x` et `y` ne sont pas définies dans le contexte de la liste. diff --git a/HSK17.md b/HSK17.md new file mode 100644 index 0000000..e5b2443 --- /dev/null +++ b/HSK17.md @@ -0,0 +1,9 @@ +# Haskell 17 + +### Exercice 1 + +1. La structure `case` en Haskell permet de gérer différents *cas*, de réagir différement suivant les différentes formes que peut avoir une variable. +2. La définition au pattern matching définit la fonction «par parties» (entre les deux lignes, `longueurListe` n'est pas défini pour les listes non vide), là ou avec le case, nous définissons directement la fonction sur tout type de liste. + +### Exercice 2 +Voir fstfunc.hs diff --git a/fstfunc.hs b/fstfunc.hs index 7efbb39..d95c783 100644 --- a/fstfunc.hs +++ b/fstfunc.hs @@ -78,5 +78,123 @@ myLengthShow [] = printf "The list has no elements\n" myLengthShow [x] = printf "The list has one element: %s\n" (show x) myLengthShow [x,y] = printf "The list has two elements: %s and %s\n" (show x) (show y) myLengthShow _ = printf "The list has more than two elements\n" + + +goodStudent :: Real a => a -> String +goodStudent m + | m>12 = "You are a good student" + | m>=10 = "You can be do what you want to do" + | otherwise = "You are a bad student" + + +myMin :: Ord a => a -> a -> a +myMin a b + | a (a,a) -> (a,a) -> (a,a) +maxVect (x,y) (x',y') + | x>=x' && y>=y' = (x,y) + | x>=x' = (x,y') + | y>=y' = (x',y) + | otherwise = (x',y') + +myMean :: Fractional a => Real a => a -> a -> String +myMean x y + | (x+y)/2>12 = "You are a good student" + | (x+y)/2>=10 = "You can be do what you want to do" + | otherwise = "You are a bad student" + +myMean2 :: Fractional a => Real a => a -> a -> String +myMean2 x y + | moy>12 = "You are a good student" + | moy>=10 = "You can be do what you want to do" + | otherwise = "You are a bad student" + where moy=(x+y)/2 + +myMean3 :: Fractional a => Real a => a -> a -> String +myMean3 x y + | moy>=acceptable = "You are a good student" + | moy>=pass = "You can be do what you want to do" + | otherwise = "You are a bad student" + where + moy=(x+y)/2 + pass=10 + acceptable=12 + + +myMean4 :: Fractional a => Real a => a -> a -> String +myMean4 x y + | moy>=acceptable = "You are a good student" + | moy>=pass = "You can be do what you want to do" + | otherwise = "You are a bad student" + where (moy,pass,acceptable)=((x+y)/2,10,12) + +whereList :: Show a => Show b => [a] -> [b] -> String +whereList l1 l2 + | length l1 > 1 && length l2 > 1 = show secondl1 ++ " " ++ show lastl2 + | length l1 <= 1 && length l2 <= 1 = "The lengths of l1 and l2 are too short" + | length l1 <= 1 = "The length of l1 is too short" + | length l2 <= 1 = "The length of l2 is too short" + where + _:secondl1:_ = l1 + lastl2 = last l2 + +listMean :: [(Double,Double)] -> [Double] +listMean l = [moy x y | (x,y) <- l] + where moy u v = (u+v)/2 + +listMeanlet :: [(Double,Double)] -> [Double] +listMeanlet l = [moy x y | d<-l, let (x,y) =d] + where moy u v = (u+v)/2 + +listMeanlet2 :: [(Double,Double)] -> [Double] +listMeanlet2 l = [let (x,y) =d in moy x y | d<-l] + where moy u v = (u+v)/2 + +listMeanlet3 :: [(Double,Double)] -> [Double] +listMeanlet3 l = [m| d<-l, let (x,y) =d, let m = moy x y, m>=12] + where moy u v = (u+v)/2 + +modifStrings :: [[Char]] -> [[Char]] +modifStrings l = [ case s of { + [] -> "null"; + [e] -> "indefini"; + [e,f] -> [e]; + _ -> [last s] + } | s<-l] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +