Programmation fonctionnelle

22/03/2017
1
Programmation fonctionnelle
Cours 10 : type somme
les enregistrements
Licence 1
Année 2016 –2017
Par N. VINCENT
CC1
0
5
10
15
20
25
30
35
40
012345678910 11 12 13 14 15 16 17 18 19 20 21
Répartition des notes
Licence 1 -programmation fonctionnelle 3
Les couleurs
On peut vérifier qu'une couleur est une couleur
primaire
# let primaire x = match x with | Bleu | Vert | Rouge -> true
| _ -> false ;;
val primaire : t_couleur -> bool = <fun>
# primaire Vert ;;
-: bool = true
# primaire Bleu ;;
-: bool = true
# primaire Rouge ;;
-: bool = true
# let v = Numero 3 ;;
val v : t_couleur = Numero 3
# primaire v ;;
-: bool = false
# primaire (Numero 3) ;;
-: bool = false
# primaire 3 ;;
Error: This function is applied to too many arguments;
maybe you forgot a `;'
# primaire Numero 3 ;;
Error: This expression has type int but an expression
was expected of type couleur
Licence 1 -programmation fonctionnelle 4
Définition récursive du type
# let c3 = Melange (c2 , Bleu) ;;
val c3 : t_couleur = Melange (Melange (Bleu, Numero 3), Bleu)
# let c1 = Melange (Bleu , Rouge) ;;
val c1 : t_couleur = Melange (Bleu, Rouge)
# let c2 = Melange (Bleu , Numero 3) ;;
val c2 : t_couleur = Melange (Bleu, Numero 3)
# type t_couleur = | Bleu | Vert | Rouge
| Numero of int
| Melange of t_couleur * t_couleur ;;
type t_couleur =
Bleu
| Vert
| Rouge
| Numero of int
| Melange of t_couleur * t_couleur
Les constructeurs sont Bleu,
Vert, Rouge, Numero, Melange
Licence 1 -programmation fonctionnelle 5
Exemple
Une peinture contient-elle du bleu ?
# let rec avecbleu c = match c with | Bleu -> true
| Melange (m1,m2) -> avecbleu m1 || avecbleu m2
| _ -> false ;;
val avecbleu : t_couleur -> bool = <fun>
# avecbleu c1 ;;
-: bool = true
# avecbleu c2 ;;
-: bool = true
# let c4 = Melange (c2 , Rouge) ;;
val c4 : t_couleur = Melange (Melange (Bleu, Numero 3), Rouge)
# avecbleu c4 ;;
-: bool = true
Licence 1 -programmation fonctionnelle 6
Exemple
Compter le nombre de couleurs bleu dans une liste
# let rec compte l x = match l with | [] -> 0
| h::t -> if h = x then 1 + (compte t x) else compte t x ;;
val compte : 'a list -> 'a -> int = <fun>
# let ll = [Bleu ; Vert ; Vert ; Bleu ; Rouge ] ;;
val ll : t_couleur list = [Bleu; Vert; Vert; Bleu; Rouge]
# compte ll Bleu ;;
-: int = 2
# let lc=[Bleu; Vert; Vert; Numero 3; Bleu; Melange (Bleu , Vert); Rouge ] ;;
val lc : t_couleur list =
[Bleu; Vert; Vert; Numero 3; Bleu; Melange (Bleu, Vert); Rouge]
# compte lc Bleu ;;
-: int = 2

22/03/2017
2
Licence 1 -programmation fonctionnelle 7
Exemple
Compter le nombre de couleurs contenant du bleu
dans une liste
# let rec compte1 l = match l with | [] -> 0
| h::t -> if avecbleu h then 1 + (compte1 t) else compte1 t;;
val compte1 : t_couleur list -> int = <fun>
# compte ll Bleu ;;
-: int = 2
# let lc=[Bleu; Vert; Vert; Numero 3; Bleu; Melange (Bleu , Vert); Rouge ] ;;
val lc : t_couleur list =
[Bleu; Vert; Vert; Numero 3; Bleu; Melange (Bleu, Vert); Rouge]
# compte1 lc ;;
-: int = 3
Licence 1 -programmation fonctionnelle 8
Version terminale
Compter le nombre de couleurs contenant du bleu
dans une liste
# let rec f acc l = match l with | [] -> acc
| h::t -> if avecbleu h then (f (acc+1) t ) else f acc t ;;
val f : int -> t_couleur list -> int = <fun>
# f 0 lc ;;
-: int = 3
# let nomb l = let rec f acc ll = match ll with | [] -> acc
| h::t -> if avecbleu h then (f (acc+1) t) else f acc t
in f 0 l ;;
val nomb : t_couleur list -> int = <fun>
# nomb lc ;;
-: int = 3
Licence 1 -programmation fonctionnelle 9
Type somme : exemple
On ne peut pas additionner des énumérés
# type t_longueur = Metre of float | Pied of float ;;
type t_longueur = Metre of float | Pied of float
# Metre 3. +. Metre 5. ;;
Error: This expression has type t_longueur
but an expression was expected of type float
Comment atteindre les réels 3 et 5 ?
# let v = Metre 3. ;;
# let valeur x = match x with Metre y -> y
| Pied y -> y ;;
val valeur : t_longueur -> float = <fun>
# valeur v ;;
-: float = 3.
Licence 1 -programmation fonctionnelle 10
Nature d’une variable
Peut on savoir de quel cas relève une valeur ?
# type t_longueur = Metre of float | Pied of float ;;
type t_longueur = Metre of float | Pied of float
# let metre x = match x with |Pied y -> false
| _ -> true;;
val metre : t_longueur -> bool = <fun>
# metre v ;;
-: bool = true
# let v = Metre 3. ;; # metre Pied 4. ;;# metre Pied 4. ;;
Error: This function is applied to too many
arguments; maybe you forgot a `;'
# metre (Pied 4.) ;;
-: bool = false
Licence 1 -programmation fonctionnelle 11
Opérations
conversion
# type t_longueur = Metre of float | Pied of float ;;
type t_longueur = Metre of float | Pied of float
# let conversion x = match x with |Pied y -> Metre ( 0.30 *. y)
| Metre y -> Pied (y /. 0.30) ;;
val conversion : t_longueur -> t_longueur = <fun>
# conversion (Metre 1.) ;;
-: t_longueur = Pied 3.33333333333333348
# conversion (Pied 12.) ;;
-: t_longueur = Metre 3.59999999999999964
Licence 1 -programmation fonctionnelle 12
Opérations
Additionner des éléments de type longueur
# let add x y = match (x,y) with | (Metre z , Metre r) ->
| (Pied z , Pied r) ->
| (Metre z , Pied r) ->
| (Pied z , Metre r) -> ;;
val add : t_longueur -> t_longueur -> t_longueur = <fun>
# add (Metre 5.) (Metre 8.) ;;
-: t_longueur = Metre 13.
# add (Pied 5.) (Pied 8.) ;;
-: t_longueur = Metre 3.9
# add (Metre 5.) (Pied 3.) ;;
-: t_longueur = Metre 5.9
# add (Pied 3.) (Metre 5.) ;;
-: t_longueur = Metre 5.9
# let rec add x y = match (x,y) with | (Metre z , Metre r) -> Metre ( z +. r)
| (Pied z , Pied r) -> conversion (Pied (z+. r))
| (Metre z , Pied r) -> add x (conversion y)
| (Pied z , Metre r) -> add (conversion x) y ;;
val add : t_longueur -> t_longueur -> t_longueur = <fun>

