CAML est langage fonctionnel fortement typé. Il
s'utilise en mode interprété ou peut être compilé.
On reconnait qu'on est sous CAML par le prompt #. Pour
valider une entrée sous CAML , qui peut être écrite sur
plusieurs lignes, on écrit ;; .
Pour quitter CAML , on tape quit();; - attention : les
parenthèses () et les ;; sont obligatoires.
Les commentaires en CAML commencent par (* et finissent
par *).
On se méfiera du fait que CAML distingue majuscules et
minuscules. Les identificateurs commencent par une
lettre.
LES LIAISONS
Au lieu d'une affectation traditionnelle, CAML utilise
des liaisons. Une liaison se fait par let . Ainsi
# let matin = 6 ;;
associe la valeur 6 à l'identificateur matin. De façon
technique, le couple (nom,valeur) est ajouté à
l'environnement de départ.
Une variable caractère est liée par '' et une
chaine par "" . A la suite de la liaison précédente
et des liaisons:
# let reveil = 'h' ;;
# let matin = "6 heures" ;;
L'environnement est [ (matin,"6 heures"),(reveil,'h'),(matin,6)...]
où ... désigne l'environnement initial. La liaison actuelle pour
un identificateur est la plus à gauche dans l'environnement.
Les liaisons peuvent être simultanées avec and :
# let nbh = 6 and jbc = 5 ;;
On peut lier des variables entre elles :
(* après les liaisons précédentes *)
# let broc = nbh + 1 ;;
Mais la liaison est statique ; après la nouvelle liaison
# let nbh = 0 ;;
l'affichage avec print_int montre que broc contient 7 (à
savoir 6 + 1) et non pas 1.
# print_int broc ;;
7 - : unit = () ;;
Une liaison utilise des valeurs déjà liées. On ne doit
pas écrire (si abc n'est pas lié à une valeur)
# let abc = 2 and cde = 4 * abc ;;
mais
# let abc = 2 ;;
# let cde = 4 * abc ;;
Attention :
# let abc = 2 ;;
# let abc = 3 and cde = 4 * abc ;;
lie finalement abc à 3 et cde à 8
En cas de variable locale relative à un calcul, on utilise
in . Les variables liées temporairement par in
ne sont pas accessibles après l'instruction :
(* ^ désigne la concaténation *)
# let s = "starsky" and h = "hutch" and blan = " & "
# in s ^ blan ^h ;;
- : string = "starsky & hutch"
# print_string s ;
>
> Variable s is unbound.
LES FONCTIONS
Une fonction en CAML se définit aussi par let ; on peut
utiliser les trois formes
# let carre x = x * x ;;
# let carre( x ) = x * x ;;
# let carre = function x -> x * x ;;
pour désigner la relation fonctionnelle qui à un nombre
associe son carré ; la forme avec le mot function écrit
explicitement est en général la forme préférée.
L'utilisation de la fonction se fait sous plusieurs
formes :
# print_int carre 4 ;;
# let a = carre( 2 ) ;;
# carre( 1 + 4 ) ;;
# let cube(x) = x * carre(x) ;;
En cas de définition avec des valeurs liées, la
définition de la fonction est liée à l'environnement au
moment de la définition :
# let a = 2 ;;
# let f = function t -> a*t + 1 ;;
# let a = 3 ;;
# f( 4 ) ;;
- : int = 9
La structure conditionnelle if permet d'assouplir la
définition des fonctions :
# let valeurAbs = function a -> if a > 0 then a else -a ;;
valeurAbs : int -> int = <fun>
En particulier, le mode principal d'écriture de boucles
se fait de façon récursive , avec comme d'habitude, le
traitement du cas élementaire, l'appel récursif avec
diminution de la taille du problème et la séquence
d'appel. Par exemple, pour calculer la somme des n
premiers cubes, on peut écrire :
# let rec somCub = function n ->
if n = 1 then 1
else n*n*n + somCub(n-1)
;; (* fin de définition de somCub *)
somCub : int -> int = <fun>
Ainsi somCub( 3 ) vaut 1*1*1 + 2*2*2 + 3*3*3 soit
# somCub 3 ;;
- int = 36
CAML permet d'écrire des fonctions complexes comme celle
qui calcule f(1),f(2)...f(n) où f et n sont passés en
paramètres dans cet ordre :
# let rec SommeF = function f -> function p ->
if p = 1 then f(1)
else f(p) + sommeF f (p-1) ;;
> sommeF : (int -> int) -> int -> int = <fun>
Un exemple d'utilisation en est
# sommeF cube 3 ;;
qui renvoie bien sûr
- int = 36
REFERENCES
CAML est un langage très riche et complet. En
particulier, il possède des fonctions graphiques, sait
effectuer de l'analyse syntaxique et lexicale (via
camlLEX et camlYACC).
On peut charger un programme écrit sous un éditeur par
include "<nomF>", recharger des modules par open"<nomM>"
et surtout lire :
Accart Houdin : Concepts et Outils de Programmation, Intereditions
Weis, Leroy : Le langage CAML, Intereditions
ainsi que les manuels de référence, le guide de
l'usager...