Le document traite des conventions lexicales en OCaml, y compris les types de données (entiers, flottants, chaînes, booléens) et leurs opérations. Il aborde la définition de fonctions, le filtrage patterns, les boucles, les conditions, les exceptions, ainsi que la gestion des entrées-sorties et des types. Des exemples de syntaxe et d'utilisation des différentes fonctionnalités du langage sont également fournis.

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