Programmation fonctionnelle

Transcription

1 Programmation fonctionnelle avancée Notes de cours Remise à niveau (simplifiée) 6 septembre 2017 Sylvain Conchon sylvain.conchon@lri.fr /46 1

2 Un livre qui peut vous aider (Amazon, FNAC, etc.) Zh# 8ÉZhi edjgfjd^ cdjh c egd\gvbbvi^dc Zi Vjm ^ih egd\gvbbzh Zi eg h V egd\gvbbvi^dc Zi Yj 2/ VkZX a Zc YZa" h^dc fjz ]bz IV" ^dc" azh# ]Zh# ez h Zi X^Za# b " Ig^ djgh 8dYZ Y^iZjg / <&(+,- >H7C /.,-"'"'&'"&(+,-") VhhZh eg evgvid^gzh Vjm ijy^vcih Zc ^c[dgbvi^" Zg idjh azh Y kzadeezjgh ZbZ! A^he! ZiX# # ('!%% % 6eegZcYgZ egd\gvbbzg D8Vba VkZX 6a\dg^i]bZh Zi higjxijgzh YZ Ydcc Zh H# 8dcX]dc?#"8# ;^aa^}igz gbvi^fjz jh Z[ÒXVXZ Zc idjiz X^g" jkgv\z YÉVa\dg^i]b^fjZ B^Xgdhd[i edjg XdcXZkd^g 6eegZcYgZ egd\gvbbzg VkZX D8Vba HnakV^c 8dcX]dc Zi?ZVc"8]g^hide]Z ;^aa^}igz cz av egd\gvbbvi^dc ZchZ^\cVci aéwxdaz Xdjgh YZ Xdbe^aVi^dc Zadee YZ cdbwgzjm c\v\zh Veea^XVi^[h Zi 2

3 La forme des programmes Ocaml Un programme OCaml est simplement : une suite de déclarations (let) ou d expressions à évaluer (de haut en bas) la fin d une déclaration ou d une expression est spécifiée par deux points virgules ;; Il n y a donc pas de point d entrée particulier (fonction principale par ex.) comme dans d autres langages. 3/46 3

4 Types et expressions élémentaires Expressions de type int : les entiers # * 2 ;; - : int = 1 # 5 / 2 ;; - : int = 2 # mod 2 ;; - : int = 1 # max int + 1 ;; - : int = int représente les entiers compris entre 2 30 et (sur une machine 32 bits) opérations sur ce type : +, -, *, / (division entière), mod (reste de la division) etc. 4/46 4

5 Types et expressions élémentaires Expressions de type bool : les valeurs booléennes # false true ;; - : bool = true # 3 <= 1 ;; - : bool = false # not (0=2) && 1>=3 ;; - : bool = false # if 2<0 then 2.0 else (4.6 *. 1.2) ;; - : float = 5.52 les constantes true (vrai) et false (faux) les opérations sur ce type not (non), && (et) et (ou) les opérateurs de comparaison (=, <, >, <=, >=) retournent des valeurs booléennes dans une conditionnelle de la forme if exp 1 then exp 2 else exp 3 l expression exp 1 doit être de type bool. /46 5

6 Types et expressions élémentaires Expressions de type char : les caractères # a ;; - : char = a # int of char a ;; - : int = 97 # char of int 100 ;; - : char = d les caractères sont encadrés par deux apostrophes la fonction int of char renvoie le code ASCII d un caractère (et inversement pour la fonction char of int). 6/46 6

7 Types et expressions élémentaires Expressions de type string : les chaînes de caractères # "hello" ;; - : string = "hello" # "" ;; - : string = "" # "bon" ^ "jour" ;; - : string = "bonjour" # "hello".[1] ;; - : char = e # string of int 123 ;; - : string = "123" ces valeurs sont encadrées par deux guillemets " l opérateur ^ concatène des chaînes l opération.[i] accède au i e caractère d une chaîne (le premier caractère est à l indice 0) des fonctions de conversions permettent de convertir des valeurs de types de base en chaînes (et inversement) /46 7

