Objective Caml

Un article de Freepedia.

(Redirigé depuis OCaml)

Image:Langage progr.png

Cet article fait partie de la série
Langages de programmation

Langages à objets

Ada 95 - C++ - C#
Common Lisp
Delphi - Eiffel - Java
Nice - Oz - Python
Ruby - Simula - Lisaac
Smalltalk - Visual Basic

Langages impératifs

APL - ASP - Assembleur
BASIC - C - Cobol
Forth - Fortran - Logo
OPL - Pascal - Perl - PHP

Langages fonctionnels

Erlang - Haskell
ML/OCaml - Oz
Lisp/Common Lisp
Scheme

Langages déclaratifs

Clips - Oz - Prolog

Langages concurrents

Ada 95 - Erlang
Java - Oz

Langages balisés

HTML - SGML - XML
Dialectes XML
S-expressions

Voir aussi

Conception - Codage
Tests - Optimisations

Le langage Objective Caml, aussi appelé Ocaml ou encore O'Caml, est un langage de programmation avancé de la famille des langages ML, développé et distribué par l'INRIA, projet Cristal.

Il permet aussi bien la programmation impérative que la programmation fonctionnelle. Ocaml est la principale implémentation du langage Caml (acronyme qui signifiait à l'origine Categorical Abstract Machine Language). Il représente une évolution de l'implémentation légère Caml Light auquel il ajoute les concepts de la programmation orientée objet et de la programmation modulaire, ainsi que des améliorations syntaxiques.

Le code source peut aussi bien être compilé en code intermédiaire (ou bytecode) à l'instar de Java ou en code natif pour de nombreuses architectures, dont IA32, IA64, PowerPC, AMD64, Sparc, Alpha, HP/PA, MIPS et StrongARM. Le compilateur natif est réputé pour sa grande efficacité, comparable à celle des compilateurs C++.

Objective Caml dispose d'un typage statique et automatique avec inférence de types, de fonctions de première classe, du polymorphisme paramétrique, du pattern matching, de la fermeture lexicale, d'une gestion d'exceptions, et d'une gestion de mémoire automatisée. L'implémentation du ramasse-miettes (garbage collector en anglais) de type incrémental générationnel est particulièrement performante. À cela s'ajoute un système de modules récursifs et paramétrables ainsi qu'un système de classes évolué. Toutes ces caractéristiques, associées à un préprocesseur perfectionné, rendent le langage particulièrement expressif et sûr.

Bien que beaucoup utilisé pour l'enseignement de la programmation, et la recherche, l'orientation généraliste d'Objective Caml ainsi qu'une base de bibliothèques importante lui trouvent des applications dans de nombreux domaines : bioinformatique, base de donnée généalogique, jeux, compilateurs, système de preuve formelle, serveurs internet, création de prototypes, etc.

Exemples de code

Manipulation de listes

 (* Les exemples ci-dessous fonctionnent sur des listes de n'importe quel type *)
 
 (* Longueur d'une liste *)
 let rec longueur  = function
   | [] -> 0
   | x :: xs -> 1 + longueur xs;;

 (* Tri d'une liste par insertion *)
 (* Une relation d'ordre doit être définie *)
 let rec trie = function
   | [] -> []
   | x :: xs -> insere x (trie xs)
 and insere e = function
   |[] -> [e]
   | x :: xs -> if x > e 
             then e :: x :: xs 
             else x :: (insere e xs);;

 (* Tri rapide (quicksort ou tri de Hoare) d'une liste *)
 let rec qsort = function
   | [] -> []
   | x :: l -> 
     let rec coupelist = function
       | [] -> [], []
       | y :: m -> let a, b = coupelist m in
         if y < x then y :: a, b else a, y :: b
     in let debut, fin = coupelist l
   in (qsort debut) @ [x] @ (qsort fin);;

 # let l = ["La"; "vie"; "est"; "un"; "long"; "fleuve"; "tranquille"];;
 - : string list = ["La"; "vie"; "est"; "un"; "long"; "fleuve"; "tranquille"]

 # longueur l;;
 - : int = 7

 # trie l;;
 - : string list = ["La"; "est"; "fleuve"; "long"; "tranquille"; "un"; "vie"]

Arbres

 (* Définition d'un arbre binaire, d'un type quelconque 'a *)
 type 'a arbre = Noeud | Arbre of ('a arbre * 'a * 'a arbre);;

 let a = Arbre(Noeud, 4, Arbre(Noeud, 2, Noeud));;
 
 (* Hauteur de l'arbre *)
 let rec hauteur = function
   |Noeud -> 0
   |Arbre(gauche, _, droit) -> 1 + max (hauteur gauche) (hauteur droit)  ;;
 
 # hauteur a;;
 - : int = 2

Recherche de racine par dichotomie

 let rec dicho f min max eps =
   let fmin = f min and fmax = f max in
     if fmin *. fmax > 0.
     then failwith "Aucune racine"
     else if max -. min < eps then (min, max) (* retourne un intervalle *)
     else let mil = (min +. max) /. 2. in
       if (f mil) *. fmin < 0.
       then dicho f min mil eps
       else dicho f mil max eps ;;

 (* Approximation de la racine carrée de 2 *)
 # dicho (fun x -> x *. x -. 2.) 0. 10. 0.000000001;;
 - : float * float = (1.4142135618, 1.41421356238)