2. Les bases du langage¶
Sommaire
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 |
---|---|
|
Entier relatif de 31 bits (+/- 1 milliard) pour un processeur 32-bits |
|
Nombre à virgule (équivalent de |
|
Booléen, noté |
|
Un charactère à 8 bits |
|
Une chaîne de caractères à 8 bits |
|
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
2.4.2. Chaînes de caractères¶
Les chaines de caractères sont immuables.
# 'a';;
- : char = 'a'
# "a";;
- : string = "a"
# {|a|} (* Chaine qui permet de ne pas à voir à échapper \ et " *)
- : string = "a"
# {|\"]} = "\\\"";;
- : bool = true
# {delimiter|the end of this|}quoted string is here|delimiter}
= "the end of this|}quoted string is here";; (* On peut personnaliser le délimiteur *)
- : bool = true
# let a = "Hello" and b = "World" in a ^ " " ^ b;; (* Concaténation *)
- : string = "Hello World"