8 Le type unit # () ;; - : unit = () # Print.printf "bonjour\n" ;; bonjour - : unit = () unit représente les expressions qui font uniquement des effets de bord une seule valeur a ce type, elle est notée () c est l équivalent du type void en C /46 8

9 Les variables globales # let x = 3 ;; val x : int = 3 le type est inféré automatiquement par le compilateur le contenu d une variable n est pas modifiable la portée est limitée aux déclarations suivantes # let y = 5 + x ;; val y : int = 8 # let z = 10 + z ;; Error: Unbound value z La liaison est statique : la redéfinition ne change pas la valeur des expressions précédentes # let x = 10 ;; val x : int = 10 # y ;; - : int = 8 /46 9

10 Appel de fonction L appel d une fonction toto avec un argument v se note simplement : toto v il n y a donc pas de parenthèses Si la fonction toto a plusieurs arguments, par exemple trois arguments, on note simplement : toto v1 v2 v3 10/46 1

11 Le type float Expressions de type float : les nombres à virgule flottante # 4.3e * ;; - : float = # 5. /. 2. ;; - : float = 2.5 # 1. /. 0. ;; - : float = infinity # 0. /. 0. ;; - : float = nan les types int et float sont disjoints opérations sur ce type : *. /. sqrt cos etc. on passe d un entier à un flottant à l aide de la fonction float of int et inversement avec truncate 11/46 1

12 Les variables locales # let x = 3 in x + 1;; - : int = 4 la portée est limitée à l expression qui suit le in # x + 2;; Error: Unbound value x le nom de la variable locale masque toute déclaration antérieure de même nom # let y = 2;; val y : int = 2 # let y = in (truncate y) + 1;; - : int = 101 # y + 3;; - : int = 5 2/46 1

13 Fonctions # let f x = x + 2;; val f : int -> int = <fun> # f 4;; - : int = 6 les types, des arguments et du résultat, sont inférés la règle de portée du nom de la fonction est identique à celle des constantes (globales ou locales) # let h x = x / 2 in h 6;; - : int = 3 # h 4;; Error : Unbound value h # let g x = x g (not x);; Error : Unbound value g 3/46 1

14 Fonctions à plusieurs arguments # let f x y z = if x then y + 1 else z - 1;; val f : bool -> int -> int -> int = <fun> # f true 2 3;; - : int = 3 les paramètres ne sont pas entre parenthèses, ni dans les déclarations, ni dans les applications de fonctions 4/46 1

15 Fonctions récursives # let rec fact x = if x <= 0 then 1 else x * fact (x - 1);; val fact : int -> int = <fun> # fact 4;; - : int = 24 l ajout du mot-clé rec change la portée de l identificateur : il est alors accessible dans la définition de la fonction 5/46 1

16 Séquences Une séquence d expressions permet d évaluer des expressions les unes après les autres # let x = Print.printf "bonjour\n"; 5 ;; bonjour val x : int = 5 l opérateur de séquence est le point virgule ; c est un opérateur binaire Étant donnée une séquence d expressions e 1 ;e 2 ; ;e n toutes les expressions e 1,..., e n 1 ne font que des effets de bord la valeur et le type de la séquence sont ceux de la dernière expression e n 6/46 1

17 les fonctions locales Une déclaration de fonction peut être locale à une expression et ou locale à la déclaration d une autre fonction Ainsi, le programme suivant : let boucle n = let rec blc_rec i = Printf.printf "%d " i; if i<n then blc_rec (i+1) in blc_rec 0;; let carre x = x * x in boucle (carre 3);; affiche /46 1

18 Définitions récursives Une fonction est récursive si elle fait appel à elle même dans sa propre définition Par exemple, la fonction factorielle n! peut être définie de manière récursive, pour tout entier n, par les deux équations suivantes 0! = 1 n! = n (n 1)! 18/46 1

19 Fonctions récursives en OCAML La définition d une fonction récursive est introduite par l adjonction du mot clé rec au mot clé let let rec fact n = if n=0 then 1 else n * fact (n-1) ;; 19/46 1

