OCaml

Un article de Wikipédia, l'encyclopédie libre.
(Redirigé depuis Objective Caml)
Aller à : navigation, rechercher
OCaml
Logo.

Apparu en 1987 (CAML), 1996 (OCaml)
Développeur Inria
Dernière version stable 4.00.1 (le )
Paradigme multiparadigme : impérative, fonctionnelle, orientée objet
Typage Fort, statique
Dialectes JoCaml, Fresh OCaml, GCaml, MetaOCaml, OCamlDuce, OcamlP3L
Influencé par ML (langage)
A influencé F#, Opa
Système d'exploitation Multiplate-forme
Licence Q Public License (compilateur)
LGPL (bibliothèques)
Site web http://caml.inria.fr/

OCaml, anciennement connu sous le nom d'Objective Caml, est l'implémentation la plus avancée du langage de programmation Caml, créé par Xavier Leroy, Jérôme Vouillon, Damien Doligez, Didier Rémy et leurs collaborateurs en 1996. Ce langage, de la famille des langages ML, est un projet open source dirigé et maintenu essentiellement par l'Inria.

OCaml est le successeur de Caml Light, auquel il a ajouté entre autres une couche de programmation objet. L'acronyme CAML provient de Categorical Abstract Machine Language, un modèle de machine abstraite qui n'est cependant plus utilisé dans les versions récentes de OCaml.

Portable et performant, OCaml est utilisé dans des projets aussi divers que le logiciel de synchronisation de fichiers Unison ou l'assistant de preuves formelles Coq. Les facilités de traitement symbolique du langage permettent le développement d'outils de vérification statique, comme le projet SLAM[1] pour des pilotes Windows écrits par Microsoft, ou ASTRÉE pour certains systèmes embarqués des Airbus A380.

Principes[modifier | modifier le code]

Caml est un langage fonctionnel augmenté de fonctionnalités permettant la programmation impérative. OCaml étend les possibilités du langage en permettant la programmation orientée objet et la programmation modulaire. Pour toutes ces raisons, OCaml entre dans la catégorie des langages multi-paradigme.

Il intègre ces différents concepts dans un système de types hérité de ML, caractérisé par un typage statique, fort et inféré.

Le système de types permet une manipulation aisée de structures de données complexes : on peut aisément représenter des types algébriques, c'est-à-dire des types hiérarchisés et potentiellement récursifs (listes, arbres…), et les manipuler aisément à l'aide du filtrage par motif. Cela fait de OCaml un langage de choix dans les domaines demandant la manipulation de structures de données complexes, par exemple les compilateurs.

Le typage fort, ainsi que l'absence de manipulation explicite de la mémoire (présence d'un ramasse-miettes) font de OCaml un langage très sûr. Il est aussi réputé pour ses performances, grâce à la présence d'un compilateur de code natif.

Histoire[modifier | modifier le code]

Le langage Caml est né de la rencontre du langage de programmation ML, auquel s'est intéressé l'équipe Formel de l'INRIA (actuel Inria) depuis le début des années 1980, et de la machine abstraite catégorique CAM de Guy Cousineau, fondée sur les travaux de Pierre-Louis Curien en 1984. La première implantation, écrite par Ascander Suarez (à l'époque doctorant à l'Université Paris Diderot) puis maintenue par Pierre Weis et Michel Mauny, a été publiée en 1987. Le langage s'est peu à peu différencié de son père ML car l'équipe de l'INRIA voulait adapter un langage à ses propres besoins, et continuer à le faire évoluer, ce qui entrait en conflit avec la « stabilité » de ML imposée par les efforts de standardisation de Standard ML.

Les limitations de la CAM ont conduit à la création d'une nouvelle implantation, mise au point par Xavier Leroy dès 1990, sous le nom de Caml Light. Cette implantation, dont une version récente est encore utilisée dans l'enseignement de nos jours, bien que le système ne soit plus maintenu par l'Inria, fonctionne grâce à un interpréteur de code octet (bytecode) codé en C, qui lui assure une grande portabilité. Le système de gestion de la mémoire, conçu par Damien Doligez, a aussi fait son apparition dans Caml Light.

En 1995, Xavier Leroy publie une version de Caml nommée Caml Special Light, qui introduit un compilateur de code natif, et un système de modules inspiré des modules de Standard ML.

OCaml, publié pour la première fois en 1996, apporte à Caml un système objet conçu par Didier Rémy et Jérôme Vouillon. Certaines fonctionnalités avancées, comme les variantes polymorphes ou les labels (permettant de distinguer les arguments donnés à une fonction par leur nom, plutôt que leur position) ont été introduites en 2000 par Jacques Garrigue.

