SlideShare une entreprise Scribd logo
1  sur  15
Télécharger pour lire hors ligne
1CAML pour
l’impatient
C H A P I T R E
Un tutoriel très très léger pour débuter avec OCAML
2 1.1. INSTALLATION ET UTILISATION
Installation et utilisation1
Pour tous les O.S. il existe des distributions de CAML clé-en-main sur le page de Jean Mou-
ric : http ://pagesperso-orange.fr/jean.mouric/.
Pour les utilisateurs de Emacs, vous pouvez charger le mode tuareg :
http ://www.emacswiki.org/emacs/TuaregMode.
CAML sous Emacs avec le mode tuareg :
CAML sous JavaCaml :
Pour utiliser l’interpréteur dans un terminal, on utilisera ledit qui permet d’avoir quelques
fonctionnalités comme l’accès à l’historique par les flèches :
$ ledit ocaml
Guillaume CONNAN - IUT de NANTES - Département informatique - Licence Creative Commons BY:
 $


 C

 - 5 février 2012
CHAPITRE 1. CAML POUR L’IMPATIENT 3
Quelques ressources électroniques2
– Une passionnante introduction à OCAML par un de ses papas...
http ://caml.inria.fr/pub/distrib/books/llc.pdf
– Le manuel de référence de CAML par Xavier LEROY et Pierre WEIS :
http ://caml.inria.fr/pub/distrib/books/manuel-cl.pdf
– Une introduction à CAML :
http ://fr.wikibooks.org/wiki/Objective_Caml
– Ouvrage de référence CAML :
http ://www.pps.jussieu.fr/Livres/ora/DA-OCAML/
– Ressources CAML :
http ://caml.inria.fr/resources/index.fr.html
– Un tutoriel en français :
http ://www.ocaml-tutorial.org/tutoriel_objective_caml
Les nombres3
Nous utiliserons dans tout le document la version basique de CAML (en fait OCAML (c’est-
à-dire CAML avec des modules pour faire de la programmation orientée objet) ou CAML
Light (c’est la version de base que nous utiliserons)) sans charger de modules complémen-
taires sauf éventuellement pour créer des graphiques ou travailler sur certaines listes.
Nous travaillerons en mode toplevel c’est-à-dire que nous compilerons automatiquement
de manière interactive. Pour se repérer, ce que nous taperons sera précédé d’un # et ce que
renverra CAML sera précédé le plus souvent d’un -.
On peut travailler avec des entiers :
# 1+2;;
- : int = 3
# succ 1;;
- : int = 2
# pred 0 ;;
- : int = -1
# abs(-3) ;;
- : int = 3
Vous remarquerez que CAML répond que le résultat de 1+2 est un entier (int) égal à 3. En
effet, CAML est adepte de l’inférence de type, c’est-à-dire qu’il devine quel type de variable
vous utilisez selon ce que vous avez tapé. Nous en reparlerons plus bas.
Les priorités des opérations sont respectées. En cas d’ambiguïté, un parenthésage implicite
à gauche est adopté :
# 1+2*3;;
- : int = 7
# 1-2+3;;
- : int = 2
# 1-(2+3);;
- : int = -4
# (1+2)*3;;
- : int = 9
Guillaume CONNAN - IUT de NANTES - Département informatique - Licence Creative Commons BY:
 $


 C

 - 5 février 2012
4 1.3. LES NOMBRES
La division renvoie le quotient entier bien sûr :
# 11/3;;
- : int = 3
# 11/3*2;;
- : int = 6
# 11/(3*2);;
- : int = 1
On peut utiliser mod pour le reste entier :
# 7 mod 2;;
- : int = 1
# 7/2;;
- : int = 3
# 7-7/2*2;;
- : int = 1
Enfin, les entiers sont de base compris entre −231
et 231
−1 sur un processeur 32 bits et entre
−263
et 263
−1 sur un processeur 64 bits.
# max_int;;
- : int = 4611686018427387903
On peut travailler avec des nombres écrits dans des bases différentes en les faisant précéder
de 0b pour la notation binaire, 0o pour la notation octale et 0x pour la notation hexadéci-
male :
# 0xa;;
- : int = 10
# 0xa0;;
- : int = 160
# 0b1011;;
- : int = 11
Les nombres non entiers sont de type float. Ils sont représentés en interne par deux en-
tiers : une mantisse m et un exposant n tel que le nombre flottant soit m ×2n
. En externe, il
apparaît sous forme décimale, le séparateur étant le point.
# 1.;;
- : float = 1.
Attention alors aux opérations :
# 3.14 + 2;;
Characters 0-4:
3.14 + 2;;
^^^^
Error: This expression has type float but an expression was expected of
type int
Cela indique que vous avez utilisé l’addition des entiers pour ajouter un entier à un flot-
tant. CAML en effet n’effectue pas de conversion implicite et demande que celle-ci soit ex-
plicite. Cela peut apparaître comme contraignant mais permet l’inférence de type qui évite
nombre de « bugs ».
Guillaume CONNAN - IUT de NANTES - Département informatique - Licence Creative Commons BY:
 $


 C

 - 5 février 2012
CHAPITRE 1. CAML POUR L’IMPATIENT 5
Les opérations arithmétiques sur les entiers doivent donc être suivies d’un point :
# 1. +. 2.1 ;;
- : float = 3.1
# 1.2 +. 2.1 ;;
- : float = 3.3
# 1./.2.;;
- : float = 0.5
# 1.5e-5 *. 100. ;;
- : float = 0.0015
# sqrt(2.);;
- : float = 1.41421356237309515
# 3.**2.;;
- : float = 9.
# log(2.);;
- : float = 0.693147180559945286
# exp(1.);;
- : float = 2.71828182845904509
# cos(0.);;
- : float = 1.
# cos(2.*.atan(1.));;
- : float = 6.12303176911188629e-17
# sin(2.*.atan(1.));;
- : float = 1.
# 1./.0.;;
- : float = infinity
# abs_float(-3.0);;
- : float = 3.
# 2.**10. ;;
- : float = 1024.
Il existe des moyens de convertir un entier en flottant :
# float(1) +. 3.1;;
- : float = 4.1
# float 1 +. 3.1;;
- : float = 4.1
et inversement :
# int_of_float(sqrt(2.));;
- : int = 1
Il ne faut pas confondre int_of_float et floor
# floor(2.1);;
- : float = 2.
# int_of_float(2.1);;
- : int = 2
# floor(-2.1);;
- : float = -3.
# int_of_float(-2.1);;
- : int = -2
Guillaume CONNAN - IUT de NANTES - Département informatique - Licence Creative Commons BY:
 $


 C

 - 5 février 2012
6 1.4. LES AUTRES TYPES DE BASE
Les autres types de base4
4 1 Les booléens
Ils sont bien sûr au nombre de deux : true et false. Nous en aurons besoin pour les tests.
Les fonctions de comparaison renvoient un booléen. On peut combiner des booléens avec
not, & et or :
# 3>2;;
- : bool = true
# 3 == 2;;
- : bool = false
# 3 <> 2;;
- : bool = true
# (3>2) && (3=2);;
- : bool = false
# (3>2) || (3=2);;
- : bool = true
# (3>2) && not(3=2);;
- : bool = true
# (3>2) && not(3=2) && (0<1 || 1>0);;
- : bool = true
On peut utiliser 3 = 2 ou 3 == 2 mais cela mérite attention pour les valeurs qui
ne sont pas de type booléen ou entier :
# let n = 1;;
val n : int = 1
# let m = 1;;
val m : int = 1
# n = m;;
- : bool = true
# n == m;;
- : bool = true
mais
# let x = 1.0;;
val x : float = 1.
# let y = 1.0;;
val y : float = 1.
# x = y ;;
- : bool = true
# x == y ;;
- : bool = false
L’égalité structurelle = explore leur structure alors que l’égalité physique == teste si les deux
valeurs occupent la même zone mémoire.
4 2 Les chaînes de caractères
En anglais : string. On les entoure de guillemets vb+"+ et on les concatène avec ^ :
Guillaume CONNAN - IUT de NANTES - Département informatique - Licence Creative Commons BY:
 $


 C

 - 5 février 2012