20 Pourquoi ce mot clé rec? La règle de portée du let let f x = x + 1 let f y = if y=0 then f 2 else 4+y 20/46 2

21 Pourquoi ce mot clé rec? La règle de portée du let let f x = x + 1 let rec f y = if y=0 then f 2 else 4+y 20/46 2

22 Définitions par cas Analyse par cas d une valeur avec la construction match with let rec fact n = match n with 0 -> 1 _ -> n * fact (n-1) ;; Ceci permet de se rapprocher encore plus de la définition mathématique 21/46 2

23 Récursivité double Récursivité double : plusieurs appels récursifs peuvent apparaître dans la définition 22/46 2

24 Récursivité double Récursivité double : plusieurs appels récursifs peuvent apparaître dans la définition let rec fibonacci n = match n with 0 -> 0 1 -> 1 _ -> fibonacci (n-1) + fibonacci (n-2) ;; 22/46 2

25 Récursivité mutuelle (1/2) Récursivité mutuelle : une fonction f peut faire référence à une fonction g qui elle-même fait référence à f Dans un fichier pair.ml : let rec pair n = (n = 0) impair (n-1) ;; let rec impair n = (n <> 0) && pair (n-1) ;; 23/46 2

26 Récursivité mutuelle (1/2) Récursivité mutuelle : une fonction f peut faire référence à une fonction g qui elle-même fait référence à f Dans un fichier pair.ml : let rec pair n = (n = 0) impair (n-1) ;; let rec impair n = (n <> 0) && pair (n-1) ;; compilation > ocamlc -o pair pair.ml File "pair.ml", line 1, characters 28-34: Unbound value impair 23/46 2

27 Récursivité mutuelle (2/2) Pour définir deux fonctions f et g mutuellement récursives on utilise la construction let rec f = e1 and g = e2 let rec pair n = (n = 0) impair (n-1) and impair n = (n <> 0) && pair (n-1) ;; 24/46 2

28 Le produit cartésien La structure de données la plus simple pour former des valeurs complexes est la paire (ou produit cartésien) 25/46 2

29 Le produit cartésien La structure de données la plus simple pour former des valeurs complexes est la paire (ou produit cartésien) # (1, 2) ;; 25/46 2

30 Le produit cartésien La structure de données la plus simple pour former des valeurs complexes est la paire (ou produit cartésien) # (1, 2) ;; - : int * int = (1,2) 25/46 2

31 Le produit cartésien La structure de données la plus simple pour former des valeurs complexes est la paire (ou produit cartésien) # (1, 2) ;; - : int * int = (1,2) Les composantes des paires peuvent être de types différents 25/46 2

32 Le produit cartésien La structure de données la plus simple pour former des valeurs complexes est la paire (ou produit cartésien) # (1, 2) ;; - : int * int = (1,2) Les composantes des paires peuvent être de types différents # ( a, 2.7) ;; 25/46 2

33 Le produit cartésien La structure de données la plus simple pour former des valeurs complexes est la paire (ou produit cartésien) # (1, 2) ;; - : int * int = (1,2) Les composantes des paires peuvent être de types différents # ( a, 2.7) ;; - : char * float = ( a,2.7) 25/46 2

34 Accéder aux composantes d une paire Les fonctions fst et snd permettent respectivement d accéder à la première et la deuxième composante d une paire 26/46 2

35 Accéder aux composantes d une paire Les fonctions fst et snd permettent respectivement d accéder à la première et la deuxième composante d une paire # snd (1,2);; 26/46 2

36 Accéder aux composantes d une paire Les fonctions fst et snd permettent respectivement d accéder à la première et la deuxième composante d une paire # snd (1,2);; - : int = 2 26/46 2

37 Accéder aux composantes d une paire Les fonctions fst et snd permettent respectivement d accéder à la première et la deuxième composante d une paire # snd (1,2);; - : int = 2 # fst ((1,2.5), a );; 26/46 2