OCaml s'est relativement stabilisé depuis (malgré l'absence d'une spécification, le document en vigueur étant le manuel officiel maintenu par l'Inria). De nombreux dialectes de OCaml sont apparus, et continuent d'explorer des aspects spécifiques des langages de programmation (concurrence, parallélisme, évaluation paresseuse, intégration du XML…) ; voir la section Langages dérivés.

Principales caractéristiques[modifier | modifier le code]

Langage fonctionnel[modifier | modifier le code]

OCaml possède la plupart des caractéristiques communes des langages fonctionnels, en particulier des fonctions d'ordre supérieur et fermetures (closures), et un bon support de la récursion terminale.

Typage[modifier | modifier le code]

Le typage statique d'OCaml détecte au moment de la compilation un grand nombre d'erreurs de programmation qui pourraient poser des problèmes au moment de l'exécution. Toutefois, contrairement à la plupart des autres langages, il n'est pas nécessaire de préciser le type des variables que l'on utilise. En effet, Caml dispose d'un algorithme d'inférence de types qui lui permet de déterminer le type des variables à partir du contexte dans lequel elles sont employées.

Le système de typage ML supporte le polymorphisme paramétrique, c'est-à-dire des types dont des parties seront indéterminées au moment de la définition de la valeur. Cette fonctionnalité, automatique, permet d'obtenir une généricité comparable à celle des generics de Java ou C# ou des templates de C++.

Cependant, les extensions du typage ML requises par l'intégration de fonctionnalités avancées, comme la programmation orientée objet, complexifie dans certains cas le système de types : l'utilisation de ces fonctionnalités peut alors demander un temps d'apprentissage au programmeur, qui n'est pas forcément familier des systèmes de types sophistiqués.

Filtrage[modifier | modifier le code]

Le filtrage par motif en anglais : pattern matching est un élément essentiel du langage Caml. Il permet d'alléger le code grâce à une écriture plus souple que des conditions classiques, et l'exhaustivité fait l'objet d'une vérification : le compilateur propose un contre-exemple lorsqu'un filtrage incomplet est décelé. Par exemple, le code suivant est compilé mais il provoque un avertissement :

# type etat = Actif | Inactif | Inconnu;;
# (* type etat : un état est l'une des trois valeurs : Actif, Inactif, Inconnu *)
 
# let est_actif = function
  | Actif -> true
  | Inactif -> false;;
  Warning P: this pattern-matching is not exhaustive.
  Here is an example of a value that is not matched:
  Inconnu

Ainsi, le programme fonctionne lorsque la fonction est_actif est appelée avec un état valant Actif ou Inactif, mais s'il vaut Inconnu, la fonction renvoie l'exception Match_failure.

Modules[modifier | modifier le code]

Les modules permettent de décomposer le programme en une hiérarchie de structures contenant des types et des valeurs logiquement reliés (par exemple, toutes les fonctions de manipulation de listes vont dans le module List). Les descendants de la famille ML sont les langages ayant actuellement les systèmes de modules les plus perfectionnés, qui permettent, en plus de disposer d'espaces de noms, de mettre en œuvre l'abstraction (valeurs accessibles dont l'implémentation est cachée) et la composabilité (valeurs qui peuvent être construites par dessus différents modules, du moment qu'ils répondent à une interface donnée).

Ainsi, les trois unités syntaxiques de construction syntaxiques sont les structures, les interfaces et les modules. Les structures contiennent l'implémentation des modules, les interfaces décrivent les valeurs qui en sont accessibles (les valeurs dont l'implémentation n'est pas exposée sont des valeurs abstraites, et celles qui n'apparaissent pas du tout dans l'implémentation du module sont inaccessibles, à l'instar des méthodes privées en programmation orientée objet). Un module peut avoir plusieurs interfaces (du moment qu'elles sont toutes compatibles avec les types de l'implémentation), et plusieurs modules peuvent vérifier une même interface. Les foncteurs sont des structures paramétrées par d'autres structures ; par exemple, les tables de hachage (module Hashtbl) de la bibliothèque standard OCaml sont utilisables comme un foncteur, qui prend en paramètre toute structure implémentant l'interface composée d'un type, d'une fonction d'égalité entre les clés, et d'une fonction de hachage.

Orienté objet[modifier | modifier le code]