CHAPITRE 1. CAML POUR L’IMPATIENT 7
# "Tralala "^"pouet pouet";;
- : string = "Tralala pouet pouet"
Ce ne sont pas des objets « fonctionnellement purs » car on peut les modifier comme les
vecteurs, à la manière de tableaux statiques.
4 3 Les caractères
En CAML : char. On les utilisera surtout pour la cryptographie. Il sont entrés entre accents
aigus :
# ’a’;;
- : char = ’a’
On peut faire des aller-retours caractère/code ASCII :
# int_of_char ’a’;;
- : int = 97
# char_of_int 97;;
- : char = ’a’
Les n-uplets5
Entre parenthèses, ils permettent de grouper plusieurs valeurs qui peuvent être de types
différents :
# (1,"1",1.0,’1’);;
- : int * string * float * char = (1, "1", 1., ’1’)
Listes6
Il existe un type liste qui est chaînée et dont le longueur est donc dynamique mais on n’a
accès qu’à son premier élément comme nous le verrons plus tard. On a cependant un opé-
rateur binaire de concaténation @ :
# let liste = [1;2;3] ;;
val liste : int list = [1; 2; 3]
# 0::liste ;;
- : int list = [0; 1; 2; 3]
# [1;2] @ [3;4];;
- : int list = [1; 2; 3; 4]
Attention ! L’inférence de type a ses petites manies :
# [1; "deux" ; 3.0];;
Characters 4-10:
[1; "deux" ; 3.0];;
^^^^^^
Guillaume CONNAN - IUT de NANTES - Département informatique - Licence Creative Commons BY:
 $


 C

 - 5 février 2012
8 1.7. CRÉATION DE TYPES
Error: This expression has type string but an expression was expected of
type
int
# [1; 2 ; 3.0];;
Characters 8-11:
[1; 2 ; 3.0];;
^^^
Error: This expression has type float but an expression was expected of
type
int
Création de types7
On n’insistera pas sur ce point pour l’instant. Voyons juste un exemple simple :
# type couleur = Trefle | Carreau | Coeur | Pique ;;
type couleur = Trefle | Carreau | Coeur | Pique
# [Trefle ; Carreau] ;;
- : couleur list = [Trefle; Carreau]
Les déclarations8
8 1 Cas général
C’est comme en maths...mais en anglais ! Donc Soit se dit Let :
# let x=3*2;;
val x : int = 6
# 2+x;;
- : int = 8
# let pi=acos(-1.);;
val pi : float = 3.14159265358979312
# sin(pi/.2.);;
- : float = 1.
Le nom des identificateurs doit commencer par une lettre minuscule.
8 2 Déclarations locales
On peut définir localement une variable, c’est-à-dire que sa portée ne dépassera pas l’ex-
pression où elle a été définie :
# let x = 3 in x + 1 ;;
- : int = 4
La définition est bien locale :
# x ;;
Guillaume CONNAN - IUT de NANTES - Département informatique - Licence Creative Commons BY:
 $


 C

 - 5 février 2012
CHAPITRE 1. CAML POUR L’IMPATIENT 9
Characters 0-1:
x ;;
^
Error: Unbound value x
let (x,y) = (1,2) in x + y ;;
- : int = 3
8 3 Déclarations simultanées
On utilise and qu’il ne faudra donc pas confondre avec & ou bien on peut utiliser un n-
uplet :
# let x=3 and y=5;;
val x : int = 3
val y : int = 5
# x+y;;
- : int = 8
# let (a,b)=(3.,5.);;
val a : float = 3.
val b : float = 5.
Fonctions9
Une expression fonctionnelle est un paramètre formel (le nom de la variable) suivi d’un
corps qui est une expression.
On peut créer des fonctions avec function :
# let delta = function
| (a,b,c) -> b*b-4*a*c;;
val delta : int * int * int -> int = <fun>
# delta(1,1,1);;
- : int = -3
Notez le val delta : int * int * int -> int = <fun> qui indique que
la fonction construite...est une fonction (<fun>) qui va de Z3
dans Z.
On peut de manière plus standard (informatiquement parlant !) définir la fonction par son
expression générale :
# let discriminant(a,b,c)=b*b-4*a*c;;
val discriminant : int * int * int -> int = <fun>
# discriminant(1,1,1);;
- : int = -3
On peut disjoindre des cas : c’est le fameux filtrage par motif (« pattern matching »)
# let sina = function
| 0. -> 1.
Guillaume CONNAN - IUT de NANTES - Département informatique - Licence Creative Commons BY:
 $


 C

 - 5 février 2012
10 1.9. FONCTIONS
| x -> sin(x)/.x;;
val sina : float -> float = <fun>
# sina(0.);;
- : float = 1.
# sina(0.1);;
- : float = 0.998334166468281548
On peut rendre le paramètre du filtrage explicite :
let rec factorielle n = match n with
| 0 -> 1
| n -> n * factorielle (n-1);;
On peut travailler avec autre chose que des nombres :
# let mystere = function
| (false,true) -> true
| (true,false) -> true
| _ -> false;;
val mystere : bool * bool -> bool = <fun>
Le tiret _ indique « dans tous les autres cas ».
On peut aussi créer des fonctions polymorphes, c’est-à-dire qui ne travaillent pas sur des
types de variables particuliers.
let composee(f,g) = function
| x ->f(g(x));;
val composee : (’a -> ’b) * (’c -> ’a) -> ’c -> ’b = <fun>
Ici, f est toute fonction transformant un type de variable a en un type de variable b et g une
fonction transformant un type de variable c en un type de variable a. La fonction composée
transforme bien un type de variable c en un type de variable b.
Si nous reprenons la fonction définie précédemment :
let carre = function
| x -> x*.x;;
val carre : float -> float = <fun>
# composee(sina,carre);;
- : float -> float = <fun>
# composee(sina,carre)(3.);;
- : float = 0.04579094280463962
On peut définir des opérateurs infixes qui seront utilisables de manière plus naturelle :
# let (%) x y = x+y;;
val ( % ) : int -> int -> int = <fun>
# 3 % 2 ;;
- : int = 5
Guillaume CONNAN - IUT de NANTES - Département informatique - Licence Creative Commons BY:
 $


 C

 - 5 février 2012
