Assistant

abstraction concrète


Construire un programme sous le système interactif

Image d'écran du système interactif sous MSDOS

Une session Caml correspond à une boucle dans laquelle une lecture d'expressions est réalisée sur l'unité d'entrée standard, chaque expression lue est soumise à une analyse lexicale puis à une analyse syntaxique, ensuite elle est typée par le système d'inférence de types, avec affichage du type inféré, et pour terminer, évaluée avec affichage de la valeur obtenue en résultat.

Exemple de session Caml Light

Au démarrage, le système interactif affiche la version de Caml Light active, suivie de l'invite "#" qui indique que le système est en attente d'une entrée de l'opérateur

> Caml Light version 0.71

#

à ce moment, si l'opérateur veut évaluer une expression telle que "12 + 35", il entre l'expression en la terminant par un double point-virgule ";;"

> Caml Light version 0.71

#12 + 35 ;;

pour valider et transmettre l'expression au système interactif, il frappe la touche d'entrée dite retour chariot ou [CR]. A la suite de quoi, le système interactif effectue et affiche le typage et l'évaluation de l'expression. Ceci fait, le système affiche l'invite et se place, de nouveau, en attente.

> Caml Light version 0.71

#12 + 35 ;; [CR]
- : int = 17
#

Le cycle : nouvelle entrée -> typage-évaluation -> affichage -> nouvelle entrée, se poursuit jusqu'à ce que l'opérateur termine la session en entrant la commande quit().

> Caml Light version 0.71

#12 + 35 ;; [CR]
- : int = 17
#......
.......
#quit() ;;
[CR]

Au cours d'une session Caml, l'environnement global est modifié par les déclarations globales.

Pour construire un programme sous le système interactif, il suffit de déclarer les types, exceptions, constantes, variables et fonctions qui seront aussitôt évaluées et introduites dans l'environnement de travail.

On peut construire un fichier texte contenant la séquence des déclarations. Il suffit, alors, d'appeler ce fichier par la commande include pour retrouver l'environnement de travail ainsi défini.

Il est aussi possible de charger le fichier source, avec la commande load, ou compilé, avec la commande load_object. De cette façon il sera possible de retrouver l'environnemnt de travail au moyen de la directive #open mais aussi de le libérer, au moyen de la directive #close



Charger un programme

La fonction include
La fonction load
La fonction load_object
La directive #open
La directive #open sert à ouvrir les modules chargés.



Construire un programme exécutable indépendant

Programmation modulaire

Pour construire un programme exécutable indépendant, on écrit un fichier texte contenant la séquence des déclarations. Il suffit, ensuite, de compiler ce fichier avec le compilateur camlc.

Exemple :

On a produit un fichier texte nommé "progcaml.ml" qui contient le programme principal.
Considérons que ce fichier utilise les fonctions des modules "module1.ml", avec son interface "module1.mli", et "module2.ml" associé à "module2.mli".
On compile les modules dans l'ordre de leur appel.
camlc -c "module1.mli"
camlc -c "module1.ml"
camlc -c "module2.mli"
camlc -c "module2.ml"
Puis, on lance la production du code exécutable qui sera installé dans un fichier portant le nom choisi par le programmeur ("progcaml.exe" dans l'exemple).
camlc -o "progcaml.exe" "module1.zo" "module2.zo" "progcaml.ml"

dernière modification : 06/12/96