Les types prédéfinis

OCaml est un langage à typage statique, inféré à la compilation.

Booléens (bool)

• Valeurs : true, false
• Opérateurs :
• not: négation (bool -> bool)
• ||: ou logique paresseux
• &&: et logique paresseux
• =, <>: égalité, inégalité ('a * 'a -> bool)

Entiers (int)

• Opérateurs : *+ -, , /, abs, mod
• Comparaisons : =, <>, <, >, <=, >=
• min_int, max_int
• Pas de fonction puissance sur les entiers

Flottants (float)

• Notation : 1.0, 2.5
• Opérateurs : *+. -, . /.
• Puissance : **
• Fonctions usuelles : cos, sin, log, exp, floor
• Cas particuliers : infinity, nan
• Comparaisons analogues aux entiers

Caractère (char) et chaîne (string)

• char : entre apostrophes 'a' ; string : entre guillemets "texte"
• Chaîne vide : ""
• Opérations string :
• Concaténation : ^ (string -> string -> string)
• Accès n-ième caractère : String.get s n
• Longueur : String.length s
• Sous-chaîne : String.sub s d l

Type vide (unit) et types paramétrés

• unit : une seule valeur ()
• Pour résultats de procédures (par ex. print_int : int -> unit)
• Types paramétrés : 'a, 'b (par ex. op. de comparaison)

Conversion de types

• Pas de conversion automatique !
• Fonctions :
• float_of_int, int_of_float, int_of_char, char_of_int, Char.escaped, etc.

Produits cartésiens (n-uplets)

• Ex : (1, -3, "bonjour") : type int * int * string
• Accès : fst tuple, snd tuple (pour couples seulement)
• Comparaisons standards si mêmes types

Déclarations et expressions

• Constantes :
• let nom = valeur;; (non modifiable ensuite)
• Variables/références :
• let nom = ref valeur;;
• Accès : contenu : !nom ; affectation : nom := nouvelle_valeur
• Plusieurs déclarations en même temps :
• let a = ... and b = ...

Instructions

Affectation

• Uniquement pour références :
• nom := expr;;
• Incrément :
• incr nom équivalent à nom := !nom + 1

Séquences

• Suite d’instructions séparées par ;
• Le type de la séquence est celui de la dernière instruction

Bloc local

• let ... in ...
• Ex : let x = 3 in x * 2

Conditionnelle

• if cond then expr1 else expr2
• Les deux branches doivent avoir le même type (sinon utiliser failwith pour les exceptions)

Boucle for

• for i = d to f do ... done
• for i = d downto f do ... done
• L’index de boucle est implicite et ne doit pas être modifié

Boucle while

• while cond do ... done

Filtrage et motifs

• match expr with
• motif1 -> seq1 | motif2 -> seq2 | ...
• Motif générique : _
• Attention à la non-exhaustivité
• Filtrage avec garde :
• motif when condition -> sequence

Fonctions

• Déclaration :
• let f x = expression
• let f = function x -> expression
• Type de la fonction : argument -> résultat
• Fonctions anonymes (lambda) :
• (fun x -> x + x)
• Appel : f 5 ou f(5)