CHAPITRE 1. CAML POUR L’IMPATIENT 11
If...then...else10
On peut utiliser une structure conditionnelle pour définir une fonction :
let valeur_abs(x)=
if x>=0 then x
else -x;;
val valeur_abs : int -> int = <fun>
Notons que chaque branche de l’arbre (la branche then et la branche else) doit être du
même type.
Fonctions récursives11
C’est une fonction construite à partir d’elle-même. On utilise la même syntaxe que pour
une fonction simple mais on fait suivre le let d’un rec :
let rec factorielle = function
| 0 -> 1
| n -> n*factorielle(n-1);;
val factorielle : int -> int = <fun>
let rec fact(n)=
if n=0 then 1
else n*fact(n);;
val fact : int -> int = <fun>
Définition locale de fonctions12
let nb_sol(a,b,c) =
let delta(a,b,c) =
b*b - 4*a*c
in if delta(a,b,c) = 0 then 1
else if delta(a,b,c) < 0 then 0
else 2;;
Récursion terminale13
let rec succ = function
|0 -> 1
|n -> 1 + succ(n-1) ;;
val succ : int -> int = <fun>
Guillaume CONNAN - IUT de NANTES - Département informatique - Licence Creative Commons BY:
 $


 C

 - 5 février 2012
12 1.14. EXCEPTIONS
# succ(100000);;
- : int = 100001
# succ(1000000);;
Stack overflow during evaluation (looping recursion?).
On arrive à la limite de la pile.
let succ(n) =
let rec local = function
| (0,acc) -> acc
| (n,acc) -> local(n-1,1 + acc)
in local(n,1);;
val succ : int -> int = <fun>
# succ(100000000);;
- : int = 100000001
Caml peut dérécursifier les récursions terminales et n’utilise plus sa pile qui ne peut donc
plus être saturée.
Exceptions14
Pour régler les problèmes d’ensemble de définition d’une fonction, on utilise des excep-
tions. Certaines sont prédéfinies (voir la liste disponible sur
caml.inria.fr/pub/docs/manual-ocaml/manual033.html#htoc253)
Par exemple :
# exception Liste_vide;;
exception Liste_vide
# let tete = function
|[] -> raise Liste_vide
|t::q -> t;;
val tete : ’a list -> ’a = <fun>
# tete [3;4;5;6];;
- : int = 3
# tete ["un";"deux";"trois"];;
- : string = "un"
# tete([]);;
Exception: Liste_vide.
Au cas zoù, on peut programmer en impératif15
En programmation fonctionnelle, on calcule une valeur par application d’une fonction. En
programmation impérative, on crée un état qu’on modifie au cours du programme au gré
d’instructions.
Guillaume CONNAN - IUT de NANTES - Département informatique - Licence Creative Commons BY:
 $


 C

 - 5 février 2012
CHAPITRE 1. CAML POUR L’IMPATIENT 13
15 1 Vecteurs
Il existe un type tableau (ou vecteur) comme dans de nombreux langages. Sa longueur est
fixée lors de sa création ce qui permet d’avoir accès à ses composantes :
# let t = [|1;2;3|] ;;
val t : int array = [|1; 2; 3|]
# t.(2) ;;
- : int = 3
# t.(2) <- 5;;
- : unit = ()
# t ;;
- : int array = [|1; 2; 5|]
15 2 Chaînes de caractères
Ce sont ne quelque sorte des vecteurs de caractères.
# let chaine = "Ich bin ein Berliner";;
val chaine : string = "Ich bin ein Berliner"
# chaine.[1] ;;
- : char = ’c’
# chaine.[1] <- ’C’;;
- : unit = ()
# chaine;;
- : string = "ICh bin ein Berliner"
15 3 Type unit
Il existe des fonctions qui jouent le rôles des procédures dans des langages impératifs et
sont à effets de bords. Ocaml étant typé, il y a un type pour ces fonctions : unit.
# print_string "Tralala" ;;
Tralala- : unit = ()
Une autre action extra-fonctionnelle est la modification en place d’un vecteur à l’aide de
<- :
# let v = [|1;2;3|];;
val v : int array = [|1; 2; 3|]
# v.(2) <- 37 ;;
- : unit = ()
# v ;;
- : int array = [|1; 2; 37|]
On évitera ce genre d’action extra-fonctionnelle dans la mesure du possible.
15 4 Entrées/sorties
Voici un exemple :
print_newline ();;
print_string "Entrez un entier : ";;
let a = read_int ();;
print_newline ();;
Guillaume CONNAN - IUT de NANTES - Département informatique - Licence Creative Commons BY:
 $


 C

 - 5 février 2012
14 1.15. AU CAS ZOÙ, ON PEUT PROGRAMMER EN IMPÉRATIF
print_string "Entrez un autre entier : ";;
let b = read_int ();;
print_newline ();;
print_string "Leur somme vaut :";;
print_int a;;
print_string " + ";;
print_int b;;
print_string " = ";;
print_int (a+b);;
print_newline ();;
print_newline ();;
et on obtient, si l’on a nommé ce fichier IO.ml :
$ ocaml IO.ml
Entrez un entier : 1
Entrez un autre entier : 2
Leur somme vaut :1 + 2 = 3
$
15 5 Références
Même si Caml fait une incursion dans la programmation impérative, il la clarifie un peu en
obligeant à distinguer le nom d’une référence et son contenu.
Une référence est en fait un pointeur vers une valeur. La valeur référencée est atteinte par
la fonction préfixe !. Elle peut être modifiée avec la fonction infixe :=.
On ne pourra pas écrire x := x + 1 comme en C par exemple. La référence est crée
avec ref et son contenu est accessible en faisant précéder son étiquette d’un ! :
# let x = ref 0 ;;
val x : int ref = {contents = 0}
# x ;;
- : int ref = {contents = 0}
# x + 1 ;;
Characters 0-1:
x + 1 ;;
^
Error: This expression has type int ref
but an expression was expected of type int
# !x + 1 ;;
- : int = 1
# x := !x + 3 ;;
- : unit = ()
# x ;;
- : int ref = {contents = 3}
# !x ;;
- : int = 3
On remarque au passage qu’une réaffectation est bien du type unit.
Guillaume CONNAN - IUT de NANTES - Département informatique - Licence Creative Commons BY:
 $


 C

 - 5 février 2012
CHAPITRE 1. CAML POUR L’IMPATIENT 15
15 6 Boucles
La syntaxe est usuelle mais il faut faire attention à la distinction référence/contenu :
( * POUR * )
# let som_ent(n) =
let s = ref 0 in
for i=1 to n do
s := !s + i
done;
!s;;
val som_ent : int -> int = <fun>
# som_ent(5) ;;
- : int = 15
( * TANT QUE * )
# let som_ent_w(n) =
let s = ref 0 in
let i = ref 0 in
while (!i <= n) do
begin
s := !s + !i;
incr i;
end
done;
!s;;
val som_ent_w : int -> int = <fun>
# som_ent_w(5) ;;
- : int = 15
Guillaume CONNAN - IUT de NANTES - Département informatique - Licence Creative Commons BY:
 $


 C

 - 5 février 2012

Contenu connexe

Tendances

Corrigés exercices langage C
Corrigés exercices langage CCorrigés exercices langage C
Corrigés exercices langage Ccoursuniv
 
C# et .NET : Enigmes et puzzles
C# et .NET : Enigmes  et puzzlesC# et .NET : Enigmes  et puzzles
C# et .NET : Enigmes et puzzlesMicrosoft
 
C++11 en 12 exemples simples
C++11 en 12 exemples simplesC++11 en 12 exemples simples
C++11 en 12 exemples simplesPethrvs
 
Tp1 compte rendu en langage c
Tp1 compte rendu en langage cTp1 compte rendu en langage c
Tp1 compte rendu en langage cEbrima NJIE
 
Chapitre 2: String en Java
Chapitre 2:  String en JavaChapitre 2:  String en Java
Chapitre 2: String en JavaAziz Darouichi
 
Chapitre2fonctionscppv2019
Chapitre2fonctionscppv2019Chapitre2fonctionscppv2019
Chapitre2fonctionscppv2019Aziz Darouichi
 
C1 - Langage C - ISIMA - Première partie
C1 - Langage C - ISIMA - Première partieC1 - Langage C - ISIMA - Première partie
C1 - Langage C - ISIMA - Première partieLoic Yon
 
programmation orienté objet c++
programmation orienté objet c++programmation orienté objet c++
programmation orienté objet c++coursuniv
 
Les nouveautés de C++11 : Ecrire du C++ Moderne
Les nouveautés de C++11 : Ecrire du C++ ModerneLes nouveautés de C++11 : Ecrire du C++ Moderne
Les nouveautés de C++11 : Ecrire du C++ ModerneMicrosoft
 

Tendances (20)

Formation python
Formation pythonFormation python
Formation python
 
Corrigés exercices langage C
Corrigés exercices langage CCorrigés exercices langage C
Corrigés exercices langage C
 
Le langage C
Le langage CLe langage C
Le langage C
 
Cours tp2
Cours tp2Cours tp2
Cours tp2
 
Chapitre 04 : les fonctions
Chapitre 04 : les fonctionsChapitre 04 : les fonctions
Chapitre 04 : les fonctions
 
C# et .NET : Enigmes et puzzles
C# et .NET : Enigmes  et puzzlesC# et .NET : Enigmes  et puzzles
C# et .NET : Enigmes et puzzles
 
Les bases du javascript
Les bases du javascriptLes bases du javascript
Les bases du javascript
 
C++11 en 12 exemples simples
C++11 en 12 exemples simplesC++11 en 12 exemples simples
C++11 en 12 exemples simples
 
Tp1 compte rendu en langage c
Tp1 compte rendu en langage cTp1 compte rendu en langage c
Tp1 compte rendu en langage c
 
Chapitre 2: String en Java
Chapitre 2:  String en JavaChapitre 2:  String en Java
Chapitre 2: String en Java
 
Chapitre 02 : Variables, Expressions et Instructions
Chapitre 02 : Variables, Expressions et InstructionsChapitre 02 : Variables, Expressions et Instructions
Chapitre 02 : Variables, Expressions et Instructions
 
Chapitre2fonctionscppv2019
Chapitre2fonctionscppv2019Chapitre2fonctionscppv2019
Chapitre2fonctionscppv2019
 
C++11
C++11C++11
C++11
 
Tp 1 introduction à matlab
Tp 1 introduction à matlabTp 1 introduction à matlab
Tp 1 introduction à matlab
 
Chap2fonctionscpp
Chap2fonctionscppChap2fonctionscpp
Chap2fonctionscpp
 
Cours java script
Cours java scriptCours java script
Cours java script
 
Chapitre05 : Les tableaux
Chapitre05 : Les tableauxChapitre05 : Les tableaux
Chapitre05 : Les tableaux
 
C1 - Langage C - ISIMA - Première partie
C1 - Langage C - ISIMA - Première partieC1 - Langage C - ISIMA - Première partie
C1 - Langage C - ISIMA - Première partie
 
programmation orienté objet c++
programmation orienté objet c++programmation orienté objet c++
programmation orienté objet c++
 
Les nouveautés de C++11 : Ecrire du C++ Moderne
Les nouveautés de C++11 : Ecrire du C++ ModerneLes nouveautés de C++11 : Ecrire du C++ Moderne
Les nouveautés de C++11 : Ecrire du C++ Moderne
 

En vedette

Infographie PwC sur la fraude en entreprise (2014)
Infographie PwC sur la fraude en entreprise (2014)Infographie PwC sur la fraude en entreprise (2014)
Infographie PwC sur la fraude en entreprise (2014)PwC France
 
MOPA "La mutualisation dans les offices de tourisme" - 3èmes Rencontres des a...
MOPA "La mutualisation dans les offices de tourisme" - 3èmes Rencontres des a...MOPA "La mutualisation dans les offices de tourisme" - 3èmes Rencontres des a...
MOPA "La mutualisation dans les offices de tourisme" - 3èmes Rencontres des a...Fabien Raimbaud
 
Compilation présentations atelier tic&lait 28 juin 2013 MEITO
Compilation présentations atelier tic&lait 28 juin 2013 MEITOCompilation présentations atelier tic&lait 28 juin 2013 MEITO
Compilation présentations atelier tic&lait 28 juin 2013 MEITOYann Dieulangard
 
Débat #Communautez La presse demain ?
Débat #Communautez La presse demain ?Débat #Communautez La presse demain ?
Débat #Communautez La presse demain ?dupin laurent
 
Educacion, escuela y tecnologia, carlos y julieta
Educacion, escuela y tecnologia, carlos y julietaEducacion, escuela y tecnologia, carlos y julieta
Educacion, escuela y tecnologia, carlos y julietaCARLOS CHAVARRIA
 
Principios para escribir un buen artículo
Principios para escribir un buen artículoPrincipios para escribir un buen artículo
Principios para escribir un buen artículoÓscar Pech Lara
 
Presentación de María Isabel Torres respecto a la COP20
Presentación de María Isabel Torres respecto a la COP20Presentación de María Isabel Torres respecto a la COP20
Presentación de María Isabel Torres respecto a la COP20Embajada de EE.UU. en el Perú
 
Le Regard Illustré
Le Regard IllustréLe Regard Illustré
Le Regard Illustrémidod
 
Savoir faire des vidéos accessibles - FFFOD
Savoir faire des vidéos accessibles - FFFODSavoir faire des vidéos accessibles - FFFOD
Savoir faire des vidéos accessibles - FFFODSophie Drouvroy
 
Images d'eau (td)
Images d'eau (td)Images d'eau (td)
Images d'eau (td)Thuydy
 
La legislación errática y desordenada a la búsqueda del mantenimiento y la cr...
La legislación errática y desordenada a la búsqueda del mantenimiento y la cr...La legislación errática y desordenada a la búsqueda del mantenimiento y la cr...
La legislación errática y desordenada a la búsqueda del mantenimiento y la cr...Universidad Autónoma de Barcelona
 
Andrea García García
Andrea García GarcíaAndrea García García
Andrea García GarcíaEufemia Rosso
 

En vedette (20)

Comment se lancer dans le M-Commerce ?
Comment se lancer dans le M-Commerce ?Comment se lancer dans le M-Commerce ?
Comment se lancer dans le M-Commerce ?
 
Infographie PwC sur la fraude en entreprise (2014)
Infographie PwC sur la fraude en entreprise (2014)Infographie PwC sur la fraude en entreprise (2014)
Infographie PwC sur la fraude en entreprise (2014)
 
MOPA "La mutualisation dans les offices de tourisme" - 3èmes Rencontres des a...
MOPA "La mutualisation dans les offices de tourisme" - 3èmes Rencontres des a...MOPA "La mutualisation dans les offices de tourisme" - 3èmes Rencontres des a...
MOPA "La mutualisation dans les offices de tourisme" - 3èmes Rencontres des a...
 
3 sur le vif
3 sur le vif3 sur le vif
3 sur le vif
 
Compilation présentations atelier tic&lait 28 juin 2013 MEITO
Compilation présentations atelier tic&lait 28 juin 2013 MEITOCompilation présentations atelier tic&lait 28 juin 2013 MEITO
Compilation présentations atelier tic&lait 28 juin 2013 MEITO
 
Wikicité - Pierrot Péladeau
Wikicité - Pierrot PéladeauWikicité - Pierrot Péladeau
Wikicité - Pierrot Péladeau
 
Débat #Communautez La presse demain ?
Débat #Communautez La presse demain ?Débat #Communautez La presse demain ?
Débat #Communautez La presse demain ?
 
Educacion, escuela y tecnologia, carlos y julieta
Educacion, escuela y tecnologia, carlos y julietaEducacion, escuela y tecnologia, carlos y julieta
Educacion, escuela y tecnologia, carlos y julieta
 
Actu Eco 17/10/14
Actu Eco 17/10/14Actu Eco 17/10/14
Actu Eco 17/10/14
 
Principios para escribir un buen artículo
Principios para escribir un buen artículoPrincipios para escribir un buen artículo
Principios para escribir un buen artículo
 
Presentación de María Isabel Torres respecto a la COP20
Presentación de María Isabel Torres respecto a la COP20Presentación de María Isabel Torres respecto a la COP20
Presentación de María Isabel Torres respecto a la COP20
 
Le Regard Illustré
Le Regard IllustréLe Regard Illustré
Le Regard Illustré
 
Savoir faire des vidéos accessibles - FFFOD
Savoir faire des vidéos accessibles - FFFODSavoir faire des vidéos accessibles - FFFOD
Savoir faire des vidéos accessibles - FFFOD
 
Wikicité - Patrick Dubé
Wikicité - Patrick DubéWikicité - Patrick Dubé
Wikicité - Patrick Dubé
 
Images d'eau (td)
Images d'eau (td)Images d'eau (td)
Images d'eau (td)
 
exemple
exempleexemple
exemple
 
BATMAN
BATMANBATMAN
BATMAN
 
Icud, Jóvenes en la red,...desmontando mitos ;-)
Icud, Jóvenes en la red,...desmontando mitos ;-)Icud, Jóvenes en la red,...desmontando mitos ;-)
Icud, Jóvenes en la red,...desmontando mitos ;-)
 
