51 lines
1.7 KiB
Markdown
51 lines
1.7 KiB
Markdown
# 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.
|