Types construits

En OCaml, on peut définir nos propres types.

Type somme (variant)¶

On peut définir un type somme (variant) en énumérant tous les cas possibles pour avoir ce type. Ceci revient à prendre l'union de plusieurs types. Chaque cas doit être identifié par un nom appelé constructeur, qui doit commencer par une majuscule (il est interdit de commencer un nom de variable avec une majuscule, pour ne pas confondre) :

In [8]:

type matiere = Math | Physique | Info

type matiere = Math | Physique | Info

Out[8]:

type matiere = Math | Physique | Info

On vient de définir un type matiere qui contient trois valeurs Math, Physique, Info.

In [10]:

Math;;  (* c'est une valeur de type matiere *)
let a = Info;; (* qu'on peut stocker dans une variable *)

Math;; (* c'est une valeur de type matiere *) let a = Info;; (* qu'on peut stocker dans une variable *)

Out[10]:

- : matiere = Math

Out[10]:

val a : matiere = Info

Pour traiter une variable de ce type, on utilise un match :

In [14]:

let heures m = match m with
  | Math -> 12.
  | Physique -> 6.5
  | Info -> 4.;;
heures Info

let heures m = match m with | Math -> 12. | Physique -> 6.5 | Info -> 4.;; heures Info

Out[14]:

val heures : matiere -> float = <fun>

Out[14]:

- : float = 4.

Les constructeurs utilisés ci-dessus sont des constantes, mais il est possible d'ajouter un paramètre avec of ... :

In [1]:

type zbarre = Infini | MoinsInfini | Entier of int

type zbarre = Infini | MoinsInfini | Entier of int

Out[1]:

type zbarre = Infini | MoinsInfini | Entier of int

Dans cet exemple, zbarre est censé représenter $\overline{\mathbb{Z}} = \mathbb{Z} \cup \{-\infty, \infty\}$. Entier est un constructeur qui dépend d'un paramètre entier. Pour obtenir une valeur à partir du constructeur Entier, on l'utilise comme une fonction :

In [2]:

Entier 10  (* valeur de type zbarre *)

Entier 10 (* valeur de type zbarre *)

Out[2]:

- : zbarre = Entier 10

Écrivons une fonction pour augmenter une valeur de type zbarre de 1 :

In [3]:

let add1 n = match n with
  | Infini -> Infini    
  | MoinsInfini -> MoinsInfini
  | Entier i -> Entier (i + 1);;

add1 (Entier 10);;
add1 Infini

let add1 n = match n with | Infini -> Infini | MoinsInfini -> MoinsInfini | Entier i -> Entier (i + 1);; add1 (Entier 10);; add1 Infini

Out[3]:

val add1 : zbarre -> zbarre = <fun>

Out[3]:

- : zbarre = Entier 11

Out[3]:

- : zbarre = Infini

Écrivons une fonction pour additionner deux valeurs de type zbarre. Pour pouvoir utiliser un opérateur infixe, on peut définir (+!) (liste de tous les symboles autorisés comme opérateur infixe):

In [4]:

let (+!) n1 n2 = match n1, n2 with
| Infini, Infini -> Infini
| MoinsInfini, MoinsInfini -> MoinsInfini
| Infini, Entier(_) | Entier(_), Infini  -> Infini
| MoinsInfini, Entier(_) | Entier(_), MoinsInfini  -> MoinsInfini
| _ -> failwith "Indetermine"

let (+!) n1 n2 = match n1, n2 with | Infini, Infini -> Infini | MoinsInfini, MoinsInfini -> MoinsInfini | Infini, Entier(_) | Entier(_), Infini -> Infini | MoinsInfini, Entier(_) | Entier(_), MoinsInfini -> MoinsInfini | _ -> failwith "Indetermine"

Out[4]:

val ( +! ) : zbarre -> zbarre -> zbarre = <fun>

In [5]:

Infini +! Infini;;
Infini +! MoinsInfini

Infini +! Infini;; Infini +! MoinsInfini

Out[5]:

- : zbarre = Infini

Exception: Failure "Indetermine".
Raised at file "stdlib.ml", line 29, characters 22-33
Called from file "toplevel/toploop.ml", line 208, characters 17-27

Exercice

Définir -!, *!, /! pour des valeurs de type zbarre. Définir aussi ~- qui permet d'avoir d'appliquer - sur un seul élément (opérateur unaire).

Il est possible d'utiliser 'a (n'importe quel type) pour un paramètre de constructeur, à condition de le mettre dans le type (on appelle alors ceci un type polymorphe). Par exemple, on pourrait redéfinir list :

In [6]:

type 'a liste = Vide | Cons of 'a * 'a liste

type 'a liste = Vide | Cons of 'a * 'a liste

Out[6]:

type 'a liste = Vide | Cons of 'a * 'a liste

Cons est alors un constructeur ayant comme paramètre un couple : premier élément de la liste et reste de la liste.

Remarque : liste est un type récursif (on utilise le type liste dans la définition de liste)

In [7]:

let l = Cons(1, Cons(2, Cons(3, Vide))) (* équivalent de 1::2::3::[]) *)

let l = Cons(1, Cons(2, Cons(3, Vide))) (* équivalent de 1::2::3::[]) *)

Out[7]:

val l : int liste = Cons (1, Cons (2, Cons (3, Vide)))

In [8]:

let rec appartient e l = match l with (* teste si e appartient à l *)
  | Vide -> false
  | Cons(x, q) -> x = e || appartient e q

let rec appartient e l = match l with (* teste si e appartient à l *) | Vide -> false | Cons(x, q) -> x = e || appartient e q

Out[8]:

val appartient : 'a -> 'a list -> bool = <fun>

Exercice

1. Écrire un type number qui représente des nombres soient entiers (int), soit flottants (float).
2. Écrire des opérations (addition...) sur ce type. L'addition d'un flottant avec un entier donnera un flottant.
3. Écrire une fonction pour sommer les éléments d'une liste de number.

Solution

In [1]:

(* 1 *)
type number = F of float | I of int;;

(* 2 *)
let (+@) n1 n2 = match n1, n2 with
    | F(f1), F(f2) -> F(f1 +. f2)
    | I(n1), I(n2) -> I(n1 + n2)
    | I(n1), F(n2) -> F(float_of_int n1 +. n2)
    | F(n1), I(n2) -> F(n1 +. float_of_int n2);;
    
(* 3 *)
let rec somme = function
    | [] -> I(0)
    | e::q -> e +@ somme q in
somme [F 3.14; I 2; I 98; F 1.745]

(* 1 *) type number = F of float | I of int;; (* 2 *) let (+@) n1 n2 = match n1, n2 with | F(f1), F(f2) -> F(f1 +. f2) | I(n1), I(n2) -> I(n1 + n2) | I(n1), F(n2) -> F(float_of_int n1 +. n2) | F(n1), I(n2) -> F(n1 +. float_of_int n2);; (* 3 *) let rec somme = function | [] -> I(0) | e::q -> e +@ somme q in somme [F 3.14; I 2; I 98; F 1.745]

Out[1]:

type number = F of float | I of int

Out[1]:

val ( +@ ) : number -> number -> number = <fun>

Out[1]:

- : number = F 104.885

Type option¶

Le type option sert à stocker une valeur optionnelle, éventuellement None :

In [4]:

None

None

Out[4]:

- : 'a option = None

In [5]:

Some 1

Some 1

Out[5]:

- : int option = Some 1

Le type option est définit comme ceci en OCaml :

In [6]:

type 'a option = None | Some of 'a

type 'a option = None | Some of 'a

Out[6]:

type 'a option = None | Some of 'a

Il est utile lorsqu'une fonction peut renvoyer aucune valeur.

Exercice

Écrire une fonction indice : 'a array -> 'a -> int option telle que indice t e renvoie Some i tel que t[i] = e, si un tel i existe, et None sinon.

Solution

In [8]:

let indice t e = 
  let res = ref None in
  for i = 0 to Array.length t - 1 do
    if t.(i) = e then res := Some i
  done;
  !res;;

indice [|0; 3; 2; 4; 5|] 4;;
indice [|0; 3; 2; 4; 5|] 1;;

let indice t e = let res = ref None in for i = 0 to Array.length t - 1 do if t.(i) = e then res := Some i done; !res;; indice [|0; 3; 2; 4; 5|] 4;; indice [|0; 3; 2; 4; 5|] 1;;

Out[8]:

val indice : 'a array -> 'a -> int option = <fun>

Pour savoir si une option est un None ou Some, on utilise un match.

Type enregistrement (record)¶

Alors qu'un type somme fait une disjonction (un "ou") de plusieurs types, un type enregistrement (record) permet d'avoir plusieurs types simultanément (un "et" de plusieurs types).

In [1]:

type fraction = {num: int; den: int};; (* fraction composée d'un numérateur ET dénominateur *)
let x = {num=3; den=4};; (* x représente la fraction 3/4 *)
x.den  (* obtient la valeur du champ den de x *)

type fraction = {num: int; den: int};; (* fraction composée d'un numérateur ET dénominateur *) let x = {num=3; den=4};; (* x représente la fraction 3/4 *) x.den (* obtient la valeur du champ den de x *)

Out[1]:

type fraction = { num : int; den : int; }

Out[1]:

val x : fraction = {num = 3; den = 4}

Out[1]:

- : int = 4

fraction est un type très proche de int*int. La différence principale est que les composantes sont nommées dans un enregistrement mais pas dans un tuple.
Nous pouvons multiplier deux fractions :

In [2]:

let mult x1 x2 = 
  {num=x1.num*x2.num; den=x1.den*x2.den};;

mult x x

let mult x1 x2 = {num=x1.num*x2.num; den=x1.den*x2.den};; mult x x

Out[2]:

val mult : fraction -> fraction -> fraction = <fun>

Out[2]:

- : fraction = {num = 9; den = 16}

Exercice

1. Écrire une fonction pour additionner deux fractions.
2. Écrire une fonction pour simplifier une fraction.

Solution

In [5]:

let add x1 x2 = { (* a/b + c/d = (a*d + b*c)/(b*d) *)
    num = (x1.num*x2.den + x1.den*x2.num);
    den = x1.den*x2.den
};;
let y = add x x;;

let simplify x = 
    let rec pgcd a b =
        if b = 0 then a
        else pgcd b (a mod b) in
    let d = pgcd x.num x.den in
    {num = x.num/d; den = x.den/d} in
simplify y;;

let add x1 x2 = { (* a/b + c/d = (a*d + b*c)/(b*d) *) num = (x1.num*x2.den + x1.den*x2.num); den = x1.den*x2.den };; let y = add x x;; let simplify x = let rec pgcd a b = if b = 0 then a else pgcd b (a mod b) in let d = pgcd x.num x.den in {num = x.num/d; den = x.den/d} in simplify y;;

Out[5]:

val add : fraction -> fraction -> fraction = <fun>

Out[5]:

val y : fraction = {num = 24; den = 16}

Out[5]:

- : fraction = {num = 3; den = 2}

L'intérêt d'utiliser des fractions plutôt que des float est de faire des calculs exacts et non pas approchés.

Exercice

1. Définir deux types enregistrements pour représenter un nombre complexe sous forme algébrique et sous forme polaire.
2. Écrire une fonction pour convertir un nombre complexe de polaire à algébrique.

Solution

In [2]:

type complexe = {re: float; im: float};;
type polaire = {r: float; theta: float};;

let polaire_to_algebrique z =
    {re = z.r *. cos z.theta; im = z.r *. sin z.theta};;
polaire_to_algebrique {r = 1.; theta = 3.14/.2.}

type complexe = {re: float; im: float};; type polaire = {r: float; theta: float};; let polaire_to_algebrique z = {re = z.r *. cos z.theta; im = z.r *. sin z.theta};; polaire_to_algebrique {r = 1.; theta = 3.14/.2.}

Out[2]:

type complexe = { re : float; im : float; }

Out[2]:

type polaire = { r : float; theta : float; }

Out[2]:

val polaire_to_algebrique : polaire -> complexe = <fun>

Out[2]:

- : complexe = {re = 0.000796326710733263345; im = 0.99999968293183461}

Mot-clé mutable¶

Par défaut, un type enregistrement n'est pas mutable (on ne peut pas modifier ses éléments).

Cependant, il est possible d'ajouter un mot-clé mutable sur un attribut. On utilise alors <- pour modifier l'attribut.

Par exemple, on pourrait redéfinir une référence comme un type enregistrement avec un seul champ mutable :

In [2]:

type 'a ref = {mutable v: 'a}

type 'a ref = {mutable v: 'a}

Out[2]:

type 'a ref = { mutable v : 'a; }

In [3]:

let a = {v = 2}  (* équivalent de let a = ref 2 *)

let a = {v = 2} (* équivalent de let a = ref 2 *)

Out[3]:

val a : int ref = {v = 2}

In [4]:

a.v  (* équivalent de !a *)

a.v (* équivalent de !a *)

Out[4]:

- : int = 2

In [5]:

a.v <- 5  (* équivalent de a := 5 *)

a.v <- 5 (* équivalent de a := 5 *)

Out[5]:

- : unit = ()