La legislación errática y desordenada a la búsqueda del mantenimiento y la cr...
La legislación errática y desordenada a la búsqueda del mantenimiento y la cr...La legislación errática y desordenada a la búsqueda del mantenimiento y la cr...
La legislación errática y desordenada a la búsqueda del mantenimiento y la cr...
 
Andrea García García
Andrea García GarcíaAndrea García García
Andrea García García
 

Similaire à Caml intro

Cours c#
Cours c#Cours c#
Cours c#zan
 
Javascript : que fait ce code?
Javascript : que fait ce code?Javascript : que fait ce code?
Javascript : que fait ce code?Ruau Mickael
 
02 Spécificité du C++ COURS SYS SYSSSSSS
02 Spécificité du C++  COURS SYS SYSSSSSS02 Spécificité du C++  COURS SYS SYSSSSSS
02 Spécificité du C++ COURS SYS SYSSSSSSAyoubElmrabet6
 
cours lanagage c avec des exemples d'application
cours lanagage c avec des exemples d'applicationcours lanagage c avec des exemples d'application
cours lanagage c avec des exemples d'applicationkamalomari2
 
condition et boucle (2).pptx
condition et boucle  (2).pptxcondition et boucle  (2).pptx
condition et boucle (2).pptxMohammedErritali2
 