22/03/2017
3
Licence 1 -programmation fonctionnelle 13
Type nombre
On peut définir un type compatible réel et entier
# type t_nombre = Reel of float | Entier of int ;;
type t_nombre = Reel of float | Entier of int
# let v1 = Entier 5 and v2 = Entier (-3) and v3 = Reel 4. and v4 = Reel 2.5 ;;
val v1 : t_nombre = Entier 5
val v2 : t_nombre = Entier (-3)
val v3 : t_nombre = Reel 4.
val v4 : t_nombre = Reel 2.5
Ils ont tous le même type
Mais aucun opérateur n’est prévu
Licence 1 -programmation fonctionnelle 14
Type nombre
On doit définir des opérations
# type t_nombre = Reel of float | Entier of int ;;
type t_nombre = Reel of float | Entier of int
# somme v1 v2 ;;
-: t_nombre = Entier 2
# somme v1 v3 ;;
-: t_nombre = Reel 9.
somme
# let somme x y = match (x,y) with | (Reel x1 , Reel x2) -> Reel (x1 +. x2)
| (Reel x1 , Entier x2) -> Reel (x1 +. float_of_int (x2))
| (Entier x1 , Entier x2) -> Entier (x1 + x2)
| (Entier x1 , Reel x2) -> Reel (float_of_int(x1) +. x2) ;;
val somme : t_nombre -> t_nombre -> t_nombre = <fun>
# somme v3 v4 ;;
-: t_nombre = Reel 6.5
# somme v4 v2 ;;
-: t_nombre = Reel (-0.5)
# let v1 = Entier 5 and v2 = Entier (-3) and v3 = Reel 4. and v4 = Reel 2.5 ;;
# let add (x,y) (z,t) = (x+z , y+t) ;;
val add : int * int -> int * int -> int * int = <fun>
# add (5,4) (0,1) ;;
-: int * int = (5, 5)
Licence 1 -programmation fonctionnelle 15
Exercice 2-1
Une liste contient une série temporelle de mesures qui sont soit des
mesures de température, soit des mesures de hauteur. Ses
éléments sont de type t_mesure défini par :Type t_mesure =
|Temp of int |Haut of int ;;
1°/ Ecrire une fonction add qui calcule terme à terme la somme de
deux couples d’entiers.
Licence 1 -programmation fonctionnelle 16
Exercice 2-2
2°/Ecrire une fonction fcompte qui à partir d’une liste de mesures de type
t_mesure, calcule un couple contenant respectivement les nombres de
mesures des températures et des hauteurs contenues dans la liste de
mesures.
# let x = [Te mp 3 ; Temp 2 ; Haut 2 ; Te mp 2 ; Haut 4] ;;
val x : t_mesure list = [Tem p 3; Temp 2; Haut 2; Temp 2; Haut 4]
# let rec fcompte l = match l with [] -> (0,0)
| (Temp x) :: t -> add (fcompte t) (1,0)
| (Haut x) :: t -> add (fcompte t) (0,1) ;;
val fcompte : t_mesure list -> int * int = <fun>
Type t_mesure = |Temp of int |Haut of int ;;
# fcompte x ;;
-: int * int = (3, 2)
Licence 1 -programmation fonctionnelle 17
Exercice 2-3
3°/ Ecrire une fonction fmoy qui à partir d’une liste de mesures de
type t_mesure, calcule un couple contenant respectivement les
moyennes des températures et des hauteurs contenues dans la
liste de mesures.
# let fmoy l = let rec fsom ll = match ll with [] -> (0,0)
| (Temp x) :: t -> add (fsom t) (x,0)
| (Haut x) :: t -> add (fsom t) (0,x)
in let (n1,n2) = fcompte l
in let (s1,s2) = fsom l
in (float_of_int s1) /. (float_of_int n1) ,
(float_of_int s2) /. (float_of_int n2) ;;
val fmoy : t_mesure list -> float * float = <fun>
# let x = [Temp 3 ; Temp 2 ; Haut 2 ; Temp 2 ; Haut 4] ;;
val x : t_mesure list = [Te m p 3; Temp 2; Haut 2; Temp 2; Haut 4]
# fmoy x ;;
-: float * float = (2.33333333333333348, 3.)
Type t_mesure = |Temp of int |Haut of int ;;
Licence 1 -programmation fonctionnelle 18
Exercice 2-4
4°/ Ecrire une fonction fmax qui à partir d’une liste de mesures de
type t_mesure, calcule un couple contenant respectivement les
valeurs maximum des températures et des hauteurs contenues dans
la liste de mesures. On vérifiera que la liste comporte au moins une
mesure de hauteur et une mesure de température, sinon une
exception indiquera ce cas.
let fmax l = let (n1,n2) = fcompte l
in if n2<1 && n1<1 then invalid_arg "pas de measures"
else
val fmax : t_mesure list -> int * int = <fun>
let fmax l = let (n1,n2) = fcompte l
in if n2<1 && n1<1 then invalid_arg "pas de measures"
else let rec ft ll = match ll with | (Te m p x) :: t -> x
| (Haut x) :: t -> ft t
| [ ] -> 0
in let rec fh ll = match ll with | (Te m p x) :: t -> fh t
| (Haut x) :: t -> x
| [ ] -> 0
in let rec ffmax acc1 acc2 ll =
match ll with [Tem p x] -> (max x acc1, acc2)
| [Haut x] -> (acc1 , max x acc2)
| (Tem p x) :: t -> ffmax (max x acc1) acc2 t
| (Haut x) :: t -> ffmax acc1 (max x acc2) t
| [ ] -> (acc1 , acc2)
in ffmax (ft l) (fh l) l ;;
val fmax : t_mesure list -> int * int = <fun>
# let x = [Tem p 3 ; Te m p 2 ; Haut 2 ; Te m p 2 ; Haut 4] ;;
val x : t_mesure list = [Tem p 3; Tem p 2; Haut 2; Te mp 2; Haut 4]
# fmax x ;;
-: int * int = (3, 4)
Type t_mesure = |Temp of int |Haut of int ;;