38 Accéder aux composantes d une paire Les fonctions fst et snd permettent respectivement d accéder à la première et la deuxième composante d une paire # snd (1,2);; - : int = 2 # fst ((1,2.5), a );; - : int * float = (1,2.5) 26/46 2

39 Accéder aux composantes d une paire Les fonctions fst et snd permettent respectivement d accéder à la première et la deuxième composante d une paire # snd (1,2);; - : int = 2 # fst ((1,2.5), a );; - : int * float = (1,2.5) # let p = (1,2) in (snd p, fst p);; 26/46 2

40 Accéder aux composantes d une paire Les fonctions fst et snd permettent respectivement d accéder à la première et la deuxième composante d une paire # snd (1,2);; - : int = 2 # fst ((1,2.5), a );; - : int * float = (1,2.5) # let p = (1,2) in (snd p, fst p);; - : int * int = (2,1) 26/46 2

41 n-uplets Le produit cartésien (binaire) se généralise facilement afin de regrouper les valeurs en n-uplets 27/46 2

42 n-uplets Le produit cartésien (binaire) se généralise facilement afin de regrouper les valeurs en n-uplets # (2+3,false true,"bonjour");; 27/46 2

43 n-uplets Le produit cartésien (binaire) se généralise facilement afin de regrouper les valeurs en n-uplets # (2+3,false true,"bonjour");; - : int * bool * string = (5,true,"bonjour") 27/46 2

44 n-uplets Le produit cartésien (binaire) se généralise facilement afin de regrouper les valeurs en n-uplets # (2+3,false true,"bonjour");; - : int * bool * string = (5,true,"bonjour") Les n-uplets et les paires peuvent se mélanger 27/46 2

45 n-uplets Le produit cartésien (binaire) se généralise facilement afin de regrouper les valeurs en n-uplets # (2+3,false true,"bonjour");; - : int * bool * string = (5,true,"bonjour") Les n-uplets et les paires peuvent se mélanger # ( a,1.2,(true,0));; 27/46 2

46 n-uplets Le produit cartésien (binaire) se généralise facilement afin de regrouper les valeurs en n-uplets # (2+3,false true,"bonjour");; - : int * bool * string = (5,true,"bonjour") Les n-uplets et les paires peuvent se mélanger # ( a,1.2,(true,0));; - : char * float * (bool * int) = ( a,1.2,(true,0)) 27/46 2

47 Accès aux éléments d un n-uplet (1/2) On utilise une forme généralisée du let ou une construction match-with let motif = e match e with motif ->... où le motif permet de filtrer le n-uplet représenté par l expression e 28/46 2

48 Accès aux éléments d un n-uplet (1/2) On utilise une forme généralisée du let ou une construction match-with let motif = e match e with motif ->... où le motif permet de filtrer le n-uplet représenté par l expression e # let v = ( a,1.2,"bonjour");; val v : char * float * string = ( a,1.2,"bonjour") 28/46 2

49 Accès aux éléments d un n-uplet (1/2) On utilise une forme généralisée du let ou une construction match-with let motif = e match e with motif ->... où le motif permet de filtrer le n-uplet représenté par l expression e # let v = ( a,1.2,"bonjour");; val v : char * float * string = ( a,1.2,"bonjour") On récupère les éléments de v avec (x,y,z) comme motif 28/46 # let (x,y,z) = v;; val x : char = a val y : float = 1.2 val z : string = "bonjour" 2

50 Accès aux éléments d un n-uplet (2/2) # let v = (1,( a,2.3));; val v : int * (char * float) = (1,( a,2.3)) 9/46 2

51 Accès aux éléments d un n-uplet (2/2) # let v = (1,( a,2.3));; val v : int * (char * float) = (1,( a,2.3)) Accès aux composantes d une paire 9/46 2

52 Accès aux éléments d un n-uplet (2/2) # let v = (1,( a,2.3));; val v : int * (char * float) = (1,( a,2.3)) Accès aux composantes d une paire # let (x,c) = v;; val x : int = 1 val c : char * float = ( a,2.3) 9/46 2

