(* Ceci est un commentaire en Caml *)
1 + 2 * 3 - 1 = 6
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
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
Chaînes: "bonjour\n"
Opérations: Concaténation ^, make_string, string_length, sub_string, s.[0],
s.[0] <- `a`
Caractères: `a`
Opérations:
int_of_char, char_of_int
Booléens: true, false
Opérations:
&&, ||, not
Rien: type unit, valeur (),
argument ou résultat non significatif.
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).
let ident = expression;;
let ident = expression in ...
let ... and ident2 = expression2
and ident3 = ...
let rec x = ...
let f x = expression
let f x y = expression
let f = function filtrage
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 ().
f (x)
f x
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)).
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.
function, ou
with
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, filtre) -> expression
| filtre as ident ->
expression
| filtre_constant |
filtre_constant -> expression
| filtre_caractère ..
filtre_caractère -> expression. Exemple
| filtre when condition
-> expression. Exemple
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
À un argument: function x
-> expression
Avec filtrage sur l'argument:
function | filtre -> expression | ... | filtre -> expression
Avec plusieurs arguments: function x -> function y ->
expression
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
[| 1; 2; 3 |] ou make_vect
nombre_d'éléments valeur_initiale
v.(0)
v.(0) <- nouvelle_valeur
do_vect, map_vectfor i = 0 to vect_length v - 1 do ... done
vect_length, blit_vect
[], [ 1; 2; 3
] ou x :: l
match l with | [] -> ... | x :: l -> ...Affectation: une liste est immuable.
do_list, map
list_length
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
expression; expression
begin
end dans les branches d'un if then else.
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
try expression
with filtrage
raise exception_constante
ou raise (exception_avec_argument
expression)
std_out):
Impression avec print_string, print_int,
print_float, ..., ou encore printf "%d\n" 1
std_in): lecture avec read_line
in_channel): open_in, close_in, input_line, input_string,
input_char
out_channel): open_out, close_out, output_string, output_char
(données structurées: input_value, output_value)
type nom = | Constructeur_constant | Constructeur_avec_argument of expression_de_type;;
type nom = {label1 : type_du_champ; label2 : type_du_champ};;
Un champ peut être modifiable: mutable label :
type_du_champ_modifiable
enregistrement.label
<- nouvelle_valeur
type nom == expression_de_type;;
exception Exception_Constante;;
exception Exception_avec_argument
of expression_de_type;;
Contacter l'auteur Pierre.Weis@inria.fr