Série sous programmes (bac scientifique)
Série sous programmes (bac scientifique)Série sous programmes (bac scientifique)
Série sous programmes (bac scientifique)Hichem Kemali
 
BDA-PL-SQL.pdf11111111111111111111111111
BDA-PL-SQL.pdf11111111111111111111111111BDA-PL-SQL.pdf11111111111111111111111111
BDA-PL-SQL.pdf11111111111111111111111111SaraMeriem1
 
Les structures en c++ (1)
Les structures en c++ (1)Les structures en c++ (1)
Les structures en c++ (1)Wael Ismail
 
Les structures en c++
Les structures en c++Les structures en c++
Les structures en c++Wael Ismail
 
TD systèmes logiques.pdf----------------
TD systèmes logiques.pdf----------------TD systèmes logiques.pdf----------------
TD systèmes logiques.pdf----------------NasriMohsen2
 
Formation python
Formation pythonFormation python
Formation pythonj_lipaz
 
Fiche de TD 1 de préparation probatoire (littéraire et scientifique) du Camer...
Fiche de TD 1 de préparation probatoire (littéraire et scientifique) du Camer...Fiche de TD 1 de préparation probatoire (littéraire et scientifique) du Camer...
Fiche de TD 1 de préparation probatoire (littéraire et scientifique) du Camer...ATPENSC-Group
 
CPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCSiratiSoufiane
 

Similaire à Caml intro (20)

Tp introduction java
Tp introduction javaTp introduction java
Tp introduction java
 
Cours c#
Cours c#Cours c#
Cours c#
 
Javascript : que fait ce code?
Javascript : que fait ce code?Javascript : que fait ce code?
Javascript : que fait ce code?
 
02 Spécificité du C++ COURS SYS SYSSSSSS
02 Spécificité du C++  COURS SYS SYSSSSSS02 Spécificité du C++  COURS SYS SYSSSSSS
02 Spécificité du C++ COURS SYS SYSSSSSS
 
cours lanagage c avec des exemples d'application
cours lanagage c avec des exemples d'applicationcours lanagage c avec des exemples d'application
cours lanagage c avec des exemples d'application
 
TP5_2020.pdf
TP5_2020.pdfTP5_2020.pdf
TP5_2020.pdf
 
condition et boucle (2).pptx
condition et boucle  (2).pptxcondition et boucle  (2).pptx
condition et boucle (2).pptx
 
langage C++
langage C++langage C++
langage C++
 
Série sous programmes (bac scientifique)
Série sous programmes (bac scientifique)Série sous programmes (bac scientifique)
Série sous programmes (bac scientifique)
 
BDA-PL-SQL.pdf11111111111111111111111111
BDA-PL-SQL.pdf11111111111111111111111111BDA-PL-SQL.pdf11111111111111111111111111
BDA-PL-SQL.pdf11111111111111111111111111
 
Etes vous-pret pour php8 ?
Etes vous-pret pour php8 ?Etes vous-pret pour php8 ?
Etes vous-pret pour php8 ?
 
C# langage & syntaxe
C#   langage & syntaxeC#   langage & syntaxe
C# langage & syntaxe
 
Les structures en c++ (1)
Les structures en c++ (1)Les structures en c++ (1)
Les structures en c++ (1)
 
Les structures en c++
Les structures en c++Les structures en c++
Les structures en c++
 
bhaj_inspiration.pdf
bhaj_inspiration.pdfbhaj_inspiration.pdf
bhaj_inspiration.pdf
 
TD systèmes logiques.pdf----------------
TD systèmes logiques.pdf----------------TD systèmes logiques.pdf----------------
TD systèmes logiques.pdf----------------
 
Formation python
Formation pythonFormation python
Formation python
 
Fiche de TD 1 de préparation probatoire (littéraire et scientifique) du Camer...
Fiche de TD 1 de préparation probatoire (littéraire et scientifique) du Camer...Fiche de TD 1 de préparation probatoire (littéraire et scientifique) du Camer...
Fiche de TD 1 de préparation probatoire (littéraire et scientifique) du Camer...
 
Python + ansible = ♥
Python + ansible = ♥Python + ansible = ♥
Python + ansible = ♥
 
CPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
 

Plus de zan

Gnu linux advanced administration arabic
Gnu linux advanced administration arabicGnu linux advanced administration arabic
Gnu linux advanced administration arabiczan
 
Apprendre python3 arab
Apprendre python3 arabApprendre python3 arab
Apprendre python3 arabzan
 