53 Accès aux éléments d un n-uplet (2/2) # let v = (1,( a,2.3));; val v : int * (char * float) = (1,( a,2.3)) Accès aux composantes d une paire # let (x,c) = v;; val x : int = 1 val c : char * float = ( a,2.3) Accès aux composantes d une composante 9/46 2

54 Accès aux éléments d un n-uplet (2/2) # let v = (1,( a,2.3));; val v : int * (char * float) = (1,( a,2.3)) Accès aux composantes d une paire # let (x,c) = v;; val x : int = 1 val c : char * float = ( a,2.3) Accès aux composantes d une composante # let (x,(y,z)) = v;; val x : int = 1 val y : char = a val z : float = 2.3 9/46 2

55 N-uplets : valeurs de première classe Les n-uplets peuvent être passés en arguments aux fonctions 0/46 3

56 N-uplets : valeurs de première classe Les n-uplets peuvent être passés en arguments aux fonctions # let f (x,y,z) = x + y * (int_of_float z);; val f : int * int * float -> int = <fun> 0/46 3

57 N-uplets : valeurs de première classe Les n-uplets peuvent être passés en arguments aux fonctions # let f (x,y,z) = x + y * (int_of_float z);; val f : int * int * float -> int = <fun> # f (1,2,3.5);; - : int = 7 ou retournés comme résultats 0/46 3

58 N-uplets : valeurs de première classe Les n-uplets peuvent être passés en arguments aux fonctions # let f (x,y,z) = x + y * (int_of_float z);; val f : int * int * float -> int = <fun> # f (1,2,3.5);; - : int = 7 ou retournés comme résultats # let rec division n m = if n<m then (0,n) else let (q,r) = division (n - m) m in (q + 1,r);; val division : int -> int -> int * int = <fun> 0/46 3

59 Les enregistrements Le produit nommé permet de définir des enregistrements : des n-uplets dont les éléments (champs) ont chacun un nom distinct En OCAML, chaque produit nommé (ou type enregistrement) possède un nom donné par l utilisateur 1/46 3

60 Les enregistrements Le produit nommé permet de définir des enregistrements : des n-uplets dont les éléments (champs) ont chacun un nom distinct En OCAML, chaque produit nommé (ou type enregistrement) possède un nom donné par l utilisateur # type complexe = { re : float; im : float};; type complexe = { re : float; im : float} 1/46 3

61 Les enregistrements Le produit nommé permet de définir des enregistrements : des n-uplets dont les éléments (champs) ont chacun un nom distinct En OCAML, chaque produit nommé (ou type enregistrement) possède un nom donné par l utilisateur # type complexe = { re : float; im : float};; type complexe = { re : float; im : float} On crée des valeurs de type complexe de la manière suivante 1/46 3

62 Les enregistrements Le produit nommé permet de définir des enregistrements : des n-uplets dont les éléments (champs) ont chacun un nom distinct En OCAML, chaque produit nommé (ou type enregistrement) possède un nom donné par l utilisateur # type complexe = { re : float; im : float};; type complexe = { re : float; im : float} On crée des valeurs de type complexe de la manière suivante # { re = 1.4; im = 0.5};; - : complexe = { re = 1.4; im = 0.5} 1/46 3

63 Accès aux éléments d un enregistrement (1/2) L accès le plus simple aux champs d un enregistrement se fait à l aide de la notation objet.nom du champ 32/46 3

64 Accès aux éléments d un enregistrement (1/2) L accès le plus simple aux champs d un enregistrement se fait à l aide de la notation objet.nom du champ # let v = { re = 1.3; im = 0.9};; val v : complexe = { re = 1.3; im = 0.9} 32/46 3

65 Accès aux éléments d un enregistrement (1/2) L accès le plus simple aux champs d un enregistrement se fait à l aide de la notation objet.nom du champ # let v = { re = 1.3; im = 0.9};; val v : complexe = { re = 1.3; im = 0.9} # v.re;; - : float = /46 3

