On peut définir des types adaptés à nos besoins.

Supposons que nous voulions définir un type correspondant aux coordonnées entières de points. Il nous faut un doublet d'entiers. On pourra définir :

let coords = (2 ,3) ;;
(* renvoie que coords est de type int * int *)

On peut enregistrer un type :

type coords = int * int;;

Mais ce n'est pas terrible car lors de la création

let c = (4, 7);;

c n'est pas automatiquement reconnu comme de type coords. Il faudrait utiliser :

type coords = Coords of int * int;;
let c = Coords(4,7);;

Attention : on ne met pas de majuscules où on veut. La commande

type Coords = int * int (* erreur à cause de la majuscule *)

Quand on veut qu'une variable puisse avoir plusieurs formes. Par exemple, supposons que l'on veuille faire une fonction carré acceptant des entiers ou des flottants :

type number = Int of int | Float of float;; (* type number, entier ou flottant *)
let carre = function
  | Int i -> Int(i * i)
  | Float f -> Float(f *. f);;

carre (Float 3.5) ;; (* renvoie 12.25 *)
carre (Int 3);; (* renvoie 9 *)

Exemple : On définit des types carré, rectangle losange, triangle et une fonction aire.

type figure =
  | Carre of float
  | Rectangle of float * float
  | Triangle of float * float;;
let aire = function
  | Carre a -> a *. a
  | Rectangle (a, b) -> a *. b
  | Triangle (a, b) -> a *. b /. 2.;;

Ensuite on pourrait tester

let f = (2., 5.);;
aire f;; (* erreur !*)

OCaml ne peut détecter ce qu'est f. Est-ce un rectangle ? un triangle ? Il faut écrire :

let f = Rectangle(2., 5.);;
aire f;; (* renvoie 10. *)

On veut une liste chaînée donc chaque maille est une paire avec un entier et un une flèche pointant sur le maillon suivant. Si le maillon suivant est Nil (équivalent de None`), c'est qu'on est en fin de chaîne.

type maillon = Nil | Maillon of int * maillon ;;

On peut dès lors créer la liste :

let a = Maillon(3, Nil);;
let b = Maillon(5, a);;
let c = Maillon(9, b);; (* chaîne 9 -> 5 -> 3 *)

Et on peut aussi créer une fonction `longueur` :

let rec longueur = function
  | Nil -> 0
  | Maillon (i, m) -> 1 + (longueur m);;
  
longueur c;; (* renvoie 3*)

On peut remarquer que dans la définition de longueur la variable i du cas Maillon n'était pas utilisée. On aurait pu dans ce cas l'indiquer clairement (à la façon de Lua) :

let rec longueur = function
  | Nil -> 0
  | Maillon (_, m) -> 1 + (longueur m);;

Ils sont comme des dictionnaires.

type point2D = { x : float ; y : float };;
let m = { x = 3. ; y = 4.5 };;
m.x (* renvoie l'attribut x de m *)