Scilabisnotnaive
ScilabisnotnaiveScilabisnotnaive
Scilabisnotnaivezan
 
Guide scilab
Guide scilabGuide scilab
Guide scilabzan
 
Aide mémoire de caml
Aide mémoire de camlAide mémoire de caml
Aide mémoire de camlzan
 
Blue j
Blue jBlue j
Blue jzan
 
Fonctionnement d'un reseau
Fonctionnement d'un reseauFonctionnement d'un reseau
Fonctionnement d'un reseauzan
 
Audit
AuditAudit
Auditzan
 
Php mysql cours
Php mysql coursPhp mysql cours
Php mysql courszan
 
Architecture
ArchitectureArchitecture
Architecturezan
 
77232345 cours-ip-mobile
77232345 cours-ip-mobile77232345 cours-ip-mobile
77232345 cours-ip-mobilezan
 
Réseaux
RéseauxRéseaux
Réseauxzan
 

Plus de zan (12)

Gnu linux advanced administration arabic
Gnu linux advanced administration arabicGnu linux advanced administration arabic
Gnu linux advanced administration arabic
 
Apprendre python3 arab
Apprendre python3 arabApprendre python3 arab
Apprendre python3 arab
 
Scilabisnotnaive
ScilabisnotnaiveScilabisnotnaive
Scilabisnotnaive
 
Guide scilab
Guide scilabGuide scilab
Guide scilab
 
Aide mémoire de caml
Aide mémoire de camlAide mémoire de caml
Aide mémoire de caml
 
Blue j
Blue jBlue j
Blue j
 
Fonctionnement d'un reseau
Fonctionnement d'un reseauFonctionnement d'un reseau
Fonctionnement d'un reseau
 
Audit
AuditAudit
Audit
 
Php mysql cours
Php mysql coursPhp mysql cours
Php mysql cours
 
Architecture
ArchitectureArchitecture
Architecture
 
77232345 cours-ip-mobile
77232345 cours-ip-mobile77232345 cours-ip-mobile
77232345 cours-ip-mobile
 
Réseaux
RéseauxRéseaux
Réseaux
 

