Formation Caml, tutoriel & guide de travaux pratiques en pdf.

Principale caracteristiques d’OCaml

Langage fonctionnel

Une seule notion fondamentale: la notion de valeur. Les fonctions elles-memes sont considerees comme des valeurs.
Un programme est essentiellement constitue d’expressions et le calcul consiste en l’evaluation de ces expressions.

Le systeme de typage

Le langage est type statiquement.
Il possede un systeme d’inference de types: le programmeur n’a besoin de donner aucune information de type: les types sont synthetises automatiquement par le compilateur.

Le polymorphisme parametrique

Un type peut ˆetre non enti`erement d´etermin´. Il est alors polymorphe. Ceci permet de développer un code g´en´erique utilisable pour diff´erentes structures de donn´ees tant que la repr´esentation exacte de cette structure n’a pas besoin d’ˆetre connue dans le code en question.

Principale caracteristiques d’OCaml

Mecanismes particuliers

OCaml poss`ede un m´ecanisme de programmation par cas: “pattern matching” tr`es puissant.
OCaml poss`ede un m´ecanisme d’exceptions pour interrompre l’´evaluation d’une expression. Ce m´ecanisme peut aussi ˆetre adopt´e comme style de programmation.
Il y a des types r´ecursifs mais pas de pointeurs.
La gestion de la m´emoire est diff´erente de celle du C. OCaml int`egre un m´ecanisme de récupération automatique de la m´emoire.

Autres aspects de OCaml

OCaml poss`ede des aspects imp´eratifs. La programmation imp´erative est possible mais non souhait´ee.
OCaml interagit avec le C.
OCaml poss`ede des aspects objets. Les fonctions peuvent manipuler des objets.
Les programmes peuvent ˆetre structur´es en modules param´etr´es (s´eparation du code et de l’interface).
OCaml ex´ecute des processus l´eger (threads). OCaml communique avec le r´eseau internet.

Principale caracteristiques d’OCaml

Environnement de programmation

OCaml dispose de trois modes d’ex´ecution le mode interactif: c’est une boucle d’interaction. La boucle d’interaction d’OCaml utilise du code-octet pour ex´ecuter les phrases qui lui sont envoy´ees. compilation vers du code-octet (bytecode) interpr´et´ par une machine virtuelle (comme Java).
compilation vers du code machine ex´ecut´ directement par un microprocesseur.
OCaml dispose de biblioth`eques.

Mode de compilation

Noms des commandes
ocaml: lance la boucle d’interaction
ocamlrun: interpr`ete de code-octet
ocamlc: compilateur en ligne de code-octet
ocamlopt: compilateur en ligne de code natif
ocamlmktop: constructeur de nouvelles boucles d’interaction

Unit´es de compilation

C’est la plus petite d´ecomposition d’un programme pouvant ˆetre compil´ee.
Pour la boucle d’interaction, c’est une phrase du langage. On va voir plus loin e qu’est une phrase.
Pour les compilateurs en ligne, c’est un couple de fichiers (le source .ml et l’interface facultative .mli).
Les fichiers objets en code-octet ont pour extension .cmo, .cma (biblioth`eque objet), .cmi (interface compil´ee). Les fichiers objets en code natif ont les extensions .cmx et .cmxa.
L’option -c indique au compilateur de n’engendrer que le code objet. L’option -custom de ocamlrun permet de cr´eer un code autonome il contient le code-octet du programme plus l’interpr`ete du code-octet).

Mode interactif

L’option -I catalogue permet d’indiquer un chemin dans lequel se fera la recherche de fichiers sources ou compil´es.
La boucle poss`ede plusieurs directives de compilation qui permettent de modifier de fa¸con interactif son comportement. Ces directives commencent par # et se terminent par ;;.
#quit;; sort de la boucle d’interaction
#directory catalogue;; ajoute un chemin de recherche #cd catalogue;; change de catalogue courant
#load « fichier objet »;; charge un fichier .cmo
#use « fichier source »;; compile et charge un fichier .ml ou .mli
#print depth profondeur;; modifie la profondeur d’affichage #trace fonction;; trace les arguments d’une fonction
#untrace fonction;; enl`eve cette trace
#untrace all;; enl`eve toute les traces
On peut lancer la boucle d’interaction sous emacs par M-x run-caml.

Un tour rapide de OCaml Les expressions

Expressions constantes

