TUTORIEL OCAML



Présentation

1
Types

2
Operateurs

3
Fonctions

4
Récursivité

5
Types

6
Enregistrement
et
Types Sommes

7
Annexes


Exercices


Corrections


Les variables

Tous les types

Tout d'abord, commençons par rappeler les types de variables que l'on appellera "de base" (ça ne fait pas de mal ;-) ):


Le Type INT : représentant les nombres entiers (positifs et négatifs).

let a = 2;;
val a : int = 2

let a = -2;;
val a : int = -2


Le Type FLOAT : représentant les nombres réels.

let valeur_bidon = -3.;;
val valeur_bidon : float = -3.

let pi = 3.141592653589793238462643383279;;
val pi : float = 3.141592653589793238462643383279

Si vous voulez utiliser de très grands nombres, il vaut mieux prendre des réels (floats) plutôt que des entiers (int).
Les entiers se limitent à un plus petit intervalle que les float.

ATTENTION :

Pour définir un float, on utilise UN POINT et non pas UNE VIRGULE !
Si vous ne respectez pas cette convention, de nombreuses erreurs vont survenir !

CULTURE G :

Cette notation provient de la syntaxe anglaise des nombres décimaux.
Exemple : Ramy est petit et mesure 1,50m ! devient Ramy est petit et mesure 1.50m !


Le Type CHAR : représentant les caractères.

let z = 'z';;
val z : char = 'z'

let arobase = '@';;
val arobase : char = '@'

Il y a 256 caractères (il y a ceux que vous utilisez presque tous les jours sur votre clavier pour écrire, mais il y aussi les caractères spéciaux).

Pour définir un CHAR on utilise bien sûr les apostrophes ''.
Dans un CHAR il n'y a un et un seul caractère entre les apostrophes.


Le Type STRING : représentant une chaîne de caractères.

let premiere = "Voici ma première chaîne de caractères.";;
val premiere : string = "Voici ma première chaîne de caractères."

let petite_chaine = "h";;
val petite_chaine : string = "h"

let encore_plus_petit = "";;
val encore_plus_petit : string = ""

Une chaîne de caractères peut contenir 0, 1 ou plusieurs caractères.


Le Type BOOLEEN : Vrai ou Faux.

let je_debute_en_caml = true;;
val je_debute_en_caml : bool = true

let et_je_mameliore = true;; (* A vous de juger :-D *)
val et_je_mameliore = true


Le Type UNIT : entité vide.

();;
- : unit = ()

print_newline ();;

- : unit = ()

On le reverra plus tard, mais c'est à utiliser pour une fonction qui ne prend pas d'argument, ou encore une fonction qui ne renvoie rien de particulier (//print_newline ()// ne prend aucun argument et ne renvoie rien, c'est pas pour autant qu'elle ne fait rien). Ce n'est pas exactement un équivalent de "void" ou "NULL" dans d'autres langages.



Les Conversions

Contrairement au langage C, OCaml permet une certaine flexibilité : on peut passer des entiers aux réels grâce à une fonction. Celles-ci s'écrivent de la façon suivante: ** typevoulu **_of_ **typeorigine **;;

int_of_float 2. ;;
2

string_of_int 123 ;;
"123"

int_of_char 'a' ;; (* La place de 'a' dans la table ASCII *)
97

Les conversions doivent être manipulées avec précaution.
Une chaîne de caractère ne peut devenir un booléen ou un entier.



Un type de variable particulier : les n-uplets

Le n-uplet est une variable composée de plusieurs variables élémentaires que nous avons vus plus haut. Il se construit avec une "virgule" qui sépare les différentes variables, ainsi que des parenthèses à leurs extrêmes. 2 variables -> ** duplet **, 3 variables -> ** triplet **, 4 variables -> ** quadruplet **, ... L'avantage de ce nouveau type de variable est de pouvoir stocker plusieurs variables élémentaires de type différents dans une seule variable, le n-uplet.

let lettre_a = ('a', 1);;
val lettre_a : char * int = ('a', 1)

let mot = ("Ocaml", 'O', 'c', 'a', 'm', 'l');;
val mot : string * char * char * char * char * char = ("Ocaml", 'O', 'c', 'a', 'm', 'l')

let moi = ("KuK", 20.5, "Nul en Maths", true, "Moyenne en Prog. :", 18);;
val moi : string * float * string * bool * string * int = ("KuK", 20.5, "Nul en Maths", true, "Moyenne en Prog. :", 18)

On peut faire toutes les combinaisons que l'on souhaite. On apprendra à l'utiliser dans les fonctions pour renvoyer plusieurs valeurs en une.

Déclaration Locale

Si vous voulez utiliser une variable sans que l'utilisateur ait à la saisir en paramètre de la fonction, vous pouvez la définir à l'intérieur de la fonction de la façon suivante :

let nomvariable = valeur in Expression;; (* Expression utilise nomvariable qui vient d'être définie localement *)

Le in est très important car il indique qu'il s'agit d'une déclaration locale de nomvariable dans Expression (elle n'existe que dans celle-ci). Après cette ligne de code, nomvariable devient inconnue (et donc si vous la réutiliser sans la définir vous aurez une Error).

exemples :

let x = 2 in x + 2;;
- : int = 4

let chaine = "dokuwiki" in print_string ("J'utilise " ^ chaine ^ ".\n");;
J'utilise Docuwiki.
- : unit = ()

(* Et maintenant, si on rappelle x on obtient une erreur ! *)
x;;
Error: Unbound value x (* x est desormais une valeur inconnue, il en est de même pour chaine *)



Eh bien maintenant que vous connaissez tous les types de variables Ocaml, apprenons à nous en servir avec la suite du tuto.