Caml

1. 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 : "bonjourn"
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

2. • 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;;