Mémento CAML

Conventions lexicales

(* Ceci est un commentaire en Caml *)

Constantes

Entiers : 1 + 2 * 3 - 1 = 6 ; Opérations : x mod y, x / y (et aussi x land y, x lor y, x lxor y, lnot x, x lsl y, x lsr y, x asr y) ; Conversions : int_of_string, string_of_int, int_of_float .

Flottants : 1.0 +. 2.0 *. 3.0 -. 1.0 = 6.0 Opérations : sin, cos, exp, sqrt, atan, log, … Conversions : float_of_string, string_of_float, float_of_int Chaînes : "bonjour\n" Opérations : Concaténation ^, make_string, string_length, sub_string, s.[0], s.[0] <- `a` Caractères : `a` Conversions : int_of_char, char_of_int Booléens : true, false ; Opérations : && , ||, not Rien: type unit, valeur (), argument ou résultat non significatif.

Parenthésage

En Caml, le parenthésage est significatif et suit les règles mathématiques des fonctions trigonométriques. En Caml, 1 + 2 * x signifie 1 + (2 * x) comme en mathématiques.

En Caml, f x signifie f (x) comme en mathématiques sin x signifie sin (x).

En Caml, f x + g x signifie (f x) + (g x), comme en mathématiques sin x + cos x signifie (sin x) + (cos x).

Donc, f x - y signifie (f x) - y comme en mathématiques sin x - 1 signifie (sin x) - 1.

En Caml, cette convention est généralisée à tous les opérateurs infixes : f x :: g x signifie (f x) :: (g x).

Définition de Valeurs

Globale : let ident = expression;;

Locale : let ident = expression in ...

Multiple : let ... and ident2 = expression2 and ident3 = ...

Récursive: let rec x = ...

Définition de Fonctions

Un argument : let f x = expression ou let f = function x -> expression ;

Plusieurs arguments : let f x y = expression ou let f = fun x y -> expression ;

Avec filtrage : let f = function filtrage ;

Récursive : let rec f x = ... ;

Cas particuliers: une procédure est une fonction sans résultat mathématique significatif, qui rend ().

Fonction anonyme

À un argument: function x -> expression

Avec filtrage sur l'argument:

function

| filtre -> expression

| ...

| filtre -> expression

Avec plusieurs arguments: function x -> function y -> expression

Appel de Fonctions

À l'aide de parenthèses : f(x) ;

Par juxtaposition : f x ;

À plusieurs arguments : f(x)(y) ou f x y ;

Cas particuliers: les fonctions sans argument mathématique significatif prennent () pour argument ;

Par exemple print_newline se déclenche quand on écrit print_newline () ;

Attention : un argument complexe doit toujours être parenthésé ; par exemple f(x + 1) (et non f x + 1 qui signifie f(x) + 1 soit 1 + f(x)).

Précédences des opérateurs

Arithmétiques: comme en mathématiques.

Booléens : comme en mathématiques.

Application de fonction et opérations: comme en mathématiques pour les fonctions trigonométriques.

• Il n'est pas nécessaire de parenthéser une application argument d'une opération (quelque soit l'opération du langage).

• On doit impérativement parenthéser une opération argument d'une fonction.

Filtrage

Un filtrage apparaît après les mots-clefs function, ou with (dans les constructions function filtrage, et aussi try ... with filtrage, ou

encore match ... with filtrage).

Un filtrage est une liste de clauses filtre -> expression: chaque clause est essayée successivement, la première pour laquelle le filtre

correspond à (ou est plus général que) la valeur filtrée est sélectionnée et l'on retourne la valeur de l'expression correspondante.

Attention : un filtrage interne à un autre filtrage doit être entouré de begin end . On distingue des filtres constants, des variables ou des filtres composés.

| filtre_constant -> expression

| filtre_variable -> expression

| filtre_composé -> expression;;

Filtre constant: les constantes du langage, comme 1, "poi", true, les constructeurs constants.

Filtre variable: les identificateurs ou le caractère _

Filtre composé: un constructeur appliqué à un filtre Constructeur filtre, des listes x::l, des n-uplets (filtre1, filtre2), des enregistrements

{label1=filtre1; ...; labeln=filtren}.

Filtres plus complexes:

• Filtre n-uplet: | (filtre, filtre) -> expression

• Filtre synonyme: | filtre as ident -> expression

• Filtre ou: | filtre_constant | filtre_constant -> expression

• Filtre intervalle: | filtre_caractère .. filtre_caractère -> expression.

• Clause avec garde: | filtre when condition -> expression.

Appel au filtrage

match expression with filtrage Par exemple: match f 2 with | 1 -> expression | n -> expression Attention : un filtrage interne à un autre filtrage doit être entouré de begin end: match e with | f1 -> begin match e2 with | g2 -> ... ... | gm -> ... end | ... | fn -> expression

Références

Définition: let x = ref 0 in ...

Accès : l'opérateur ! retourne le contenu de la référence argument (! reference) ;

Affectation : l'opérateur := modifie le contenu de la référence en partie gauche (reference := valeur) ; par exemple: x := !x + 1

Vecteurs

Définition : [| 1; 2; 3 |] ou make_vect nombre_d'éléments valeur_initiale ;

Accès : v.(0) ;

Affectation : v.(0) <- nouvelle_valeur ;

Parcours : do_vect, map_vect, for i = 0 to vect_length v - 1 do ... done ;

Fonctions : vect_length, blit_vect

Listes

Définition : [] , [ 1; 2; 3 ] ou x :: l ;

Accès:

match l with

| [] -> ...

| x :: l -> ...

Affectation : une liste est immuable.

Parcours : do_list, map ;

Fonctions : list_length

Boucles

for i = 0 to 10 do print_int i done ou for i = 10 downto 0 do print_int i done ;

while !j > 0 do j := !j - 1 done

Séquence

Syntaxe : expression; expression

Attention : une séquence doit être entourée de begin end (ou de ( )) dans les branches d'un if then else.

Conditionnelle

Syntaxe: if condition then expression else expression ;

Opérateurs de comparaison standard : <, >, <=, >=, <> ;

Comparaison physique : ==, != ;

Attention : if condition then begin e1; e2 end else begin e3; e4 end .

Exceptions

Définition d'exceptions : exception Exception_Constante;; ou exception Exception_avec_argument of expression_de_type;;

Rattrapage : try expression with filtrage

Lancement : raise exception_constante ou raise (exception_avec_argument expression)

Entrées-sorties

• Écran (std_out): Impression avec print_string, print_int, print_float, ...,

• Clavier (std_in): lecture avec read_line ;

• Gestion de fichiers:

o en lecture (in_channel): open_in, close_in, input_line, input_string, input_char

o en écriture (out_channel): open_out, close_out, output_string, output_char (données structurées: input_value, output_value) .

Définition de Types

• Type somme:

type nom =

| Constructeur_constant

| Constructeur_avec_argument of expression_de_type;;

• Type enregistrement:

type nom = { label1 : type_du_champ; label2 : type_du_champ};;

Un champ peut être modifiable: mutable label : type_du_champ_modifiable ;

Affectation d'un champ modifiable: enregistrement.label <- nouvelle_valeur .

• Type abbréviation:

type nom == expression_de_type;;