66 Accès aux éléments d un enregistrement (2/2) Le filtrage permet un accès partiel et en profondeur aux champs d un enregistrement # type t = { a : int; b : float * char; c : string };; type t = { a : int; b : float * char; c : string } 33/46 3

67 Accès aux éléments d un enregistrement (2/2) Le filtrage permet un accès partiel et en profondeur aux champs d un enregistrement # type t = { a : int; b : float * char; c : string };; type t = { a : int; b : float * char; c : string } # let v = { a = 1; b = (3.4, a ); c = "bonjour" };; val v : t = { a = 1; b = (3.4, a ); c = "bonjour" } 33/46 3

68 Accès aux éléments d un enregistrement (2/2) Le filtrage permet un accès partiel et en profondeur aux champs d un enregistrement # type t = { a : int; b : float * char; c : string };; type t = { a : int; b : float * char; c : string } # let v = { a = 1; b = (3.4, a ); c = "bonjour" };; val v : t = { a = 1; b = (3.4, a ); c = "bonjour" } # let { b = (_,x); c = y} = v;; val x : char = a val y : string = "bonjour" 33/46 3

69 L ordre des champs n a pas d importance Les définitions de types suivantes sont équivalentes type t = { a : int; b : char; c : bool } type t = { b : char; c : bool; a : int } 34/46 3

70 L ordre des champs n a pas d importance Les définitions de types suivantes sont équivalentes type t = { a : int; b : char; c : bool } type t = { b : char; c : bool; a : int } De même ces valeurs sont égales : # { a = 1; b = t ; c = true} = { b = t ; c = true; a = 1} ;; - : bool = true 34/46 3

71 L ordre des champs n a pas d importance Les définitions de types suivantes sont équivalentes type t = { a : int; b : char; c : bool } type t = { b : char; c : bool; a : int } De même ces valeurs sont égales : # { a = 1; b = t ; c = true} = { b = t ; c = true; a = 1} ;; - : bool = true Le filtrage est également insensible à l ordre des champs : # let { c = x; b = y} = { b = t ; c = true; a = 1} ;; val x : bool = true val y : char = t 34/46 3

72 Structurer l information Le mélange des n-uplets et des enregistrements permet de définir des objets complexes # type adresse = { rue : string; ville : string; cp : int};; # type fiche = { nom : string; prenom : string ; adresse : adresse; date_naissance : int * int * int; tel_fixe : string; portable : string };; 35/46 3

73 Création de nouvelles valeurs # let v1 = { a = 1; b = false; c = r };; val v1 : t = { a = 1; b = false; c = r } 36/46 3

74 Création de nouvelles valeurs # let v1 = { a = 1; b = false; c = r };; val v1 : t = { a = 1; b = false; c = r } On peut créer un nouvel enregistrement v2 en utilisant le contenu des champs de v1 36/46 3

75 Création de nouvelles valeurs # let v1 = { a = 1; b = false; c = r };; val v1 : t = { a = 1; b = false; c = r } On peut créer un nouvel enregistrement v2 en utilisant le contenu des champs de v1 # let v2 = { a = v1.a; b = true; c = v1.c};; val v2 : t = { a = 1; b = true; c = r } 36/46 3

76 Création de nouvelles valeurs # let v1 = { a = 1; b = false; c = r };; val v1 : t = { a = 1; b = false; c = r } On peut créer un nouvel enregistrement v2 en utilisant le contenu des champs de v1 # let v2 = { a = v1.a; b = true; c = v1.c};; val v2 : t = { a = 1; b = true; c = r } Le raccourci syntaxique suivant permet d arriver au même résultat {v with c1 = e1;... cn=en} 36/46 3

77 Création de nouvelles valeurs # let v1 = { a = 1; b = false; c = r };; val v1 : t = { a = 1; b = false; c = r } On peut créer un nouvel enregistrement v2 en utilisant le contenu des champs de v1 # let v2 = { a = v1.a; b = true; c = v1.c};; val v2 : t = { a = 1; b = true; c = r } Le raccourci syntaxique suivant permet d arriver au même résultat {v with c1 = e1;... cn=en} # let v3 = { v1 with b = true };; val v3 : t = { a = 1; b = true; c = r } 36/46 3

