# 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.