Une fois entr´ dans la boucle OCaml on peut ´evaluer des expressions.
shell $ ocaml –> appel de la boucle
Objective Caml version 3.11.1
# 3;; –> expression `a ´evaluer
– : int = 3 –> r´eponse
# #quit;; –> pour sortir de la boucle
shell $ –> shell de syst`eme
La r´eponse de l’´evaluation d’une expression est sa valeur et son type.
Les expressions plus simples sont les constants des types de base.
# 5.0;;
– : float = 5.
# true;;
– : bool = true
# « Hello, word! »;;
– : string = « Hello, word! »
S. Guerrini (LIPN – Paris 13) Programmation Fonctionnelle 2009–2010 11/45
Un tour rapide de OCaml Les expressions
Les op´erateur arithm´etiques
Sur les entier on a les op´erateur arithm´etiques infixes
# 3+4*2;; – : int = 11
Mais attention, les op´erateur sont typ´es et ils ne sont pas “overloaded”
# 3.0 + 2.5;;
Characters 0-3:
3.0 + 2.5;;
^^^
Error: This expression has type float but an expression was expected of type int
Les op´erateur arithm´etiques sur les r´eel ont des symboles distingu´es.
# 3.0 +. 2.0;; – : float = 5.
Les op´erateur bool´een et le if-then-else
Les op´erateurs bool´eens sont
not: n´egation
&& ou &: et s´equentiel
|| ou or: ou s´equentiel
# not false && false;;
– : bool = false
# not (false && false);; – : bool = true
# true = false;;
– : bool = false
#3=3;;
– : bool = true
#4+5>=10;;
– : bool = false
# 2.0 *. 4.0 >= 7.0;; – : bool = true
Expressions conditionnelles
# if (3 < 4) then 1 else 0;; – : int = 1
# if (3 > 4) then 1 else 0;;
– : int = 0
seulement une des branches then/else est evalu´ee

Conversion de types

Pour utiliser un entier dans une expression que contient un op´erateur r´eel il faut utiliser une fonction de conversion explicite
# 3.0 +. 2;; Characters 7-8: 3.0 +. 2;;^
Error: This expression has type int but an expression was expected of type float
# 3.0 +. float 2;;
– : float = 5.
Les op´erateur de comparaison < > <= >= = sont les mˆemes pour les entiers et les r´eels
# 2.0 < 3.0;; # 2 < 3;;
– : bool = true – : bool = true
Mais attention, il faut toujours faire de conversion de type si n´ecessaire
# 2.0 < 3;;
Characters 6-7:
2.0 < 3;; ^
Error: This expression has type int but an expression was expected of type float
# 2.0 < float 3;; – : bool = true
Les chaˆınes de caract`eres
literals
# « Hello, world! »;;
– : string = « Hello, world! »
concat´enation
# « Hello,  » ^ « world! »;;
– : string = « Hello, world! »
la biblioth`eque String
# String.uppercase « Hello, world! »;;
– : string = « HELLO, WORLD! » \end{itemize}
# open String;;
# uppercase « Hello, world! »;; – : string = « HELLO, WORLD! »
S. Guerrini (LIPN – Paris 13) Programmation Fonctionnelle 2009–2010 15/45
Un tour rapide de OCaml Les fonctions
Les fonctions
Les fonctions sont des expressions (fun est ´equivalent `a function)
# fun x -> x * 2;;
– : int -> int = <fun>
# function x -> x *2;;
– : int -> int = <fun>
Le type d’une fonction n’est plus un type de base
Pour ´evaluer une fonction il faut lui donner les valeurs des arguments
# (fun x -> x * 2) 3;; – : int = 6
L’argument d’une fonction peut ˆetre une fonction
# (fun f -> f (f 2));;
– : (int -> int) -> int = <fun>
Le r´esultat de l’´evaluation d’une fonction peut ˆetre une autre fonction
# (fun f x -> f (f x)) (fun x -> x * x);; – : int -> int = <fun>
En ajoutant des arguments on peut ´evaluer la fonction obtenue
# (fun f x -> f (f x)) (fun x -> x * x) 2;; – : int = 16

Les noms

On peut associer un nom `a des expressions pour le r´eutiliser apr`es
# let x = 2 + 3;; val x : int = 5
# x * 3;;
– : int = 15
En particulier on peut donner un nom `a les fonctions
# let f = (fun x -> x * 2);; val f : int -> int = <fun>
# f 3;;
– : int = 6
Pour d´efinir une fonction OCaml fournit aussi une syntaxe simplifi´e
# let g f x = f (f (x * 2));;
val g : (int -> int) -> int -> int = <fun>
# let sq x = x * x;;
val sq : int -> int = <fun>
# let h = g sq;;
val h : int -> int = <fun>
# h 1;;
– : int = 16
let f x y = e est ´equivalent `a let f = fun x y -> e

Convention sur les noms

Avec OCaml, les noms de variables et de fonctions doivent commencer par une minuscule.
Les noms commen¸cant par une majuscule sont r´eserv´es pour les constructeurs.
# let IsEven x = x mod 2 = 0;; Characters 4-12:
let IsEven x = x mod 2 = 0;;
^^^^^^^^
Error: Unbound constructor IsEven
# let isEven x = x mod 2 = 0;;
val isEven : int -> bool = <fun>
Dans une d´eclaration, un nom x d´eclar´ dans un let est connu dans toutes les expressions qui suivent la d´eclaration mais pas dans l’expression `a la droite de let x =.

Un tour rapide de OCaml Les fonctions

Port´e du let
Dans une d´eclaration, un nom x d´eclar´ dans un let est connu dans toutes les expressions qui suivent la d´eclaration mais pas dans l’expression `a la droite de let x =
# let z = z + 3;; Characters 8-9:
let z = z + 3;;
^
Error: Unbound value z
# let z = 2;;
val z : int = 2
# let z = z + 3;; val z : int = 5
Pour d´efinir des fonctions r´ecursives il faut noter qu’on est en train de donner une d´eclaration r´ecursive en utilisant le construit let rec.
S. Guerrini (LIPN – Paris 13) Programmation Fonctionnelle 2009–2010 19/45
Un tour rapide de OCaml Les fonctions
Les produits cart´esiens
Les valeurs des produits cart´esiens binaires sont les couples
# (3, 4);;
– : int * int = (3, 4)
Ce n’est pas n´ecessaire que les objets de la couple aient le mˆeme type
# let p = (true, « alpha »);;
val p : bool * string = (true, « alpha »)
Les projections
# fst p;;
– : bool = true
# snd p;;
– : string = « alpha »
# p = (fst p, snd p);; – : bool = true
Les produits cart´esiens n-aires
# (true, 3, « alpha », 4);;
– : bool * int * string * int = (true, 3, « alpha », 4)
les projections fst et snd sont pr´ed´efinies seulement pour le cas binaire n = 2 il n’y a pas des projections pr´ed´efinies pour chaque n
on peut d´efinir les projections pour toutes les n-uples
# let p_1_3 (x, y, z) = x;;
val p_1_3 : ’a * ’b * ’c -> ’a = <fun>