Le langage fonctionnel Caml

Les expressions contenues dans un module peuvent faire appel soit à des noms internes, définis dans ce module, soit à des noms externes définis dans d'autres modules. Rien n'interdisant à des modules différents de contenir des entités de même nom, une entité ne peut être identifiée que par un couple « nom du module, nom interne au module ». En Caml, un tel couple est appelé nom complet (ou nom qualifié ) et est noté m __ n où m est le nom du module et n est le nom interne au module appelé nom abrégé (ou nom non qualifié ). Par exemple, int__minus désigne le nom minus du module int qui est un module de la bibliothèque de base de Caml.

On pourrait imposer que seuls les noms complets soient employés dans les programmes, mais ce serait très lourd. Pour l'éviter Caml offre un mécanisme d'ouverture de module qui permet le plus souvent de n'employer que les noms abrégés, leur complétion étant automatiquement effectuée par Caml. Ce mécanisme est le suivant :

• pour utiliser le nom abrégé d'une entité dans le texte source d'un module il faut au préalable ouvrir le module qui contient cette définition.
• un module est explicitement ouvert par la directive #open m où m est le nom du module et fermé par la directive #close m . Pour faciliter la tâche du programmeur, Caml ouvre automatiquement avant l'analyse d'un module, le module à analyser ainsi que les modules de la bibliothèque qui sont le plus utilisés.
• lorsque Caml rencontre un nom abrégé, il le complète par le nom du premier module ouvert qui définit ce nom, en parcourant ces modules dans l'ordre suivant : le module en cours d'analyse, les modules explicitement ouverts dans l'ordre de leur ouverture, les modules de bibliothèque ouverts dans un ordre défini lors de l'installation de Caml.

Les règles d'emploi des noms abrégés dans le texte d'un module, impliquées par ce mécanisme sont les suivantes :

• toutes les entités du module en cours d'écriture peuvent être désignées par leur nom abrégé. Cette règle est tout à fait naturelle. Elle a été appliquée implicitement, dans tous les chapitres précédents, pour le module top ;
• toutes les entités d'un module ouvert peuvent être désignées par leur nom abrégé, s'il n'existe pas d'entité de même nom dans un module explicitement ouvert préalablement. Il y a donc intérêt à ouvrir en premier le module le plus utilisé ;
• toutes les entités d'un module de bibliothèque peuvent être désignées sous leur nom abrégé, s'il n'existe pas d'entité de même nom dans les modules explicitement ouverts ou bien dans les modules de bibliothèque ouverts préalablement. Une conséquence de cette règle est la possibilité de redéfinir les primitives de la bibliothèque tout en conservant leur désignation. La fonction prédéfinie min, par exemple, choisit le plus petit de deux entiers. On peut la redéfinir dans le module top pour qu'elle choisisse le plus petit entier d'une liste non vide d'entiers :

#min;;
- : int -> int -> int = <fun>
#min 2 1;;
- : int = 1
#let rec min = function
    | [] -> failwith "min est inapplicable"
    | [n] -> n
    | n::l -> int__min n (min l);;
min : int list -> int = <fun>
#min [3; 1; 2];;
- : int = 1

• Dans les autres cas, les définitions devront être désignées par leur nom complet. C'est le cas de int__min dans le programme précédent.

Les entités définies dans un module peuvent être classées en deux catégories : les entités publiques qui sont destinées à être utilisées par d'autres modules et les entités privées qui servent uniquement à définir les premières et qui sont cachées aux autres modules. Considérons, par exemple, un module contenant les formules permettant de calculer le volume de divers objets géométriques (sphères, cylindres, prismes, etc.). Pour définir ces formules il peut être nécessaire d'utiliser des constantes (π par exemple) ou des définitions intermédiaires (la surface de base d'un cylindre, par exemple) qui ne doivent pas être visibles dans les autres modules. =

Pour distinguer entre entités publiques et entités privées, Caml décompose un module en deux parties :

• l' interface , qui est formée par les signatures des noms de valeurs et par les définitions des types et des exceptions publiques. La signature d'un nom de valeur est une phrase de la forme :

value n : t;;

• l' implémentation , qui est formée par les définitions des noms de valeur et celles des types et des exceptions privées.

Le fichier contenant l'implémentation d'un module de nom m doit avoir pour nom m .ml et celui contenant son interface m .mli.

Par exemple, dans le module cercle on peut vouloir cacher la valeur pi et exporter le type cercle et les fonctions périmètre et surface. En ce cas l'interface, enregistrée dans le fichier cercle.mli contiendra les phrases :

type cercle = {Rayon: float};;
value périmètre cercle -> float;;
value surface cercle -> float;;

et l'implémentation, enregistrée dans le fichier cercle.ml, les phrases :

let pi = 3.14;;
let périmètre {Rayon = r} = 2. *. pi *. r;;
let surface {Rayon = r} = pi *. r *. r;;

L'interface par défaut d'un module est constituée de toutes les définitions contenues dans ce module.

Interface et implémentation d'un module sont destinés à être compilés. Il faut pour cela appliquer la fonction prédéfinie compile au nom du fichier correspondant. Par exemple :

#compile "cercle.mli";;
- : unit = ()
#compile "cercle.ml";;
- : unit = ()

La compilation de l'interface d'un module m produit le fichier m .zi, dit fichier d ' interface compilée et celle de l'implémentation produit le fichier m .zo, dit fichier de code objet . Par exemple cercle.zi et cercle.zo pour le module cercle.

Le fichier d'interface compilée contient les informations sur les types des entités déclarées dans le fichier d'interface. Ce fichier est indispensable pour compiler les modules qui font appel aux entités publiques de m . Quant au fichier de code objet, il contient le code compilé des valeurs définies dans le fichier d'implémentation.

Pour charger en mémoire un module non compilé et l'exécuter il faut appliquer la fonction prédéfinie load au nom de son fichier source. Par exemple :

#load "un_deux_trois";;
un : int = 1
deux : int = 2
trois : int = 3
- : unit = ()

Pour faire de même avec un module compilé, il faut appliquer la fonction prédéfinie load_object au nom de son fichier de code objet. Par exemple :

#load_object "cercle.zo";;
- : unit = ()

(si l'extension .zo est omise elle automatiquement rajoutée).

Attention ! pour que les définitions des modules chargés soient visibles il faut au préalable ouvrir le module :

#un;;
Toplevel input:
>un;;
>^^
The value identifier un is unbound.
##open "un_deux_trois";;
#un;;
- : int = 1

Travailler en mode interactif est équivalent à charger de façon incrémentale le module top qui, comme nous l'avons vu, contient toutes les définitions entrées au clavier ou par une inclusion de fichier (include).

Au démarrage d'une session interactive, Caml charge automatiquement tous les modules de la bibliothèque standard. Il ouvre aussi un certain nombre de modules comme nous l'avons expliqué au §VII.B.1.