Les Opérateurs

Le caml est supposé être un langage flexible capable d'associer à vos variables un type en fonction de vos instructions (l'interpréteur interprète vos instructions afin de déterminer le type de chacune de vos variables). Alors qu'en C, on devait définir au préalable le type de nos variables. Mais dans certains cas comme les additions ou les multiplications, cela dépend de l'opérateur utilisé. C'est-à-dire que Ocaml déduit le type de nos variables seulement en regardant l'opérateur.

Les Nombres

En effet, le caml dispose de deux types d'opérateurs selon que l'on veuille agir sur les entiers ou les réels (int ou float).
* Pour les entiers (int), on a les opérateurs traditionnels tels que : + - * et /
* Pour les réels (float) il "suffit" d'ajouter un '.' après chaque opérateur, sauf pour le modulo qui n'existe que pour les entiers. On a donc les opérateurs: +. -. *. et /.

Exemple 1 :

let a = 2 + 11;;
val a : int = 13

Parlons de l'interprétation, dans l'exemple que je viens de faire je n'ai pas eu à préciser que a est de type int. L'interpréteur voit que '2' et '11' sont des entiers (int), de plus on a un '+' (j'ai pas fais exprès de faire de jeu mot ;-) !). L'interpréteur déduit que 'a' vaut 13, c'est un int ! Ça fonctionne de la même manière pour la soustraction, la multiplication et la division ...

Exemple 2 :

let b = 2. -. 11. ;;
val b : float = -9.

Ici, '2.' est un float ainsi que '11.'. On a l'opérateur '-.' qui permet à l'interpréteur de déduire que b est un float. Comme pour les int, soustraction, multiplication et division fonctionnent comme ça.

Attention chaque opérateur est spécifique à son type.
Les mélanges sont INTERDITS !!!! Sous peine de recevoir une expression du type :

" Error: This expression has type type1 but is here used with type type2 "
 ou
" Error: This expression has type type1 but an expression was expected of type type2 "

Les chaînes de caractères

Il y a deux opérateurs utiles sur les chaînes de caractères Ocaml: La Concaténation:

let tuto = "Tutoriel " ;;
val tuto : string = "Tutoriel "

let ocaml = "Ocaml.";;
val ocaml : string = "Ocaml."

let tutocaml = tuto ^ ocaml ;;
val tutocaml :string = "Tutoriel Ocaml."

Bon, c'est plutôt simple :-). Deux chaînes concaténées donnent une seule chaîne (pas nouveau, non ?).

Accès Caractères:

let ocaml = "ocaml" ;;
val ocaml : string = "ocaml"

let o = ocaml.[0] ;;
val o : char = 'o'

let c = ocaml.[1] ;;
val c : char = 'c'

Si vous avez une chaîne de caractères vous pouvez donc accéder aux caractères qui la constituent. Ce sera pratique quand vous voudrez faire du traitement de texte ou autres ...

Les booléens

Vous le savez, les booléens ne peuvent prendre que deux valeurs (True ou False). Voyons quelques opérateurs qui permettent de faire de la Logique.

let a = true ;;
val a : bool = true

let b = false ;;
val b : bool = false

not a ;; (* La négation d'un booléen *)
- : bool = false

a and b ;; (* Conjonction *)
- : bool = false

a && b ;; (* Conjonction *)
- : bool = false

a or b ;; (* Disjonction *)
- : bool = true

a || b ;; (* Disjonction *)
- : bool = true

( (a and b) || (b && a) ) ;;
- : bool = false

Si vous avez des questions de logique, soit vous avez déjà un bon niveau soit vous attendez le deuxième semestre (parce qu'il y aura des cours de Numération Logique), et si vous n'appartenez à aucun de ces deux groupes je vois pas ce qu'on pourra y faire ^_^ ! ! !

La Comparaison

Comme dans tous les langages de programmation on a la possibilité de comparer des variables entre elles (à condition qu'elles soient du même type).

11 < 12 ;;
s - : bool = true

(2. *. 3.) = 10. ;; (* Ocaml fait la différence entre une déclaration et un comparaison avec un égale *)
- : bool = false

"Tutoriel Ocaml" == "Tutoriel " ^ "Ocaml" ;; (* Comme en C, on peut mettre deux 'égales' pour comparer *)
- : bool = true

'a' < 'z' ;; (* Ocaml compare la place dans l'alphabet des deux caractères *)
- : bool = true

1 <> 2 ;; (* Différent *)
- : bool = true

2 =! 1 ;; (* Différent *)
- : bool = true

Ces opérateurs ( <, >, =, ==, =! <>> ) sont utilisables avec int, float, char, string.

Allez, on passe à la suite du tuto.