78 Enregistrements : valeurs de première classe Une fonction prenant un enregistrement en argument : # let f v = v.a;; val f : t -> int 37/46 3

79 Enregistrements : valeurs de première classe Une fonction prenant un enregistrement en argument : # let f v = v.a;; val f : t -> int # f {a = 1; b = false; c = e };; - : int = 1 37/46 3

80 Enregistrements : valeurs de première classe Une fonction prenant un enregistrement en argument : # let f v = v.a;; val f : t -> int # f {a = 1; b = false; c = e };; - : int = 1 Les enregistrements peuvent aussi être retournés en résultat # let f {a=x} v = { v with a = x+v.a } ;; val f : t -> t -> t 37/46 3

81 Enregistrements : valeurs de première classe Une fonction prenant un enregistrement en argument : # let f v = v.a;; val f : t -> int # f {a = 1; b = false; c = e };; - : int = 1 Les enregistrements peuvent aussi être retournés en résultat # let f {a=x} v = { v with a = x+v.a } ;; val f : t -> t -> t # let v = {a=1;b=true;c= r } in f v v;; - : t = {a=2;b=true;c= r } 37/46 3

82 Les types sommes Modélisation de domaines finis Réalisation de sommes disjointes permettant de réunir dans un même type des valeurs pouvant appartenir à des types différents 38/46 3

83 Constructeurs constants On peut modéliser un domaine fini comportant exactement n valeurs avec un type somme Exemple, les couleurs d un jeu de carte : # type couleur = Pique Coeur Carreau Trefle;; type couleur = Pique Coeur Carreau Trefle les identificateurs Pique, Coeur, Carreau et Trefle sont des constructeurs (les majuscules sont obligatoires pour définir des constructeurs) le nom du domaine fini est couleur 39/46 3

84 Utilisation des constructeurs L unique manière de créer des valeurs d un type somme est d utiliser un constructeur : 40/46 4

85 Utilisation des constructeurs L unique manière de créer des valeurs d un type somme est d utiliser un constructeur : # Trefle;; - : couleur = Trefle 40/46 4

86 Utilisation des constructeurs L unique manière de créer des valeurs d un type somme est d utiliser un constructeur : # Trefle;; - : couleur = Trefle # let v = (Pique, Coeur);; val v : couleur * couleur = (Pique, Coeur) 40/46 4

87 Utilisation des constructeurs L unique manière de créer des valeurs d un type somme est d utiliser un constructeur : # Trefle;; - : couleur = Trefle # let v = (Pique, Coeur);; val v : couleur * couleur = (Pique, Coeur) # Pique = Coeur;; - : bool = false 40/46 4

88 Filtrage des constructeurs constants La construction match-with permet de définir de manière compacte une analyse par cas d un type somme 41/46 4

89 Filtrage des constructeurs constants La construction match-with permet de définir de manière compacte une analyse par cas d un type somme # let points v = match v with Pique -> 1 Trefle -> 2 Coeur -> 3 Carreau -> 4;; 41/46 4

90 Filtrage des constructeurs constants La construction match-with permet de définir de manière compacte une analyse par cas d un type somme # let points v = match v with Pique -> 1 Trefle -> 2 Coeur -> 3 Carreau -> 4;; val points : couleur -> int = <fun> 41/46 4

91 Filtrage des constructeurs constants La construction match-with permet de définir de manière compacte une analyse par cas d un type somme # let points v = match v with Pique -> 1 Trefle -> 2 Coeur -> 3 Carreau -> 4;; val points : couleur -> int = <fun> # points Coeur;; - : int = 3 41/46 4

92 Constructeurs avec arguments Les constructeurs peuvent également avoir des arguments, par exemple : # type num = Int of int Float of float type num = Int of int Float of float Le mot-clé of indique que le constructeur attend un argument On crée des valeurs en appliquant les constructeurs à des arguments du bon type : # Int(5);; 42/46 4