OCaml se distingue particulièrement par son extension du typage ML vers un système objet comparable à ceux utilisés par les langages objets classiques. Cela permet un sous-typage structurel, dans lequel les objets sont de types compatibles si les types de leurs méthodes sont compatibles, indépendamment de leurs arbres d'héritage respectifs. Cette fonctionnalité, que l'on peut considérer comme l'équivalent du duck typing des langages dynamiques, permet une intégration naturelle des concepts objets dans un langage globalement fonctionnel.

Ainsi, à la différence des langages orientés objet tels C++ ou Java pour lesquels toute classe définit un type, les classes OCaml définissent plutôt des abréviations de types. En effet, pour peu que le type des méthodes soient compatibles, deux objets de deux classes différentes peuvent être utilisés indifféremment dans un même contexte. Cette caractéristique de la couche objet de OCaml rompt bon nombre de principes communément admis : il est en effet possible de faire du sous-typage sans héritage, par exemple. Le côté polymorphe rompt le principe inverse. Des exemples de code, bien que rares, exhibant des cas d'héritage sans sous-typage existent également.

La force de la couche objet tient à son homogénéité et sa parfaite intégration dans la philosophie et l'esprit même du langage OCaml. Des objets fonctionnels, dont les attributs ne peuvent être modifiés et dont les méthodes, le cas échéant, en retournent une copie avec la mise-à-jour des attributs, ou encore la définition d'objets immédiats, ou à la volée, sont également possibles.

Distribution[modifier | modifier le code]

La distribution OCaml contient :

  • Un interpréteur interactif (ocaml)
  • Un compilateur bytecode (ocamlc) et l'interpréteur de bytecode (ocamlrun)
  • Un compilateur natif (ocamlopt)
  • Des générateurs d'analyseurs lexicaux (ocamllex) et syntaxiques (ocamlyacc),
  • Un préprocesseur (camlp4), qui permet des extensions ou modifications de la syntaxe du langage
  • Un débogueur pas à pas, avec retour en arrière (ocamldebug)
  • Des outils de profiling
  • Un générateur de documentation (ocamldoc)
  • Un gestionnaire de compilation automatique (ocamlbuild), depuis OCaml 3.10,
  • Une bibliothèque standard variée

Les outils OCaml sont régulièrement utilisés sous Windows, GNU/Linux ou Mac OS, mais existent aussi sur d'autres systèmes comme les BSD.

Le compilateur bytecode permet de créer des fichiers qui sont ensuite interprétés par ocamlrun. Le bytecode étant indépendant de la plate-forme, cela assure une grande portabilité (ocamlrun pouvant a priori être compilé sur toute plate-forme supportant un compilateur C fonctionnel). Le compilateur natif produit un code assembleur spécifique à la plate-forme, ce qui sacrifie la portabilité de l'exécutable produit pour des performances grandement améliorées. Un compilateur natif est présent pour les plates-formes IA32, PowerPC, AMD64, Alpha, Sparc, Mips, IA64, HPPA et StrongArm.

Une interface de compatibilité permet de lier du code OCaml à des primitives en C, et le format des tableaux de nombre flottants est compatible avec C et Fortran. OCaml permet aussi l'intégration de code OCaml dans un programme en C, ce qui permet de distribuer des bibliothèques OCaml à des programmeurs en C sans qu'ils aient besoin de connaître ou même d'installer OCaml.

Les outils OCaml sont majoritairement codés en OCaml, à l'exception de quelques bibliothèques et de l'interpréteur bytecode, qui sont codés en C. En particulier, le compilateur natif est entièrement codé en OCaml.

Gestion de la mémoire[modifier | modifier le code]

OCaml dispose, comme Java, d'une gestion automatisée de la mémoire, grâce à un ramasse-miettes incrémental générationnel. Celui-ci est spécialement adapté à un langage fonctionnel[2] (optimisé pour un rythme rapide d'allocation/libération de petits objets), n'a donc pas d'impact sensible sur les performances des programmes. Il est configurable pour rester efficace dans des situations atypiques d'utilisation de la mémoire.

Performances[modifier | modifier le code]

OCaml se distingue de la plupart des langages développés dans des milieux académiques par d'excellentes performances[3][réf. insuffisante]. En plus des optimisations locales « classiques » effectuées par le générateur de code natif, les performances profitent avantageusement de la nature fonctionnelle et statiquement et fortement typée[4] du langage.

