Caml en bref

Fichier créé en juin 1996.

Conventions lexicales

(* Ceci est un commentaire en Caml *)

Constantes

Entiers: 1 + 2 * 3 - 1 = 6
Opérations:

x mod y, x / y, x land y, x lor y, x lxor y, lnot x, x lsl
y, x lsr y, x asr y

int_of_string, string_of_int, int_of_float

Exemple

Flottants: 1.0 +. 2.0 *. 3.0 -. 1.0 = 6.0
Opérations: sin, cos, exp, sqrt, atan, atan2
float_of_string, string_of_float, float_of_int

Exemple

Chaînes: "bonjour\n"
Opérations: Concaténation ^, make_string, string_length, sub_string, s.[0], s.[0] <- `a`

Exemple

Caractères: `a`
Opérations: int_of_char, char_of_int

Exemple

Booléens: true, false
Opérations: &&, ||, not

Exemple

Rien: type unit, valeur (), argument ou résultat non significatif.

Exemple

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

Exemple

Définition de Fonctions

Un argument: let f x = expression
Plusieurs arguments: let f 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 ().
Par exemple, toutes les fonctions d'affectation rendent ().

Exemple

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

Exemple

Précédences des opérateurs

Arithmétiques: comme en mathématiques. Exemple

Booléens: comme en mathématiques. Exemple

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). Exemple
On doit impérativement parenthéser une opération argument d'une fonction. Exemple

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.

Exemple

Filtre variable: les identificateurs ou le caractère _

Exemple

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. Exemple
Clause avec garde: | filtre when condition -> expression. Exemple

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

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

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

Exemple

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

Exemple

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

Exemple

Boucles

for i = 0 to 10
do print_int i done

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

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

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, ..., ou encore printf "%d\n" 1
Clavier (std_in): lecture avec read_line
Gestion de fichiers:
- en lecture (in_channel): open_in, close_in, input_line, input_string, input_char
- 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;;
```

Définition d'exceptions

exception Exception_Constante;;

exception Exception_avec_argument
of expression_de_type;;

Contacter l'auteur Pierre.Weis@inria.fr