Caml intro

  • 1. 1CAML pour l’impatient C H A P I T R E Un tutoriel très très léger pour débuter avec OCAML
  • 2. 2 1.1. INSTALLATION ET UTILISATION Installation et utilisation1 Pour tous les O.S. il existe des distributions de CAML clé-en-main sur le page de Jean Mou- ric : http ://pagesperso-orange.fr/jean.mouric/. Pour les utilisateurs de Emacs, vous pouvez charger le mode tuareg : http ://www.emacswiki.org/emacs/TuaregMode. CAML sous Emacs avec le mode tuareg : CAML sous JavaCaml : Pour utiliser l’interpréteur dans un terminal, on utilisera ledit qui permet d’avoir quelques fonctionnalités comme l’accès à l’historique par les flèches : $ ledit ocaml Guillaume CONNAN - IUT de NANTES - Département informatique - Licence Creative Commons BY: $ C - 5 février 2012
  • 3. CHAPITRE 1. CAML POUR L’IMPATIENT 3 Quelques ressources électroniques2 – Une passionnante introduction à OCAML par un de ses papas... http ://caml.inria.fr/pub/distrib/books/llc.pdf – Le manuel de référence de CAML par Xavier LEROY et Pierre WEIS : http ://caml.inria.fr/pub/distrib/books/manuel-cl.pdf – Une introduction à CAML : http ://fr.wikibooks.org/wiki/Objective_Caml – Ouvrage de référence CAML : http ://www.pps.jussieu.fr/Livres/ora/DA-OCAML/ – Ressources CAML : http ://caml.inria.fr/resources/index.fr.html – Un tutoriel en français : http ://www.ocaml-tutorial.org/tutoriel_objective_caml Les nombres3 Nous utiliserons dans tout le document la version basique de CAML (en fait OCAML (c’est- à-dire CAML avec des modules pour faire de la programmation orientée objet) ou CAML Light (c’est la version de base que nous utiliserons)) sans charger de modules complémen- taires sauf éventuellement pour créer des graphiques ou travailler sur certaines listes. Nous travaillerons en mode toplevel c’est-à-dire que nous compilerons automatiquement de manière interactive. Pour se repérer, ce que nous taperons sera précédé d’un # et ce que renverra CAML sera précédé le plus souvent d’un -. On peut travailler avec des entiers : # 1+2;; - : int = 3 # succ 1;; - : int = 2 # pred 0 ;; - : int = -1 # abs(-3) ;; - : int = 3 Vous remarquerez que CAML répond que le résultat de 1+2 est un entier (int) égal à 3. En effet, CAML est adepte de l’inférence de type, c’est-à-dire qu’il devine quel type de variable vous utilisez selon ce que vous avez tapé. Nous en reparlerons plus bas. Les priorités des opérations sont respectées. En cas d’ambiguïté, un parenthésage implicite à gauche est adopté : # 1+2*3;; - : int = 7 # 1-2+3;; - : int = 2 # 1-(2+3);; - : int = -4 # (1+2)*3;; - : int = 9 Guillaume CONNAN - IUT de NANTES - Département informatique - Licence Creative Commons BY: $ C - 5 février 2012
  • 4. 4 1.3. LES NOMBRES La division renvoie le quotient entier bien sûr : # 11/3;; - : int = 3 # 11/3*2;; - : int = 6 # 11/(3*2);; - : int = 1 On peut utiliser mod pour le reste entier : # 7 mod 2;; - : int = 1 # 7/2;; - : int = 3 # 7-7/2*2;; - : int = 1 Enfin, les entiers sont de base compris entre −231 et 231 −1 sur un processeur 32 bits et entre −263 et 263 −1 sur un processeur 64 bits. # max_int;; - : int = 4611686018427387903 On peut travailler avec des nombres écrits dans des bases différentes en les faisant précéder de 0b pour la notation binaire, 0o pour la notation octale et 0x pour la notation hexadéci- male : # 0xa;; - : int = 10 # 0xa0;; - : int = 160 # 0b1011;; - : int = 11 Les nombres non entiers sont de type float. Ils sont représentés en interne par deux en- tiers : une mantisse m et un exposant n tel que le nombre flottant soit m ×2n . En externe, il apparaît sous forme décimale, le séparateur étant le point. # 1.;; - : float = 1. Attention alors aux opérations : # 3.14 + 2;; Characters 0-4: 3.14 + 2;; ^^^^ Error: This expression has type float but an expression was expected of type int Cela indique que vous avez utilisé l’addition des entiers pour ajouter un entier à un flot- tant. CAML en effet n’effectue pas de conversion implicite et demande que celle-ci soit ex- plicite. Cela peut apparaître comme contraignant mais permet l’inférence de type qui évite nombre de « bugs ». Guillaume CONNAN - IUT de NANTES - Département informatique - Licence Creative Commons BY: $ C - 5 février 2012
  • 5. CHAPITRE 1. CAML POUR L’IMPATIENT 5 Les opérations arithmétiques sur les entiers doivent donc être suivies d’un point : # 1. +. 2.1 ;; - : float = 3.1 # 1.2 +. 2.1 ;; - : float = 3.3 # 1./.2.;; - : float = 0.5 # 1.5e-5 *. 100. ;; - : float = 0.0015 # sqrt(2.);; - : float = 1.41421356237309515 # 3.**2.;; - : float = 9. # log(2.);; - : float = 0.693147180559945286 # exp(1.);; - : float = 2.71828182845904509 # cos(0.);; - : float = 1. # cos(2.*.atan(1.));; - : float = 6.12303176911188629e-17 # sin(2.*.atan(1.));; - : float = 1. # 1./.0.;; - : float = infinity # abs_float(-3.0);; - : float = 3. # 2.**10. ;; - : float = 1024. Il existe des moyens de convertir un entier en flottant : # float(1) +. 3.1;; - : float = 4.1 # float 1 +. 3.1;; - : float = 4.1 et inversement : # int_of_float(sqrt(2.));; - : int = 1 Il ne faut pas confondre int_of_float et floor # floor(2.1);; - : float = 2. # int_of_float(2.1);; - : int = 2 # floor(-2.1);; - : float = -3. # int_of_float(-2.1);; - : int = -2 Guillaume CONNAN - IUT de NANTES - Département informatique - Licence Creative Commons BY: $ C - 5 février 2012
  • 6. 6 1.4. LES AUTRES TYPES DE BASE Les autres types de base4 4 1 Les booléens Ils sont bien sûr au nombre de deux : true et false. Nous en aurons besoin pour les tests. Les fonctions de comparaison renvoient un booléen. On peut combiner des booléens avec not, & et or : # 3>2;; - : bool = true # 3 == 2;; - : bool = false # 3 <> 2;; - : bool = true # (3>2) && (3=2);; - : bool = false # (3>2) || (3=2);; - : bool = true # (3>2) && not(3=2);; - : bool = true # (3>2) && not(3=2) && (0<1 || 1>0);; - : bool = true On peut utiliser 3 = 2 ou 3 == 2 mais cela mérite attention pour les valeurs qui ne sont pas de type booléen ou entier : # let n = 1;; val n : int = 1 # let m = 1;; val m : int = 1 # n = m;; - : bool = true # n == m;; - : bool = true mais # let x = 1.0;; val x : float = 1. # let y = 1.0;; val y : float = 1. # x = y ;; - : bool = true # x == y ;; - : bool = false L’égalité structurelle = explore leur structure alors que l’égalité physique == teste si les deux valeurs occupent la même zone mémoire. 4 2 Les chaînes de caractères En anglais : string. On les entoure de guillemets vb+"+ et on les concatène avec ^ : Guillaume CONNAN - IUT de NANTES - Département informatique - Licence Creative Commons BY: $ C - 5 février 2012
  • 7. CHAPITRE 1. CAML POUR L’IMPATIENT 7 # "Tralala "^"pouet pouet";; - : string = "Tralala pouet pouet" Ce ne sont pas des objets « fonctionnellement purs » car on peut les modifier comme les vecteurs, à la manière de tableaux statiques. 4 3 Les caractères En CAML : char. On les utilisera surtout pour la cryptographie. Il sont entrés entre accents aigus : # ’a’;; - : char = ’a’ On peut faire des aller-retours caractère/code ASCII : # int_of_char ’a’;; - : int = 97 # char_of_int 97;; - : char = ’a’ Les n-uplets5 Entre parenthèses, ils permettent de grouper plusieurs valeurs qui peuvent être de types différents : # (1,"1",1.0,’1’);; - : int * string * float * char = (1, "1", 1., ’1’) Listes6 Il existe un type liste qui est chaînée et dont le longueur est donc dynamique mais on n’a accès qu’à son premier élément comme nous le verrons plus tard. On a cependant un opé- rateur binaire de concaténation @ : # let liste = [1;2;3] ;; val liste : int list = [1; 2; 3] # 0::liste ;; - : int list = [0; 1; 2; 3] # [1;2] @ [3;4];; - : int list = [1; 2; 3; 4] Attention ! L’inférence de type a ses petites manies : # [1; "deux" ; 3.0];; Characters 4-10: [1; "deux" ; 3.0];; ^^^^^^ Guillaume CONNAN - IUT de NANTES - Département informatique - Licence Creative Commons BY: $ C - 5 février 2012
  • 8. 8 1.7. CRÉATION DE TYPES Error: This expression has type string but an expression was expected of type int # [1; 2 ; 3.0];; Characters 8-11: [1; 2 ; 3.0];; ^^^ Error: This expression has type float but an expression was expected of type int Création de types7 On n’insistera pas sur ce point pour l’instant. Voyons juste un exemple simple : # type couleur = Trefle | Carreau | Coeur | Pique ;; type couleur = Trefle | Carreau | Coeur | Pique # [Trefle ; Carreau] ;; - : couleur list = [Trefle; Carreau] Les déclarations8 8 1 Cas général C’est comme en maths...mais en anglais ! Donc Soit se dit Let : # let x=3*2;; val x : int = 6 # 2+x;; - : int = 8 # let pi=acos(-1.);; val pi : float = 3.14159265358979312 # sin(pi/.2.);; - : float = 1. Le nom des identificateurs doit commencer par une lettre minuscule. 8 2 Déclarations locales On peut définir localement une variable, c’est-à-dire que sa portée ne dépassera pas l’ex- pression où elle a été définie : # let x = 3 in x + 1 ;; - : int = 4 La définition est bien locale : # x ;; Guillaume CONNAN - IUT de NANTES - Département informatique - Licence Creative Commons BY: $ C - 5 février 2012
  • 9. CHAPITRE 1. CAML POUR L’IMPATIENT 9 Characters 0-1: x ;; ^ Error: Unbound value x let (x,y) = (1,2) in x + y ;; - : int = 3 8 3 Déclarations simultanées On utilise and qu’il ne faudra donc pas confondre avec & ou bien on peut utiliser un n- uplet : # let x=3 and y=5;; val x : int = 3 val y : int = 5 # x+y;; - : int = 8 # let (a,b)=(3.,5.);; val a : float = 3. val b : float = 5. Fonctions9 Une expression fonctionnelle est un paramètre formel (le nom de la variable) suivi d’un corps qui est une expression. On peut créer des fonctions avec function : # let delta = function | (a,b,c) -> b*b-4*a*c;; val delta : int * int * int -> int = <fun> # delta(1,1,1);; - : int = -3 Notez le val delta : int * int * int -> int = <fun> qui indique que la fonction construite...est une fonction (<fun>) qui va de Z3 dans Z. On peut de manière plus standard (informatiquement parlant !) définir la fonction par son expression générale : # let discriminant(a,b,c)=b*b-4*a*c;; val discriminant : int * int * int -> int = <fun> # discriminant(1,1,1);; - : int = -3 On peut disjoindre des cas : c’est le fameux filtrage par motif (« pattern matching ») # let sina = function | 0. -> 1. Guillaume CONNAN - IUT de NANTES - Département informatique - Licence Creative Commons BY: $ C - 5 février 2012
  • 10. 10 1.9. FONCTIONS | x -> sin(x)/.x;; val sina : float -> float = <fun> # sina(0.);; - : float = 1. # sina(0.1);; - : float = 0.998334166468281548 On peut rendre le paramètre du filtrage explicite : let rec factorielle n = match n with | 0 -> 1 | n -> n * factorielle (n-1);; On peut travailler avec autre chose que des nombres : # let mystere = function | (false,true) -> true | (true,false) -> true | _ -> false;; val mystere : bool * bool -> bool = <fun> Le tiret _ indique « dans tous les autres cas ». On peut aussi créer des fonctions polymorphes, c’est-à-dire qui ne travaillent pas sur des types de variables particuliers. let composee(f,g) = function | x ->f(g(x));; val composee : (’a -> ’b) * (’c -> ’a) -> ’c -> ’b = <fun> Ici, f est toute fonction transformant un type de variable a en un type de variable b et g une fonction transformant un type de variable c en un type de variable a. La fonction composée transforme bien un type de variable c en un type de variable b. Si nous reprenons la fonction définie précédemment : let carre = function | x -> x*.x;; val carre : float -> float = <fun> # composee(sina,carre);; - : float -> float = <fun> # composee(sina,carre)(3.);; - : float = 0.04579094280463962 On peut définir des opérateurs infixes qui seront utilisables de manière plus naturelle : # let (%) x y = x+y;; val ( % ) : int -> int -> int = <fun> # 3 % 2 ;; - : int = 5 Guillaume CONNAN - IUT de NANTES - Département informatique - Licence Creative Commons BY: $ C - 5 février 2012
  • 11. CHAPITRE 1. CAML POUR L’IMPATIENT 11 If...then...else10 On peut utiliser une structure conditionnelle pour définir une fonction : let valeur_abs(x)= if x>=0 then x else -x;; val valeur_abs : int -> int = <fun> Notons que chaque branche de l’arbre (la branche then et la branche else) doit être du même type. Fonctions récursives11 C’est une fonction construite à partir d’elle-même. On utilise la même syntaxe que pour une fonction simple mais on fait suivre le let d’un rec : let rec factorielle = function | 0 -> 1 | n -> n*factorielle(n-1);; val factorielle : int -> int = <fun> let rec fact(n)= if n=0 then 1 else n*fact(n);; val fact : int -> int = <fun> Définition locale de fonctions12 let nb_sol(a,b,c) = let delta(a,b,c) = b*b - 4*a*c in if delta(a,b,c) = 0 then 1 else if delta(a,b,c) < 0 then 0 else 2;; Récursion terminale13 let rec succ = function |0 -> 1 |n -> 1 + succ(n-1) ;; val succ : int -> int = <fun> Guillaume CONNAN - IUT de NANTES - Département informatique - Licence Creative Commons BY: $ C - 5 février 2012
  • 12. 12 1.14. EXCEPTIONS # succ(100000);; - : int = 100001 # succ(1000000);; Stack overflow during evaluation (looping recursion?). On arrive à la limite de la pile. let succ(n) = let rec local = function | (0,acc) -> acc | (n,acc) -> local(n-1,1 + acc) in local(n,1);; val succ : int -> int = <fun> # succ(100000000);; - : int = 100000001 Caml peut dérécursifier les récursions terminales et n’utilise plus sa pile qui ne peut donc plus être saturée. Exceptions14 Pour régler les problèmes d’ensemble de définition d’une fonction, on utilise des excep- tions. Certaines sont prédéfinies (voir la liste disponible sur caml.inria.fr/pub/docs/manual-ocaml/manual033.html#htoc253) Par exemple : # exception Liste_vide;; exception Liste_vide # let tete = function |[] -> raise Liste_vide |t::q -> t;; val tete : ’a list -> ’a = <fun> # tete [3;4;5;6];; - : int = 3 # tete ["un";"deux";"trois"];; - : string = "un" # tete([]);; Exception: Liste_vide. Au cas zoù, on peut programmer en impératif15 En programmation fonctionnelle, on calcule une valeur par application d’une fonction. En programmation impérative, on crée un état qu’on modifie au cours du programme au gré d’instructions. Guillaume CONNAN - IUT de NANTES - Département informatique - Licence Creative Commons BY: $ C - 5 février 2012
  • 13. CHAPITRE 1. CAML POUR L’IMPATIENT 13 15 1 Vecteurs Il existe un type tableau (ou vecteur) comme dans de nombreux langages. Sa longueur est fixée lors de sa création ce qui permet d’avoir accès à ses composantes : # let t = [|1;2;3|] ;; val t : int array = [|1; 2; 3|] # t.(2) ;; - : int = 3 # t.(2) <- 5;; - : unit = () # t ;; - : int array = [|1; 2; 5|] 15 2 Chaînes de caractères Ce sont ne quelque sorte des vecteurs de caractères. # let chaine = "Ich bin ein Berliner";; val chaine : string = "Ich bin ein Berliner" # chaine.[1] ;; - : char = ’c’ # chaine.[1] <- ’C’;; - : unit = () # chaine;; - : string = "ICh bin ein Berliner" 15 3 Type unit Il existe des fonctions qui jouent le rôles des procédures dans des langages impératifs et sont à effets de bords. Ocaml étant typé, il y a un type pour ces fonctions : unit. # print_string "Tralala" ;; Tralala- : unit = () Une autre action extra-fonctionnelle est la modification en place d’un vecteur à l’aide de <- : # let v = [|1;2;3|];; val v : int array = [|1; 2; 3|] # v.(2) <- 37 ;; - : unit = () # v ;; - : int array = [|1; 2; 37|] On évitera ce genre d’action extra-fonctionnelle dans la mesure du possible. 15 4 Entrées/sorties Voici un exemple : print_newline ();; print_string "Entrez un entier : ";; let a = read_int ();; print_newline ();; Guillaume CONNAN - IUT de NANTES - Département informatique - Licence Creative Commons BY: $ C - 5 février 2012
  • 14. 14 1.15. AU CAS ZOÙ, ON PEUT PROGRAMMER EN IMPÉRATIF print_string "Entrez un autre entier : ";; let b = read_int ();; print_newline ();; print_string "Leur somme vaut :";; print_int a;; print_string " + ";; print_int b;; print_string " = ";; print_int (a+b);; print_newline ();; print_newline ();; et on obtient, si l’on a nommé ce fichier IO.ml : $ ocaml IO.ml Entrez un entier : 1 Entrez un autre entier : 2 Leur somme vaut :1 + 2 = 3 $ 15 5 Références Même si Caml fait une incursion dans la programmation impérative, il la clarifie un peu en obligeant à distinguer le nom d’une référence et son contenu. Une référence est en fait un pointeur vers une valeur. La valeur référencée est atteinte par la fonction préfixe !. Elle peut être modifiée avec la fonction infixe :=. On ne pourra pas écrire x := x + 1 comme en C par exemple. La référence est crée avec ref et son contenu est accessible en faisant précéder son étiquette d’un ! : # let x = ref 0 ;; val x : int ref = {contents = 0} # x ;; - : int ref = {contents = 0} # x + 1 ;; Characters 0-1: x + 1 ;; ^ Error: This expression has type int ref but an expression was expected of type int # !x + 1 ;; - : int = 1 # x := !x + 3 ;; - : unit = () # x ;; - : int ref = {contents = 3} # !x ;; - : int = 3 On remarque au passage qu’une réaffectation est bien du type unit. Guillaume CONNAN - IUT de NANTES - Département informatique - Licence Creative Commons BY: $ C - 5 février 2012
  • 15. CHAPITRE 1. CAML POUR L’IMPATIENT 15 15 6 Boucles La syntaxe est usuelle mais il faut faire attention à la distinction référence/contenu : ( * POUR * ) # let som_ent(n) = let s = ref 0 in for i=1 to n do s := !s + i done; !s;; val som_ent : int -> int = <fun> # som_ent(5) ;; - : int = 15 ( * TANT QUE * ) # let som_ent_w(n) = let s = ref 0 in let i = ref 0 in while (!i <= n) do begin s := !s + !i; incr i; end done; !s;; val som_ent_w : int -> int = <fun> # som_ent_w(5) ;; - : int = 15 Guillaume CONNAN - IUT de NANTES - Département informatique - Licence Creative Commons BY: $ C - 5 février 2012