Ainsi, les informations de typage sont complètement déterminées à la compilation, et n'ont pas besoin d'être reproduites dans le code natif, ce qui permet entre autres de retirer complètement les tests de typage au moment de l'exécution. D'autre part, certains algorithmes de la bibliothèque standard exploitent les propriétés intéressantes des structures de données fonctionnelles pures : ainsi, l'algorithme d'union d'ensembles est asymptotiquement plus rapide que celui des langages impératifs, car il utilise leur non-mutabilité pour réutiliser une partie des ensembles de départ pour constituer l'ensemble de sortie (c'est la technique de path copying pour les structures de données persistantes).

Historiquement, les langages fonctionnels ont été considérés comme lents par certains programmeurs, car ils nécessitent naturellement la mise en œuvre de concepts (récupération de la mémoire, application partielle…) qu'on ne savait pas compiler efficacement ; les progrès des techniques de compilation ont depuis permis de rattraper l'avantage initial des langages impératifs. OCaml, en optimisant efficacement ces parties du langage et en implémentant un ramasse-miettes adapté aux allocations fréquentes des langages fonctionnels, a été un des premiers langages fonctionnels à démontrer l'efficacité retrouvée de la programmation fonctionnelle.

En général, la rapidité d'exécution est légèrement inférieure à celle d'un code équivalent en C. Xavier Leroy parle prudemment de « performances d'au moins 50 % celles d'un compilateur C raisonnable »[5]. Ces prévisions ont depuis été confirmées par de nombreux benchmarks[6]. En pratique, les programmes restent en général dans cette fourchette (de 1 à 2 fois celle du code C), avec des extrêmes dans les deux directions (parfois plus rapide que le C, parfois fortement ralenti par une interaction malheureuse avec le ramasse-miettes. Dans tous les cas, cela reste plus rapide que la plupart des langages récents qui ne sont pas compilés nativement, comme Python ou Ruby, et comparable aux langages statiques compilés à la volée comme Java ou la plate-forme .NET[7].

Utilisation[modifier | modifier le code]

Le langage OCaml, issu des milieux de recherche, ne bénéficie pas de la puissance publicitaire de certains langages de programmation actuels. Il reste donc relativement peu connu du grand public informatique (ainsi que la plupart des langages fonctionnels), mais est cependant solidement implanté dans quelques niches dans lesquelles les qualités du langage contrebalancent son relatif manque de publicité et de support.

Enseignement[modifier | modifier le code]

Caml (OCaml ou son petit frère Caml Light) est le langage utilisé par la plupart des classes préparatoires françaises, dans l'optique des épreuves d'informatique des concours d'entrée aux grandes écoles ; les documents utilisés dans ce cadre[8] mettent en avant les liens entre programmation fonctionnelle et mathématiques, et l'aisance avec laquelle les langages de la famille ML manipulent les structures de données récursives, utiles pour enseigner l'algorithmique. Il est aussi utilisé dans de nombreuses universités, en France (pour des raisons historiques) mais aussi dans le reste du monde, par exemple en Allemagne, aux États-Unis ou au Japon[réf. nécessaire].

Il souffre dans le milieu universitaire de la concurrence de son cousin éloigné Haskell, préféré dans certains cours de programmation fonctionnelle car, entre autres choses, il ne reprend aucun concept de la programmation impérative.

Recherche[modifier | modifier le code]

OCaml est un langage assez utilisé dans le milieu de la recherche[9]. Historiquement, les langages de la branche ML ont toujours été étroitement lié au domaine des systèmes de preuves formelles (le ML initial de Robin Milner est ainsi apparu pour être utilisé dans le système de preuves LCF). OCaml est le langage utilisé par un des logiciels majeurs du domaine, l'assistant de preuves Coq.

OCaml est bien évidemment présent dans de nombreux autres domaines de la recherches informatiques, dont la recherche en langages de programmation et compilateurs (voir la section Langages dérivés), ou le logiciel de synchronisation de fichier Unison.

Industrie[modifier | modifier le code]

Malgré sa communication relativement timide, OCaml a acquis une solide base d'utilisateurs dans des domaines spécifiques de l'industrie. Ainsi, l'industrie aéronautique utilise OCaml pour sa sûreté de programmation et son efficacité pour la formulation d'algorithmes complexes. On peut citer dans ce domaine le projet ASTRÉE[10],[11], utilisé entre autres par la compagnie Airbus. Le compilateur du langage de programmation temps-réel synchrone Lustre, utilisé pour les systèmes critiques tels les systèmes d'avionique des Airbus ou de contrôle de certaines centrales nucléaires, est également écrit en OCaml.

OCaml est utilisé par des acteurs importants de l'industrie du logiciel, comme Microsoft ou XenSource, tous deux membres du Consortium Caml[12]. Il trouve aussi des applications dans l'informatique financière, comme l'a montré l'entreprise Jane Street Capital[13], qui emploie de nombreux programmeurs OCaml, ou encore Lexifi, entreprise française, spécialisée dans la conception de langages de programmation dédiés à la finance, ayant d'ailleurs été récompensés internationalement.

Enfin, il est aussi utilisé par des projets libres généralistes, comme MLDonkey, GeneWeb, le client pour webradios Liquidsoap, la bibliothèque FFTW[14], ainsi que certains logiciels de l'environnement de bureau KDE[15]. Enfin, les formules mathématiques du logiciel MediaWiki sont générées par un programme écrit en OCaml.

Présentation du langage[modifier | modifier le code]

Hello world[modifier | modifier le code]

Voici la syntaxe pour effectuer le traditionnel « Hello world » en OCaml :

let _ =
  print_string "Hello world!\n";
  exit 0

On peut également utiliser la fonction printf mappée depuis le langage C :

let _ =
  Printf.printf "Hello world!\n";
  exit 0

Déclarations et valeurs de base[modifier | modifier le code]

En mode interactif le code peut être entré simplement à la suite de l'invite « # » qui figure en début de ligne. Par exemple, pour définir une variable x contenant le résultat du calcul 1 + 2 * 3, on écrira :

# let x = 1 + 2 * 3 ;;

Après avoir saisi et validé cette expression, Caml détermine le type de l'expression (en l'occurrence, il s'agit d'un entier) et affiche le résultat du calcul :

val x : int = 7

On peut être tenté d'effectuer toutes sortes de calculs. Cependant, il faut prendre garde à ne pas mélanger les entiers et les réels, ce que l'on fait couramment dans de nombreux langages, car ceci provoque une erreur lors de la compilation :

  # 2.3 + 1.;;
    Characters 0 - 3:
     2.3 + 1.;;
     ^^
    This expression has type float but is here used with type int  

Cet exemple simple permet de se faire une première idée du fonctionnement de l'algorithme d'inférence de types. En effet, lorsque nous avons écrit « 2.3 + 1. », nous avons ajouté les réels 2.3 et 1. avec l'operateur + des entiers, ce qui pose problème. En fait, pour effectuer ce calcul, nous devons nous assurer que tous les nombres ont le même type d'une part (par exemple il est impossible d'ajouter 2.3 et 1 car 1 est un entier contrairement à 1. ou 2.3), et d'autre part employer la loi de composition interne + appliquée aux réels, notée « +. » en Caml. Nous aurions donc dû écrire :

# 2.3 +. 1. ;;
- : float = 3.3

Fonctions[modifier | modifier le code]

Les programmes sont souvent structurés en procédures et en fonctions. Les procédures sont composées d'un ensemble de commandes utilisées plusieurs fois dans le programme, et regroupées par commodité sous un même nom. Une procédure ne renvoie pas de valeur, ce rôle étant dévolu aux fonctions. De nombreux langages disposent de mots-clefs distincts pour introduire une nouvelle procédure ou une nouvelle fonction (Procedure et Function en Pascal, Sub et Function en Visual Basic, etc.). Caml, quant à lui, ne possède que des fonctions, et celles-ci se définissent de la même manière que les variables. Par exemple, pour définir l'identité, on peut écrire :

# let id = function x -> x ;;

Après saisie et validation de l'expression, l'algorithme de synthèse de types détermine le type de la fonction. Cependant, dans l'exemple que nous avons donné, rien ne présage du type de x, aussi la fonction apparaît-elle comme polymorphe (à tout élément de l'ensemble 'a, elle associe une image id(x) qui est élément de l'ensemble 'a) :

val id : 'a -> 'a = <fun>

Récursivité[modifier | modifier le code]

La récursivité consiste à rédiger une fonction qui fait référence à elle-même, sur le modèle de la récurrence mathématique. En Caml, les fonctions récursives sont introduites à l'aide du mot-clef rec. Par exemple, pour définir la factorielle, nous pouvons écrire :

let rec factorielle = function
    | 0 -> 1
    | n -> n * factorielle (n - 1) ;;

Définitions internes[modifier | modifier le code]

Il est possible de définir des valeurs ou des fonctions à l'intérieur d'une fonction. On utilise pour cela la syntaxe suivante :

# let factorielle n =
    let rec auxiliaire resultat = function
       | 0 -> resultat
       | n -> auxiliaire (n * resultat) (n - 1)
     in auxiliaire 1 n ;;

Récursivité terminale, appels terminaux[modifier | modifier le code]

Le compilateur OCaml optimise les appels terminaux : quand, pendant l'évaluation d'une fonction, la dernière étape à effectuer est l'appel d'une (autre) fonction, OCaml saute directement à cette nouvelle fonction sans conserver en mémoire l'appel de la première, devenu inutile.

En particulier, OCaml optimise la récursion terminale. Par exemple, la deuxième fonction factorielle ci-dessus (avec un paramètre auxiliaire résultat) est une fonction terminale, équivalente à une boucle, et produira un résultat équivalent, égalant ainsi les performances du code impératif correspondant.

La récursion terminale est aussi performante que l'itération ; elle est donc à préférer quand elle permet d'écrire des programmes plus clairs ou plus faciles à manipuler[16].

Manipulation de listes[modifier | modifier le code]

Les listes sont très utilisées en programmation, en particulier pour les traitements récursifs. Pour construire une liste, plusieurs écritures sont possibles :

# 1 :: 2 :: 3 :: [] ;;
# [1 ; 2 ; 3] ;;

Ce faisant, on obtient une liste d'entiers, que Caml note de la façon suivante :

- : int list = [1 ; 2 ; 3]

Pour connaître la longueur d'une liste sans utiliser la fonction du module List définie à cet effet, on peut écrire :

(* Longueur d'une liste *)
# let rec longueur = function
      [] -> 0
    | t :: q -> 1 + longueur q ;;

Lors de l'analyse de cette fonction par l'algorithme d'inférence de type, il apparaît que la liste peut contenir n'importe quel type de données, de sorte que la fonction possède le type suivant :

val longueur : 'a list -> int = <fun>

La fonction suivante crée une liste de couples à partir de deux listes : La longueur de cette liste sera égale à la longueur de la liste passée en paramètre qui est la plus courte.

# let rec couple l1 l2 =
    match (l1, l2) with
      ([],_) | (_,[]) -> []
    | (a :: q, b :: p) -> (a, b) :: couple q p;;

Le caractère _ indique que le premier (ou le deuxième) élément du couple n'a pas d'importance (il suffit qu'une des deux listes du couple soit vide pour que la fonction se termine).

(* Typage *)
val couple : 'a list -> 'b list -> ('a * 'b) list = <fun>

Le type des éléments de chaque liste n'est pas forcément le même : 'a et 'b. On peut donc avoir (int list) et (float list) pour former (int * float) list

Fonctions d'ordre supérieur[modifier | modifier le code]

Les fonctions d'ordre supérieur sont des fonctions qui prennent une ou plusieurs fonctions en entrée et/ou renvoient une fonction. La plupart des langages fonctionnels possèdent des fonctions d'ordre supérieur. Concernant Caml, on peut en trouver des exemples dans les fonctions prédéfinies des modules Array, List, etc. Par exemple, l'expression suivante :

# List.map (fun i -> i * i) [0; 1; 2; 3; 4; 5] ;;

produira le résultat suivant :

- : int list = [0; 1; 4; 9; 16; 25]

La fonction map prend en argument la fonction anonyme qui, à tout entier i, associe son carré, et l'applique aux éléments de la liste, construisant ainsi la liste des valeurs élevées au carré.

Autre exemple :

let double f i = f (f i)

La fonction double prend en paramètre une fonction f et une valeur i et applique deux fois f à i.

let trois = double (fun i -> i+1) 1
 
(* renvoie la fonction "incrémentation de 2" *)
let augmente_2 = double (fun i -> i+1)
 
(* renvoie [3;2;3] *)
let liste = double (function [] -> [] | e::l -> (e+1)::l) [1;2;3]

Voici encore un exemple :

let rec parcours f e = function
  [] -> e
  | x::l -> f x (parcours f e l)
 
(* Exemple d'application *)
(* la somme des éléments de la liste [1;1;2] *)
let somme = parcours (+) 0 [1;1;2]
 
(* une fonction calculant la somme des éléments (int) d'une liste *)
let fonction_somme = parcours (+) 0
 
(* une fonction calculant le produit des éléments (float) d'une liste *)
let fonction_produit = parcours ( *. ) 1.

Enfin, un dernier exemple. Ici, on se charge de définir un nouvel opérateur noté '$'. Cette opérateur effectue la composée de deux fonctions.

let ( $ ) f g =
  fun x -> f (g x)
(* val ( $ ) : ('a -> 'b) -> ('c -> 'a) -> ('c -> 'b) = <fun> *)
 
let f x = x * x
let g x = x + 3
 
let h = f $ g
 
print_int (h 3)
(* Affiche 36. *)

Arbres et types récursifs[modifier | modifier le code]

Pour définir un arbre binaire de type quelconque, on se sert d'un type récursif. On peut ainsi avoir recours à l'écriture suivante :

type 'a arbre =
  Feuille
| Branche of 'a arbre * 'a * 'a arbre;;

Cet arbre se compose de branches qui se ramifient à souhait, et se terminent par des feuilles. Pour connaître la hauteur d'un arbre, on utilise alors :

 
let rec hauteur = function
  Feuille -> 0
| Branche (gauche, _, droite) -> 1 + max (hauteur gauche) (hauteur droite);;

Recherche de racine par dichotomie[modifier | modifier le code]

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)

Mémoïsation[modifier | modifier le code]

Voici un exemple de fonction qui utilise la mémoïsation. Il s'agit d'une fonction qui calcule le n-ième terme de la suite de Fibonacci. Contrairement à la fonction récursive classique, celle-ci mémorise les résultats et peut les ressortir en temps constant grâce à la table de hachage.

(* Taille de la table de hachage. *)
let _HASH_TABLE_SIZE = 997
 
(* Retourne le n-ième terme de la suite de Fibonacci. *)
let rec fibo =
  (* Pré-définitions. Ce code est exécuté une fois lors de la définition de la
     fonction, mais ne l'est pas à chaque appel. Cependant, `h` reste dans
     l'environnement de cette fonction pour chaque appel. *)
  let h = Hashtbl.create _HASH_TABLE_SIZE in
  (* Premiers termes. *)
  Hashtbl.add h 0 0;
  Hashtbl.add h 1 1;
  function
    | n when n < 0 -> invalid_arg "fibo" (* Pas de nombre négatif. *)
    | n ->
      try
        Hashtbl.find h n (* On a déjà calculé `fibo n`, on ressort donc le
                            résultat stocké dans la table `h`. *)
      with
          Not_found ->                 (* Si l'élément n'est pas trouvé, ... *)
            let r = fibo (n - 1) + fibo (n - 2) in (* ... on le calcule, ... *)
            Hashtbl.add h n r;                     (* ... on le stocke, ...  *)
            r                                (* ... et on renvoie la valeur. *)

Dérivation d'un polynôme[modifier | modifier le code]

On se propose ici d'implémenter une fonction simple permettant de dériver un polynôme de degré quelconque. Il faut d'abord spécifier le type qui représentera notre polynôme :

type polyn =
  | Num of float         (* constante      *)
  | Var of string        (* variable       *)
  | Neg of polyn         (* négation       *)
  | Add of polyn * polyn (* addition       *)
  | Sub of polyn * polyn (* soustraction   *)
  | Mul of polyn * polyn (* multiplication *)
  | Div of polyn * polyn (* division       *)
  | Pow of polyn * int   (* exponentiation *)

Maintenant, voici la fonction qui dérive ce polynôme par rapport à la variable x spécifiée en paramètre.

let rec deriv x = function
  | Num _ -> Num 0.
  | Var y when y = x -> Num 1.
  | Var _ -> Num 0.
  | Neg p -> Neg (deriv x p) (* -p' *)
  | Add (p, q) -> Add (deriv x p, deriv x q) (* p' + q' *)
  | Sub (p, q) -> Sub (deriv x p, deriv x q) (* p' - q' *)
  | Mul (p, q) -> Add (Mul (deriv x p, q), Mul (p, deriv x q)) (* p'q + pq' *)
  | Div (p, q) -> Div (Sub (Mul (deriv x p, q), Mul (p, deriv x q)), Pow (q, 2)) (* (p'q - pq') / q² *)
  | Pow (p, 0) -> Num 0.
  | Pow (p, 1) -> deriv x p
  | Pow (p, n) -> Mul (Num n, Mul (deriv x p, Pow (p, n - 1))) (* n * p' * p^(n-1) *)

Différentes cibles de compilation[modifier | modifier le code]

L'implémentation OCaml a été adaptée par d'autres auteurs à des cibles de compilation autres que le bytecode et le code natif. On trouvera:

  • OCaml-Java, une distribution pour la JVM contenant ocamlc, ocamlrun, ocamldep, ocamldoc, ocamllex, menhir, un compilateur ocamljava vers la JVM.
  • OCamIL, un prototype de backend pour l'environnement .NET. Elle contient un compilateur vers du bytecode OCaml (exécutable par ocamlrun), un compilateur vers .NET et un outil comme ocamlyacc nommé ocamilyacc.

Langages dérivés[modifier | modifier le code]

De nombreux langages étendent OCaml pour lui ajouter des fonctionnalités un peu plus exotiques.

  • F# est un langage de la plateforme .NET développé par Microsoft Research, basé sur OCaml (et en partie compatible)
  • MetaOCaml ajoute un mécanisme de quotations et de génération de code au runtime, qui apporte des fonctionnalités de métaprogrammation à OCaml
  • Fresh OCaml (basé sur AlphaCaml, un autre dérivé de OCaml) facilite la manipulation de noms symboliques
  • JoCaml ajoute à OCaml un support du Join Calculus, orienté vers les programmes concurrents ou distribués
  • OcamlP3L apporte une forme particulière de parallélisme, basée sur les « squelettes » (skeleton programming)
  • GCaml ajoute le polymorphisme ad-hoc à OCaml, permettant la surcharge des opérateurs ou un marshalling conservant les informations de typage
  • OCamlDuce permet au système de types de représenter des valeurs XML ou liées à des expressions régulières. C'est un intermédiaire entre OCaml et le langage CDuce, spécialisé dans la manipulation du XML
  • Opa est un langage de développement d'applications et services web implanté en OCaml et dont le noyau reprend les fonctionnalités du langage OCaml. Par ailleurs, le compilateur Opa utilise le backend du compilateur OCaml pour générer des serveurs natifs.

Notes et références[modifier | modifier le code]

  1. Quelques succès d'OCaml : SLAM
  2. « Les programmes fonctionnels sont des programmes qui allouent en général beaucoup et on constate que de très nombreuses valeurs ont une durée de vie très courte. D'autre part, dès qu'une valeur a survécu à plusieurs GC, elle a de grandes chances d'exister pour un bon moment » — Développement d'applications avec Objective Caml
  3. « Generating efficient machine code has always been an important aspect of OCaml, and I spent quite a bit of work on this at the beginning of the OCaml development (95-97). Nowadays, we are largely satisfied with the performances of the generated code. » — Xavier Leroy, sur la mailing list caml
  4. « Guarantees provided by the type system can also enable powerful program optimizations. » — Xavier Leroy, Introduction to types in compilation
  5. (en) mailing list thread : « Our blanket performance statement "OCaml delivers at least 50 % of the performance of a decent C compiler" is not invalidated :-) »
  6. (en) shootout : OCaml vs. C benchmark
  7. comparaison de performances entre ocamlopt et C# Mono
  8. Enseignement de la programmation avec Caml
  9. Citeseer: une liste d'article de recherche utilisant Caml
  10. Site du projet ASTRÉE, consulté sur www.astree.ens.fr le
  11. « Interprétation abstraite :application aux logiciels de l’A380 », Patrick Cousot, consulté sur www.di.ens.fr le
  12. Consortium Caml
  13. Jane Street Capital
  14. La bibliothèque FFTW, réalisant une Transformée de Fourier rapide, est constituée de code en langage C. Cependant, pour des raisons de performances, le code C est généré et optimisé automatiquement par un compilateur, genfft, écrit en OCaml. Le processus de génération et spécialisation des routines est décrit dans l'article A Fast Fourier Transform Compiler, de Matteo Frigo (MIT) [lire en ligne (page consultée le 9 décembre 2007)]. On trouve dans la documentation FFTW une appréciation concernant l'utilisation de OCaml : « The genfft suite of code generators was written using Objective Caml, a dialect of ML. Objective Caml is a small and elegant language developed by Xavier Leroy. The implementation is available from http://caml.inria.fr/. In previous releases of FFTW, genfft was written in Caml Light, by the same authors. An even earlier implementation of genfft was written in Scheme, but Caml is definitely better for this kind of application. » — FFTW Acknowledgments
  15. Page du composant EqChem du logiciel Kalzium
  16. Un programme utilisant des appels terminaux est souvent plus lisible qu'une itération équivalente quand le motif de sauts est complexe. Par exemple, on peut décrire un automate comme un ensemble de fonctions de transitions effectuant des appels terminaux (ou des sauts goto dans les langages impératifs) vers les autres états de l'automate. Dans ce cas, les appels terminaux permettent une plus grande flexibilité, comme montré dans l'article (en) Automatas Via Macros.

Voir aussi[modifier | modifier le code]

Sur les autres projets Wikimedia :

Articles connexes[modifier | modifier le code]

Liens externes[modifier | modifier le code]