Caml : solution du TD 3

Une solution du TD 3 de Caml (v.16.1)

Exercice 1

arités	forme curryfiée
f: 2, g: 2, h: 2	( f (h x y) (g z t)
f: 3, g: 2, x: 1	(f h ( g (x h) y) z)
f: 4, h: 2, z: 1	( f g (h x y) (z x) t)

Exercice 2
1.
type chiffre = Zero | Un | Deux |Trois | Quatre | Cinq | Six | Sept | Huit | Neuf;;
2.
type panier = Pomme of int | Poire of int | Peche of int;;
let papom = Pomme 10;;
let papoi = Poire 6;;
3.
type operateur = Plus | Moins | Multiplie | Divisepar;;
let calculer op m n =
if op=Plus then (m+n)
else if op=Moins then (m-n)
else if op=Multiplie then (m*n)
else (m/n);;
4.
type complexePur = Reel of float | Imaginaire of float;;

Exercice 3
1.
type dbl_ent = int * int;;
type dbl_reel = float * float;;
type dbl_ec = dbl_ent * dbl_reel;;
let tranformer ((n,p),(x,y)) = ( float_of_int(n)*.x , float_of_int(p)*.y );;
N.B. On pourrait aussi définir :
let tranformer (x:dbl_ec) = ( (float_of_int (fst (fst x)))*.(fst (snd x)), (float_of_int (snd (fst x)))*.(snd (snd x)) );;
2.
type point2 = float * float;;
let abscisse (x:point2) = fst x;;
let ordonnee (x:point2) = snd x;;
3.
type point3 = float * float * float;;
On ne peut pas utiliser les fonctions fst et snd pour des types produits de plus de deux types.
let projection ((x,y,z):point3) = ((x,y+z):point2);;
4.
type vecteur = float * float * float;;
let vectoriser ((x1,y1,z1):point3) ((x2,y2,y2):point3) = (x2-.x1, y2-.y1, z2-.z1):vecteur;;

Exercice 4
type individu = string * string * int;;
let (d:individu) = ("Tsing", "Tao", 98);;
Nom et prénom sont deux chaines de caractère qui ne peuvent pas être distinguées par Caml autrement que par l'ordre arbitraire choisi dans le type.

Exercice 5
1.
type nom = Nom of string;;
type prenom = Prenom of string;;
2.
type age = Age of int;;
N.B. I faut distinguer age qui est le nom du type et Age est un identificateur abstrait, on aurait pu faire une autre choix, tel que : type age = Annee of int. 3.
type personne = nom * prenom * age;;
4.
let p = ( Nom "DURAN", Prenom "Alice", Age 20);;
5.
A chacune des valeurs nom, prénom ou âge, est associé un identificateur symbolique. Caml saura inférer le type de p comme étant une personne.
6.
let extraireNom (Nom n, Age a) = n;;
let extraireAge (Nom n, Age a) = a;;

Exercice 6

type	fonction
'a→int	`let f1 x = 1;;`
'a→'a	`let f2 x = x;;`
'a→unit	`let f3 = ();;`
int→int	`let f4 x = x+1;;`
'a→'b→'a	`let f5 x y = x;;`
'a→'b→'b	`let f6 x y = y;;`
'a→int→int	`let f7 x y = y+1;;`
'a→int→'a	`let f8 x y = if y>0 then x else x;;`
'a&raarr;('a→'b)→'b
'a→('a→int)→int	`let f10 x f = f(x)+1;;`
int→(int→'a)→'a	`lt f11 x = f(x+1);;`
('a→'b)→('b→'c)→'a→'c	`let f12 f g x = g(f(x));;`

Exercice 7
Pour vérifier vos réponses, créer ces fonctions sous Caml.

Exercice 8
(Voir avec le cours)

Exercice 9
1.
Pour vérifier vos réponses, créer ces fonctions sous Caml.
2.
Ces trois fonctions peuvent réaliser une même opération mais en plaçant l'opérateur
– soit entre les deux opérandes (écriture infixe, celle dont nous avons l'habitude),
– soit avant les deux opérandes (écriture préfixe, dite aussi polonaise),
– soit après les deux opérandes (écriture suffixe, dite aussi postfixe).
3.

let prefixeIF x y z = 

   if x=Plus then y+z

   else if x=Moins then y-z

   else if x=Multiplie then y*z

   else y/z;;

let prefixeMATCH x y z = match x with 

   | Plus      −> y+z

   | Moins     −> y-z

   | Multiplie −> y*z

   | Divisepar −> y/z;;

Exercice 10

let nullite n = match n with

   | 0 minus;> 0

   | _ minus;> 1;;

let unoudeux n = match with

   | 1 minus;> 1

   | 2 minus;> 2;;

Caml répond : << Warning 8: this pattern-matching is not exhaustive. >> car l'instruction match doit examiner tous ou bien se terminer par le cas général dénoté _

let doublenul x y = match (x,y) with

   | (0,_) −> 0

   | (_,0.) −> 1

   | _ −> 2;;

let minuscule = match s.[0] with

   |'a' −> 'v'

   |

...



   | 'y' −> 'v'

   | _ −> '-';;

let position x = match x with

   | (0,0) −> "origine"

   | (0,_) −> "abscisse"

   | (_,0) −> "ordonnee";;

Exercice 11
1.
let xor a b = if a==b then false else true;;
let xor a b = ;;

let xor a b = match (a,b) with

   | (true,true) −> false

   | (true,false) −> true =

   | (false,true) −> true

   | (false,false) −> false;;

let xor a b = match (a,b) with

   | (true,false) −> true =

   | (false,true) −> true

   | _ −> false;;

let xor a b = not (a==b);;
2.
Sur le même principe.

Exercice 12

let combien p = match p with

   | Poire n minus;> n

   | Pomme n minus;> n

   | Peche n minus;> n;;

Exercice 13
On peut toujours remplacer : if expression then conséquence else alternative par match expression with | true −> conséquence with | _ −> alternative, mais quel intérêt ??
Il y a par contre des situations où la reconnaissance de motif par match est plus puissante que ce que pourrait offrir une suite de if imbriqués (voir l'exercice précédent).
Par conséquent, il est essentiel de bien choisir entre ces deux outils selon les situations rencontrées.