Variables

Let nom-variable = expr ;;

Expr : constantes (0, 12, 125

(global : nom_variable est associé à sa valeur jusqu’à ce qu’on la redéfinisse)

Let var=6 ;;

Let var=7 ;; (*var vaut maintenant 7*)

Asignations locales

Let nom_var = expr1 in

Expr2

Ex : let a=2 in 4*a ;; (*renvoie 8, et c’est aussi une expression*)

Let x= let a=2 in 4*a;; (* 8 est associé à x *)

Les expressions en OCaml ont toutes un type.

Types : int ; float ; string ; …

Fonction en Ocaml

Let nom_fonction param1 param2 …. = expr ;;

Dans expr, on peut utiliser param1, param2

Ex : let somme x y = x+y ;;

Type int -> int -> int ; la flèche indique une fonction

Types : (‘a * ‘b) ; (‘a * ‘b * ‘c)

‘a correspond à un type par exemple ‘a=int ou ‘a = int*float

Ex : let uplet = (5,8)

Val uplet : int * int = (5,8)

Let somme1 (x,y) = x+y ;;

Val somme1 : (int*int -> int)

Val somme : int -> int-> int mais ceci signifie en fait : int -> (int -> int)

En Ocaml, on n’aime pas les parenthèses et on aime bien les fonctions partielles. Ce que fait somme
c’est prendre un entier x en entrée et renvoyer la fonction f et f_x : N -> N , y I-> x+y.
Let double x =

Let rec aux y accumulateur = match y with

|0 -> accumulateur

|y -> aux (y-1) (accumulateur +2)

in aux x 0 ;;

est la même chose que

let double x= match x with

|0-> 0

|y -> 2*y;;

Les fonctions prennent toujours un argument et si elles ne sont pas censées en prendre, elles en
prennent quand même un de type unit.

Let imprime 5 () = print_int 5 ;

() est de type unit et c’est son seul élément, il est utilisé pour les expressions qui ne renvoient rien.

(imprime 5 () ;;

Let imprime5 x y = print_int 5 a pour signature ‘a –> ‘b -> unit. En fait, x et y peuvent être de type
quelconque car on ne fait rien avec.

 Tous les éléments d’un tableau sont de même type.

 Pour accéder à un élément, on fait t.(i).
 Contrairement à une liste, on peut changer les éléments d’un tableau en faisant t.(i) <- valeur.

Ex : let a = Array.length t in

For i=0 to a-1 do

t.(i) <- t.(i)+1 done.

Comment créer des types personnels ?

1er cas : type enregistrement

Type nom du type = {nomattribut1 = type 1 ; … ; nomattributn : type n}

Ex : type complexe = {mutable réel : float ; imag : float}

Let z = {réel =0. ; imag = 1.} ;;

z.reel ;; (* accède à l’attribut réel de 2, renvoie donc 0.)

2e cas : type somme

Type nomdutype = constructeur1 of type1 / constructeur2 of type2

Type couleur = Blanc | Nom | MelangeRVB of int*int*int ;;

Let rouge = Melange(255, 0, 0) ;;

Let bleuparfait (c : couleur) = match c with

|Blanc -> false

|Noir -> false

|Melange(x,y,z) -> if (x=0 && y=0 && z=255) then true else false ;;