93 Constructeurs avec arguments Les constructeurs peuvent également avoir des arguments, par exemple : # type num = Int of int Float of float type num = Int of int Float of float Le mot-clé of indique que le constructeur attend un argument On crée des valeurs en appliquant les constructeurs à des arguments du bon type : # Int(5);; - : num = Int(5) 42/46 4

94 Filtrage des constructeurs avec arguments (1/2) On utilise la construction match-with pour récupérer les arguments associés à un constructeur # match Int(5) with Int(x) -> x+2;; - : int = 7 En réalité, la réponse que l on obtient est celle-là : 43/46 4

95 Filtrage des constructeurs avec arguments (1/2) On utilise la construction match-with pour récupérer les arguments associés à un constructeur # match Int(5) with Int(x) -> x+2;; - : int = 7 En réalité, la réponse que l on obtient est celle-là : Warning P: this pattern-matching is not exhaustive. Here is an example of a value that is not matched: Float _ - : int = 7 43/46 4

96 Filtrage des constructeurs avec arguments (1/2) On utilise la construction match-with pour récupérer les arguments associés à un constructeur # match Int(5) with Int(x) -> x+2;; - : int = 7 En réalité, la réponse que l on obtient est celle-là : Warning P: this pattern-matching is not exhaustive. Here is an example of a value that is not matched: Float _ - : int = 7 Le filtrage exige de faire une analyse par cas complète en fonction du type de l objet filtré et non de sa valeur. 43/46 4

97 Filtrage des constructeurs avec arguments (2/2) La complétude de l analyse peut être obtenue en exécutant failwith "explication" pour les cas impossibles # match Int(5) with Int(x) -> x+2 Float(x) -> failwith "cas impossible";; 44/46 4

98 Filtrage des constructeurs avec arguments (2/2) La complétude de l analyse peut être obtenue en exécutant failwith "explication" pour les cas impossibles # match Int(5) with Int(x) -> x+2 Float(x) -> failwith "cas impossible";; - : int = 7 44/46 4

99 Exemple L addition de valeurs de type num peut s écrire ainsi 45/46 4

100 Exemple L addition de valeurs de type num peut s écrire ainsi # let ajoute x y = match (x,y) with (Int(m), Int(n)) -> Int(m + n) (Int(m), Float(n)) -> Float((float_of_int m) +. n) (Float(m), Int(n)) -> Float(m +. (float_of_int n)) (Float(m), Float(n)) -> Float(m +. n);; 45/46 4

101 Exemple L addition de valeurs de type num peut s écrire ainsi # let ajoute x y = match (x,y) with (Int(m), Int(n)) -> Int(m + n) (Int(m), Float(n)) -> Float((float_of_int m) +. n) (Float(m), Int(n)) -> Float(m +. (float_of_int n)) (Float(m), Float(n)) -> Float(m +. n);; val ajoute : num -> num -> num = <fun> On utilise simplement cette fonction de la manière suivante 45/46 4

102 Exemple L addition de valeurs de type num peut s écrire ainsi # let ajoute x y = match (x,y) with (Int(m), Int(n)) -> Int(m + n) (Int(m), Float(n)) -> Float((float_of_int m) +. n) (Float(m), Int(n)) -> Float(m +. (float_of_int n)) (Float(m), Float(n)) -> Float(m +. n);; val ajoute : num -> num -> num = <fun> On utilise simplement cette fonction de la manière suivante # ajoute (Float(3.5)) (Int(5));; - : num = Float(8.5) 45/46 4

103 Autre exemple Le type des cartes d un jeu de cartes : type valeur = Roi Reine Valet Num of int type couleur = Coeur Pique Trefle Carreau type carte = valeur * couleur # let compare (c1,_) (c2,_) = if c1 = c2 then 0 else match c1,c2 with Roi, _ -> 1 Reine, Roi -> -1 Reine, _ -> 1 Valet, Roi -> -1 Valet, Reine -> -1 Valet, _ -> 1 Num(x), Num(y) -> (x - y) / (abs (x - y)) _ -> -1 6/46 4