Le langage OCaml

En C, if est une instruction : elle fait quelque chose. En OCaml, if est une expression : elle vaut quelque chose.

let m = if a > b then a else b     (* m reçoit la VALEUR de l'expression *)

Conséquence immédiate : le else n'est pas facultatif quand la valeur est utilisée — une expression doit valoir quelque chose dans tous les cas. Et les deux branches doivent avoir le même type, car l'expression entière n'en a qu'un.

let x = 3                     (* définition globale *)
let y = x + 1 in y * 2        (* définition locale : y n'existe que dans « y * 2 » *)

let carre x = x * x           (* une fonction : pas de parenthèses, pas de return *)
let rec fact n =              (* rec : la fonction peut s'appeler elle-même *)
  if n = 0 then 1 else n * fact (n - 1)

let ... in ... est lui-même une expression : il vaut son second membre.

Vous n'écrivez pas les types ; le compilateur les trouve.

let double x = 2 * x
(* le compilateur répond : val double : int -> int = <fun> *)

Il a raisonné ainsi : * est la multiplication des entiers, donc x est un int, donc le résultat aussi. La notation int -> int se lit « d'int vers int ».

Quand rien ne contraint le type, il reste variable :

let identite x = x            (* val identite : 'a -> 'a *)
let premier (a, b) = a        (* val premier : 'a * 'b -> 'a *)

'a se lit « alpha » et désigne n'importe quel type. Une seule fonction sert alors pour tous les types — c'est le polymorphisme, dont l'annexe demande une « idée naïve ».

let rec longueur liste =
  match liste with
  | [] -> 0                      (* motif : la liste vide *)
  | _ :: reste -> 1 + longueur reste   (* motif : une tête, et un reste *)

Chaque motif décrit une forme possible de la valeur, et le premier qui correspond l'emporte. Le motif _ désigne « n'importe quoi, dont je n'ai pas besoin ».

let p = (3, "trois", 3.0)      (* type : int * string * float *)
let (a, b, c) = p              (* on récupère les composantes SANS match *)

Une liste OCaml est immuable et simplement chaînée. Deux constructeurs seulement : [] la liste vide, et :: qui ajoute une tête.

let l = 1 :: 2 :: 3 :: []      (* équivaut à [1; 2; 3] *)
List.length l                  (* 3 *)
l @ [4; 5]                     (* concaténation *)

Là où la liste est immuable et chaînée, le tableau est mutable et à accès direct.

let t = [| 3; 1; 4 |]          (* type : int array *)
let u = Array.make 10 0        (* 10 cases, toutes à 0 *)
t.(0)                          (* lecture : 3 *)
t.(0) <- 7                     (* écriture : la flèche gauche MODIFIE *)
Array.length t                 (* 3 *)

type couleur = Trefle | Carreau | Coeur | Pique      (* type énuméré *)

type forme =                                          (* type somme : chaque cas
                                                         porte ses propres données *)
  | Cercle of float
  | Rectangle of float * float

let aire f =
  match f with
  | Cercle r -> 3.14159 *. r *. r
  | Rectangle (l, h) -> l *. h

Les constructeurs commencent par une majuscule, les identifiants par une minuscule.

type 'a arbre =
  | Vide
  | Noeud of 'a arbre * 'a * 'a arbre

let rec taille a =
  match a with
  | Vide -> 0
  | Noeud (g, _, d) -> 1 + taille g + taille d

Quatre lignes pour le type, quatre pour la fonction. En C, il fallait une structure, un pointeur, un malloc par nœud et un free pour chacun. C'est ce que le programme appelle « manipuler facilement des structures de données récursives », et c'est la raison pour laquelle toute la partie « arbres » du programme se lit mieux en OCaml.

type 'a option = None | Some of 'a     (* prédéfini *)

(* Renvoie Some v si la clé figure dans l'association, None sinon. *)
let rec cherche cle assoc =
  match assoc with
  | [] -> None
  | (c, v) :: reste -> if c = cle then Some v else cherche cle reste

option rend l'absence de résultat visible dans le type. Là où C rendait NULL — que rien n'oblige à tester —, OCaml rend une valeur que le filtrage oblige à décomposer.

Une fonction OCaml à plusieurs arguments est en réalité une fonction à un argument qui rend une fonction. C'est la curryfication, et elle se lit dans le type :

let ajoute x y = x + y        (* val ajoute : int -> int -> int *)
let incr = ajoute 1           (* val incr : int -> int  — application PARTIELLE *)

Une fonction qui prend ou rend une fonction est dite d'ordre supérieur. List.map en est une : son type ('a -> 'b) -> 'a list -> 'b list annonce qu'elle attend une fonction en premier argument.

let double = fun x -> 2 * x           (* fonction anonyme *)
List.map (fun x y -> x + y) [1; 2]    (* deux arguments, sans nom *)

let rec pair n   = n = 0 || impair (n - 1)   (* let rec … and … : *)
and     impair n = n <> 0 && pair (n - 1)    (* les deux se voient l'une l'autre *)

String.length "chien"      (* 5 *)
"chi" ^ "en"               (* concaténation *)
"chien".[0]                (* le caractère 'c' *)

Les chaînes sont immuables : on ne peut pas écrire dans s.[i]. Et char porte un ordre total, donc les comparaisons < et > y ont un sens.

print_int 42; print_string "\n"; print_float 3.14
let n = read_int ()          (* aussi read_float, read_line *)

if c then begin              (* begin … end groupe plusieurs expressions *)
  print_string "oui";        (* là où la syntaxe n'accepterait qu'une seule *)
  incr compteur
end

begin ... end est un synonyme exact de la parenthèse ; on l'emploie quand le bloc tient sur plusieurs lignes, où il se lit mieux.

let compteur = ref 0        (* une CASE modifiable, de type int ref *)
compteur := !compteur + 1   (* := écrit,  ! lit *)

let somme t =
  let s = ref 0 in
  for i = 0 to Array.length t - 1 do
    s := !s + t.(i)
  done;
  !s

let attendre c =                (* pas de « rec » : rien ne s'appelle soi-même *)
  while !c > 0 do c := !c - 1 done

Le point-virgule sépare deux expressions : il évalue la première, jette sa valeur, et rend la seconde. Le type unit, dont l'unique valeur s'écrit (), est celui des expressions qu'on évalue pour leur effet et non pour leur valeur.

let division a b =
  if b = 0 then raise Division_by_zero else a / b

let sur a b =
  try Some (division a b) with Division_by_zero -> None

let jamais () = failwith "cas impossible"   (* pour l'irrattrapable *)

Le programme met en garde, et c'est une remarque de fond : « on veille à ne pas laisser penser que les exceptions servent uniquement à gérer des erreurs ». Une exception est aussi une sortie anticipée légitime — trouver un élément et quitter la boucle sur-le-champ, par exemple.