Tuteur pour le langage CAML

novalid      

Texte du Tuteur écrit par Gilles HUNAULT

Une liste des autres tuteurs (langages, logiciels, systèmes d'exploitations...) est accessible par Mosaic...


Table des Matières

Le langage Caml

Les liaisons en Caml

Les fonctions en Caml

Références


INTRODUCTION


    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...