2. Les bases du langage

2.1. Commentaires

(* Un commentaire (* Un commentaire imbriqué *) *)
(*
Je suis multiligne !
    (* Moi
    aussi *)
*)

2.2. Déclaration de variables

La déclaration en OCaml se fait grâce au mot-clé let.

# let x = 5;;
val x : int = 5
# let y = 3;;
val y : int = 3
# let z = x + y;;
val z : int = 8

Les déclarations précédentes sont globales. On peut aussi faire des déclarations locales grâce à in.

# let a = 10 and b = 11;;
val a : int = 10
val b : int = 11
# let (a, b) = (3, 4) in a * b;;
- : int = 12
# (a, b);;
- : int * int = (10, 11)

On peut imbriquer les déclarations.

# let c = let (a, b) = (3, 4) in a * b;;
val c : int = 12

Avertissement

Une déclaration locale ne peut englober une déclaration globale.

# let u = 4 in let v = 2;;
Characters 22-24:
let u = 4 in let v = 2;;
                    ^^
Error: Syntax error

2.3. Déclaration de fonctions

On utilise le même mot-clé let, avec en plus le mot-clé function. Par exemple la fonction carré :

# let f = function x -> x * x;;
val f : int -> int = <fun>

On appelle cette fonction comme ceci :

# f 3;;
- : int = 9

On note qu’il n’y a pas de parenthèses. Les fonctions récursives sont marquées avec le mot-clé rec.

# let rec fac n =
    if n = 0 then 1
    else n * fact (n-1);;
val fact : int -> int = <fun>
# fact 3;;
- : int = 6

2.4. Types natifs

En plus des entiers qui ont été utilisés jusqu’ici, il existe de nombreux types natifs en OCaml

Type Définition
int Entier relatif de 31 bits (+/- 1 milliard) pour un processeur 32-bits
float Nombre à virgule (équivalent de double en C
bool Booléen, noté true ou false
char Un charactère à 8 bits
string Une chaîne de caractères à 8 bits
unit Valeur unique notée ()

Le typage n’est pas dynamique, on ne peut pas évaluer par exemple 1 + 0.5, chaque type possède ses propres opérateurs. Pour le cas précédent, il faut explicitement convertir 1 en flottant ou bien arrondir/tronquer 0.5 pour en faire un entier.

2.4.1. Opérations sur les entiers et flottants

# 1 + 1;;
- : int = 2
# 2 * 3;;
- : int = 6
# 4 - 5;;
- : int = -1
# (/) 10 2;; (* opérateur utilisé comme une fonction *)
- : int = 5
# 10 mod 3;; (* reste de la division euclidienne *)
- : int = 1

Pour les flottants, les opérateurs sont les mêmes préfixé d’un .. mod devient mod_float.

# 1.5 +. 1.5;;
- : float = 3
# 2.5 *. 3.;; (* 3. est un flottant, 3 est un entier *)
- : float = 7.5
# mod_float 7. 3.5;; (* on est obligés d'utiliser mod_float comme ceci *)
- : float = 0

D’autres trucs sympas :

# max_int;;
- : int = 4611686018427387903
# min_int;;
- : int = -4611686018427387904
# max_float;;
- : float = 1.79769313486231571e+308
# 1 / 0;;
Exception: Division_by_zero
# 1. /. 0.;;
- : float = infinity