FL-system’s Intelligent Cache
Gurvan Le Guernic, Julien Perret
IRISA, Campus universitaire de Beaulieu,
Avenue du G´en´eral Leclerc, 35042 Rennes Cedex - France
fGurvan.Le Guernic, Julien.Perretg@irisa.fr
R´esum´e : Cet article pr´esente une application de
techniques issues du g´enie logiciel `a la mod´elisation
d’environnements virtuels. Ces derniers, d`es lors qu’ils
sont complexes, constituent des masses de donn´ees
particuli`erement volumineuses et, de ce fait, difficiles
`a manipuler. De plus, les descriptions exhaustives de
ces environnements, c’est-`a-dire explicites, sont peu
´evolutives. Pour r´esoudre ces probl`emes, il existe des
m´ethodes bas´ees sur des syst`emes de r´e´ecriture permettant
de d´ecrire de fac¸on g´en´erique les objets de
l’environnement. Chaque objet est ainsi d´ecrit par un
axiome qui est r´e´ecrit lors de la g´en´eration de l’environnement.
Lors de cette phase, il est fr´equent de retrouver
deux s´equences de r´e´ecriture aboutissant `a un mˆeme
objet. Il est alors possible d’utiliser un m´ecanisme tel que
le cache afin d’am´eliorer les performances en profitant
des calculs d´ej`a effectu´es.
Cependant, se contenter de mettre en correspondance les
noms et param`etres des axiomes n’est pas suffisant pour
´etablir l’ensemble des r´e´ecritures identiques. En effet,
les r´e´ecritures d’un mˆeme axiome avec des param`etres
effectifs diff´erents peuvent aboutir au mˆeme objet. Le
syst`eme propos´e dans cet article effectue une analyse
dynamique des r´e´ecritures afin d’am´eliorer les performances
du cache en d´etectant de tels cas.
La premi`ere partie de cet article pr´esente le syst`eme de
r´e´ecriture, la seconde l’analyse utilis´ee, et la derni`ere le
m´ecanisme propos´e.
Mots-cl´es : R´ealit´e virtuelle - Syst`emes de r´e´ecriture -
3D - Cache 3D - Calcul de d´ependances - Mod´elisation
et informatique fondamentale
1 INTRODUCTION
La gestion d’environnements virtuels 3D de grande
taille comporte des contraintes propres. Elle n´ecessite le
stockage de la description d’un grand nombre d’´el´ements
montrant de fortes similitudes structurelles et apparaissant
`a l’identique ou presque `a plusieurs endroits
de la sc`ene (on pourra par exemple penser `a une
rang´ee de bancs ou de lampadaires). La description
exhaustive d’un environnement urbain dans un langage
3D (e.g. VRML) fige le mod`ele 3D dans un
´etat unique (ou du moins difficilement maintenable) et
n´ecessite une grande capacit´e de stockage. Une solution
consiste `a utiliser le m´ecanisme de r´e´ecriture appel´e FLsystem
[Marvie, 2003, Marvie, 2005]. Ce syst`eme, bas´e
sur les L-systems [Lindenmayer, 1968, Smith, 1984] et
les grammaires de Chomsky [Prusinkiewicz, 2001], permet
de d´ecrire la structure g´en´erale des principaux types
d’´el´ements rencontr´es dans l’environnement urbain tels
que bˆatiments et arbres. La r´e´ecriture d’un axiome initial
`a l’aide de la grammaire associ´ee aux ´el´ements urbains
d’un type donn´e permet la g´en´eration automatique
d’une entit´e urbaine de ce type. Cela permet une description
compacte et ´evolutive d’environnements urbains
3D de grande taille. Il est ainsi possible de construire
de nombreuse entit´es diff´erentes d’un mˆeme type d’objet
en ex´ecutant plusieurs r´e´ecritures de l’axiome initial
avec des param`etres diff´erents.
L’inconv´enient majeur d’une telle m´ethode est le coˆut,
en temps de calcul, impliqu´e par la phase de r´e´ecriture.
Cependant, le surcoˆut impos´e par cette phase peut ˆetre
r´eduit. Dans le cas de la g´en´eration d’une ville de
grande taille, il est probable qu’un mˆeme bˆatiment1 apparaisse
deux fois en des lieux diff´erents de la sc`ene.
Il est encore plus probable d’avoir de multiples occurrences
d’une mˆeme fenˆetre. Il serait donc int´eressant
de pouvoir r´ecup´erer le r´esultat de r´e´ecritures d´ej`a effectu
´ees. Il est bien sur possible d’ajuster la grammaire
pour qu’elle r´eutilise des ´el´ements 3D. N´eanmoins, cette
m´ethode pr´esente l’inconv´enient de compliquer la tache
du r´edacteur des grammaires et de diminuer la g´en´ericit´e
structurelle des r`egles de r´e´ecriture. Une autre solution
consiste `a utiliser un cache. Chaque fois qu’un axiome `a
r´e´ecrire correspond `a une clef du cache, l’objet 3D correspondant
`a cette clef est directement r´eutilis´e.
Dˆu `a la nature param´etrique des axiomes du FL-system,
un syst`eme simple de reconnaissance des clefs du cache
se r´ev`ele insuffisant. Par exemple, un axiome g´en´erateur
de bˆatiments simples (bat) peut ˆetre d´efini `a l’aide de 3
param`etres : d pour la distance au point d’observation (valant
1 pour un bˆatiment tr`es ´eloign´e), n pour le nombre
d’´etages, et s pour le style du bˆatiment. Pour n constant,
il est probable que cet axiome g´en`ere le mˆeme bˆatiment
quel que soit s lorsque d vaut 1. Ainsi bat(1; 8; s1) et
bat(1; 8; s2) aboutissent au mˆeme objet 3D. Seulement,
il n’est pas ´evident pour un cache na¨ıf que bat(1; 8; s1) et
bat(1; 8; s2) doivent ˆetre consid´er´es comme ´equivalents.
1Nous consid´erons ici deux bˆatiments comme identiques si leurs caract
´eristiques sont suffisamment proches pour pouvoir utiliser, pour les
deux, un mˆeme repr´esentant, i.e. un mˆeme mod`ele g´eom´etrique.
La m´ethode que nous proposons utilise des notions et
m´ecanismes similaires `a ceux que l’on rencontre dans
l’analyse de d´ependances entre les entr´ees et les sorties
d’un programme [Pugh, 1989, Abadi, 1996]. Les travaux
sur les d´ependances sont tr`es nombreux dans le
domaine de la s´ecurit´e informatique, et de nombreux
autres probl`emes du g´enie logiciel ont de forts liens
avec l’analyse de d´ependance [Abadi, 1999]. Dans notre
cas, ce type d’analyse permet par exemple de d´etecter
que lorsque d est ´egale `a 1 le r´esultat final de la
r´e´ecriture de l’axiome bat est d´ependant uniquement de
ses deux premiers param`etres. Ainsi, le syst`eme de cache
peut d´etecter automatiquement qu’il doit consid´erer
bat(1; 8; s1) et bat(1; 8; s2) comme ´equivalents.
Ce document pr´esente tout d’abord une version simplifi
´ee des FL-systems. En section 3, nous introduisons
un calcul dynamique des d´ependances appliqu´e aux FLsystems
permettant d’identifier les param`etres intervenant
dans la r´e´ecriture d’un axiome. La section suivante
pr´esente l’application de ce calcul `a la r´ealisation d’un
cache intelligent pour la phase de r´e´ecriture des FLsystems.
Enfin, nous concluons en section 5.
2 FL-SYSTEM
Les FL-systems permettent de mod´eliser toutes sortes
d’objets g´eom´etriques et, de pr´ef´erence, des objets qui
pr´esentent une structure fortement redondante, tels des
plantes ou des bˆatiments. En effet, bas´es sur une description
grammaticale des objets, les FL-systems permettent
d’utiliser `a bon escient la redondance de l’environnement
mod´elis´e. Cette r´ep´etition nous permet des descriptions
tr`es courtes et g´en´eriques de classes d’objets. Une classe
d’objets est caract´eris´ee par un ensemble de param`etres.
Une instance d’objet est alors obtenue par la d´efinition
d’un ensemble de valeurs associ´ees `a ces param`etres.
N´eanmoins, les valeurs donn´ees `a l’axiome d’un FLsystem
n’ont pas n´ecessairement d’influence sur toutes
les parties de l’objet g´en´er´e. Il est en effet courant qu’une
mˆeme partie d’un objet se retrouve `a l’identique dans un
autre objet de la mˆeme classe, malgr´e des diff´erences importantes
dans les valeurs de leurs param`etres (on pourra
ici penser aux feuilles de deux arbres de la mˆeme esp`ece).
Dans cette section, nous proposons une grammaire et une
s´emantique pour les r`egles de r´e´ecriture des FL-systems.
2.1 Le paradigme d’instanciation d’objets
g´eom´etriques
En informatique graphique, il est courant de vouloir
r´eutiliser des objets g´eom´etriques d´ej`a d´efinis ailleurs,
d’une part pour r´eduire l’espace de stockage, mais aussi
le coˆut d’affichage de ces mod`eles lors de la navigation.
Pour ce faire, Hart [Hart, 1992] propose le paradigme
d’instanciation d’objets g´eom´etriques dans le
cadre de la mod´elisation d’objets fractals. Ainsi, `a partir
de r`egles simples, il devient possible de r´eutiliser lemˆeme
arbre pour d´efinir une forˆet en comportant des centaines,
chaque arbre pouvant lui-mˆeme utiliser plusieurs fois la
mˆeme branche et ainsi de suite. Ce paradigme, aujourd’hui
int´egr´e `a la plupart des langages de mod´elisation
g´eom´etrique (e.g. VRML[Marrin, 1997]), am´eliore tr`es
sensiblement les performances des applications 3D.
Dans le cadre de la mod´elisation d’environnements naturels,
Deussen [Deussen, 1998] propose l’instanciation
approximative comme une extension du paradigme d’instanciation
de Hart. Les objets mod´elis´es proc´eduralement
sont projet´es dans l’espace des param`etres de l’axiome et
ensuite regroup´es par clusters. Chaque cluster repr´esente
alors une instance approximative de tous les objets qui
en font partie, r´eduisant ainsi le nombre d’objets que
contient la sc`ene.
Les FL-systems permettent l’utilisation de noeuds VRML,
et donc l’utilisation du paradigme d’instanciation. Nous
proposons ici un m´ecanisme d’instanciation automatique,
implicite, et transparent pour l’utilisateur. Ce m´ecanisme
est bas´e sur le calcul dynamique des d´ependances dans
les r`egles de r´e´ecriture (cf. section 3).
2.2 La grammaire utilis´ee
Comme le montre la figure 1, ces r`egles sont compos
´ees d’une partie gauche (Axiome), d’une condition
(Cond), et d’une partie droite (Terme). Nous
consid´ererons ici que la strat´egie de r´e´ecriture est
d´eterministe et r´ecursive `a gauche, contrairement aux
L-systems dont la r´e´ecriture est parall`ele. Cette restriction
a pour but de rendre d´eterministe chaque ´etape de
la r´e´ecriture d’un axiome. Ceci simplifie la pr´esentation
des travaux d´evelopp´es dans cet article, en particulier les
th´eor`emes pr´esent´es en section 3. De plus, pour contrˆoler
la profondeur de r´e´ecriture, nous utiliserons un param`etre
donn´e `a l’axiome. Ainsi, `a partir d’un axiome donn´e,
une r´e´ecriture engendrera un mot compos´e de terminaux.
Les terminaux, dans les FL-systems, sont des fonctions
et, plus g´en´eralement, des appels `a des primitives
g´eom´etriques quelconques (VRML, OpenGL ou autres).
Pour plus de d´etails sur les strat´egies de r´e´ecriture pouvant
ˆetre appliqu´ees sur les FL-systems, ainsi que sur la
nature des mots g´en´er´es, voir [Marvie, 2005].
La figure 2 donne un exemple de FL-system. L’axiome
initialise les param`etres n, , l, w et color, qui
repr´esentent respectivement la profondeur de r´e´ecritu2r,e
un angle de rotation, la longueur d’un segment de
branche, le rayon d’une branche et la couleur des feuilles.
Les terminaux rotateX et rotateZ tournent le rep`ere local
autour des axes X et Z respectivement. Le terminal
moveZ d´eplace le rep`ere local le long de l’axe Z, tandis
que les crochets [ et ] empilent et d´epilent le rep`ere local,
permettant la cr´eation facile de sous-branches. Hormis
pour l’axiome L, il existe 2 r`egles de r´e´ecriture
pour tous les axiomes. La premi`ere repr´esente la r`egle de
d´ecomposition de l’axiome `a proprement parler, l’autre
nous assure que lorsque la profondeur de r´e´ecriture est
atteinte, l’axiome est remplac´e par un terminal.
2La profondeur de r´e´ecriture d’un FL-system est son ˆage.
! : true ! A(7; 22:5; 10; 1; green)
A(n; ; l;w; color) : n > 0 ! B(n 1; ; l;w; color) rotateZ( 5) B(n 1; ; l;w; color) rotateZ( 5) B(n 1; ; l;w; color)
A(n; ; l;w; color) : n = 0 !
B(n; ; l;w; color) : n > 0 ! [ rotateX() F(n 1; ; l;w; color) L(n 1; ; l;w; color) A(n 1; ; l;w 0:707; color)]
B(n; ; l;w; color) : n = 0 !
F(n; ; l;w; color) : n > 0 ! F(n 1; ; l;w; color) L(n 1; ; l;w; color) rotateZ( 5) F(n 1; ; l;w; color)
F(n; ; l;w; color) : n = 0 ! cylinder(l;w) moveZ(l)
L(n; ; l;w; color) : true ! [ rotateX( 2) leaf(l; color) ]
FIG. 2 – FL-system pour un buisson modifi´e `a partir d’un L-system propos´e par Prusinkiewicz[Prusinkiewicz, 1990]
V al = R+
V ar ::= [a z]
NAxiome ::= [A Z][a z]?
NTerminal ::= [a z]?
V ::= V ar j V al
Terminal ::= NTerminal ( ExPar? )
OpCond ::= = j >
Cond ::= V OpCond V j true
OpP ar ::= + j j x
ExPar ::= ( ExPar OpP ar ExPar )
j V
Axiome ::= NAxiome ( ExPar? )
Terme ::= Axiome Terme
j Terminal Terme j
RWrule ::= Axiome : Cond ! Terme
FIG. 1 – Proposition de grammaire pour les r`egles de
r´e´ecriture. A? d´esigne une liste d’´el´ements de type A.
FIG. 3 – R´esultat de la r´e´ecriture du L-system de la figure 2
L’axiome A repr´esente un apex3 `a partir duquel sont
cr´e´ees trois branches B. Les branches B se d´ecomposent
en une arˆete F, une feuille L et un nouvel apex A. Chaque
arˆete F est d´ecompos´ee en une arˆete, une feuille, et une
autre arˆete, simulant ainsi le ph´enom`ene de croissance
des branches. Lorsque la profondeur de r´e´ecriture est
nulle, les arˆetes F sont remplac´ees par des cylindres (dont
l’axe de rotation est l’axe Z) grˆace au terminal cylinder.
Les feuilles L sont, quand `a elles, remplac´ees par des objets
g´eom´etriques leaf.
La figure 4 montre les diff´erences entre la strat´egie
de r´e´ecriture parall`ele des L-systems et celle propos´ee
ici pour les FL-systems. N´eanmoins, en s’assurant que
les termes situ´es en partie droite des r`egles d´ecr´ementent
le param`etre n de l’axiome, le r´esultat de la r´e´ecriture
compl`ete du FL-system et du L-system ´equivalent apr`es
n d´erivations successives sont identiques. La figure 3
montre une interpr´etation g´eom´etrique de la r´e´ecriture de
cet exemple.
2.3 La s´emantique utilis´ee
Pour pouvoir utiliser un cache pour les FL-systems,
nous avons besoin d’une s´election des r`egles de r´e´ecriture
d´eterministe. Nous proposons ici une formalisation de
la s´emantique utilis´ee pour la r´e´ecriture des FL-systems.
Tout d’abord, nous d´efinissons R comme la liste (ordonn
´ee) des r`egles de r´e´ecriture d’un FL-system donn´e.
Soit A(v) un axiome tel que v 2 R. Nous avons alors
la s´emantique donn´ee en figure 5.
x 2 Terminaux?
A(p) : c ^ c ! T = first(R;A(v))
x A(v) y !R x eval(T[v=p]) y
FIG. 5 – S´emantique des r`egles de r´e´ecriture
Nous d´efinissons first(R;A(v)) la fonction qui retourne
la r`egle de r´e´ecriture “A(p ) : c ^ c ! T” o`u :
– “A(p) : c ! T” = ri est la premi`ere r`egle de R s’appliquant
(i.e. la condition “c” est vraie) `a A(v)
– c est la conjonction des n´egations des condition des
re`gles pr´ec´edantirdans R et s’appliquant a` un axiome
de nom A
X[a=b] retourne le r´esultat de la substitution dans
X de toutes les occurrences de b par a. Ainsi,
3En biologie, apex est le nom donn´e au sommet d’un organe.
A(7; 22:5; 10; 1; green) A(7; 22:5; 10; 1; green)
B(6; ...) ... B(6; ...) ... B(6; ...) B(6; ...) ... B(6; ...) ... B(6; ...)
[ ...F(5; ...) L(5; ...) A(5; ...) ] ...B(6; ...) ...B(6; ...) [ ...F(5; ...) L(5; ...) A(5; ...) ] ...[ ...F(5; ...) L(5; ...) A(5; ...) ] ...[ ...F(5; ...) L(5; ...) A(5; ...) ]
[ ...B(4; ...) ...B(4; ...) ... B(4; ...)] ...B(6; ...) ...B(6; ...) [ ...B(4; ...) ...B(4; ...) ...B(4; ...)] ...[ ...B(4; ...) ...B(4; ...) ...B(4; ...)] ...[ ...B(4; ...) ...B(4; ...) ...B(4; ...)]
... ...
FIG. 4 – Comparaison des strat´egies de r´e´ecriture entre les FL-systems propos´es (`a gauche) et les L-systems (`a droite).
(A(x+3; y))[(1; 0)=(x; y)] rend A(1 + 3; 0). La fonction
eval(T) parcourt le terme T et ´evalue les expressions
y apparaissant pour obtenir les param`etres
num´eriques de l’´etape de r´e´ecriture suivante. Par
exemple, eval(A(1+3; 0)) retourne A(4; 0).
Exemple 2.1: Un autre exemple de FL-system
! : true ! A(1; 2)
A(m; n) : m = 0 !
A(m; n) : n > 0 ! A(m; n 1)
A(m; n) : n = 0 !
´Etant donn´e le FL-system de l’exemple 2.1, l’axiome
A(1; 2) se r´e´ecrit en A(1; 1) avec first(R;A(1; 2))
´egal :
A(m; n) : :(m = 0) ^ (n > 0) ! A(m; n 1)
Dans cet exemple, la condition m 6= 0 ^ n > 0 donne la
d´ependance vis-`a-vis des variables m et n de la r`egle appliqu
´ee. Si la n´egation de m = 0 n’´etait pas pr´esente,
l’importance de la valeur de m ne serait pas explicite.
Toujours dans ce mˆeme exemple, la fonction eval remplace
le param`etrem par sa valeur (1), et ´evalue l’expression
“n 1” `a 1.
Le paragraphe pr´ec´edent aborde la d´ependance qui existe
entre la valeur des param`etres d’un axiome et le r´esultat
final de sa r´e´ecriture. La section suivante propose d’aller
plus loin dans l’´etude de cette d´ependance.
3 CALCUL DYNAMIQUE DES DE´ PENDANCES
Le syst`eme de cache pr´esent´e dans cet article met `a
profit la propri´et´e de joignabile´itde certains termes dans
un syst`eme de r´e´ecriture [Dershowitz, 1990]. Si deux
termes se r´e´ecrivent en un mˆeme terme sous forme normale
(i.e. compos´e uniquement de terminaux) alors ces
deux termes sont dit joignables. Dans cette section, nous
exposons la m´ethode employ´ee afin de calculer dynamiquement
un ensemble, aussi grand que possible, de
termes joignables avec le terme en cours de r´e´ecriture. La
m´ethode employ´ee s’inspire de travaux sur la confidentialit
´e de programmes s´equentiels [Le Guernic, 2005]. Elle
se base sur la modification de la s´emantique de r´e´ecriture
afin de manipuler des valeurs ´etiquet´ees. La r´e´ecriture
d’un axiome, param´etr´e par des valeurs´etiquet´ees, retourne
alors un terme sous forme normale, lui-mˆeme
marqu´e par une ´etiquette. Cette derni`ere d´ecoule des
´etiquettes des param`etres de l’axiome qui ont influenc´e
cette r´e´ecriture.
3.1 Adaptation de la grammaire
La simple modification, donn´ee en figure 6, de notre
grammaire initiale (figure 1) permet d’int´egrer les valeurs
´etiquet´ees. P(Label) est l’ensemble des ensembles
de Label. Les valeurs (V al) sont maintenant des paires
not´ees “e : n”. Le deuxi`eme ´el´ement de cette paire (n),
aussi appel´e valeur num´erique, appartient `a R+ (“n” est
la valeur utilis´ee dans la section 2). Le premier ´el´ement
(e) est un ensemble de labels formant une ´etiquette.
Chaque ´etiquette de l’axiome initial4 est compos´ee d’un
unique label. Chacun de ces labels n’est utilis´e qu’une
seule fois (cf. exemple 3.1).
Exemple 3.1: Exemple d’´etiquetage initial
A(fl1g : 7; fl2g : 22:5; fl3g : 10; fl4g : 1; fl5g : green)
Etiquette = P(Label)
V al = (Etiquette R+)
FIG. 6 – Grammaire des valeurs ´etiquet´ees
3.2 Une nouvelle s´emantique
La figure 7 pr´esente la nouvelle s´emantique utilis
´ee pour la r´e´ecriture de termes dont les valeurs sont
´etiquet´ees. Cette s´emantique pr´esente de grandes similitudes
avec celle pr´esent´ee dans la section 2. Il est facile
de se convaincre que, mis `a part les ´etiquettes, ces deux
s´emantiques r´e´ecrivent un axiome de la mˆeme fac¸on.
x 2 Terminaux?
A(p) : c ^ c ! T = first(R;A(v))
ec = (var(c ^ c))[lab(v)=p]
eop = (var(op(T)))[lab(v)=p]
e0 = e [ ec [ eop
e : x A(v) y !R e0 : x eval(T[v=p]) y
FIG. 7 – Nouvelle s´emantique des r`egles de r´e´ecriture
Dans cette nouvelle s´emantique, chaque terme est
´egalement ´etiquet´e. Cette ´etiquette identifie l’ensemble
des param`etres qui ont influenc´e la r´e´ecriture. Afin de calculer
la nouvelle ´etiquette d’un terme lors de sa r´e´ecriture,
nous introduisons trois nouvelles fonctions :
op retourne la liste des op´erations contenues dans son
argument. Par exemple, “op(A(x; x + y; x + 1))”
rend la liste [x + y; x + 1].
4On appelle axiome initial, l’axiome servant de point de d´epart `a la
r´e´ecriture.
var retourne l’ensemble des variables de son argument.
Ainsi “var(x > y)” rend en r´esultat l’ensemble
fx; yg.
lab extrait l’´etiquette d’une valeur. Par exemple,
“lab(e : 3)” retourne l’´etiquette e.
La fonction eval est ´egalement modifi´ee afin de calculer
avec des valeurs ´etiquet´ees. Lors de l’´evaluation
d’un param`etre sous forme d’op´eration, eval fait abstraction
des ´etiquettes et effectue l’op´eration `a partir des
valeurs num´eriques. Une nouvelle ´etiquette vide est attribu
´ee au r´esultat. Par exemple, eval(A((e:1) + 3)) retourne
A(; : 4).
Lors de la r´e´ecriture d’un terme t dans un terme 0 t
(e : t !R e0 : t0), la nouvelle ´etiquette (e0) est obtenue en
faisant l’union des labels de l’ancienne ´etiquette avec les
labels des ´etiquettesec et eop, o`u :
ec contient les labels des param`etres influenc¸ant la
s´election de la r`egle de r´e´ecriture pour cette ´etape
de l’´evaluation.
eop contient les labels des param`etres qui sont intervenus
dans le calcul d’une op´eration `a cette ´etape.
3.3 Propri´et´es de la s´emantique
Afin d’´enoncer certaines propri´et´es de la s´emantique,
une relation de projection entre param`etres est tout
d’abord d´efinie. Cette d´efinition s’appuie sur une
repr´esentation des param`etres d’un axiome sous la forme
d’une liste de valeurs ´etiquet´ees. Cette projection s’exprime
en fonction d’une ´etiquette qui restreint les param`
etres pris en compte. On note “P1
e*
P2” la projection
d’une liste de param`etres P1 dans une autre liste
de param`etres P2 de fac¸on restreinte `a l’´etiquette e. Pour
toutes listes de param`etres P1 et P2, P1
e*
P2 si et seulement
si les param`etres, dont l’´etiquette dans P1 est un
sous-ensemble de e, ont la mˆeme valeur num´erique dans
P1 et dans P2. Une d´efinition r´ecursive plus formelle de
cette notion est donn´ee dans la d´efinition 3.1.
D´efinition 3.1 (P1
e*
P2)
– [ ] e* [ ] est vrai
– [e1 : x j RP1] e* [ : y j RP2] est vrai ssi :
1. x = y ou e1 6 e
2. RP1
e*
RP2
Trois nouvelles fonctions sont ´egalement introduites :
labellise prend en argument une liste de valeurs
num´eriques (n) et une liste d’´etiquettes de mˆeme
longueur (e). Elle retourne une liste de valeurs
´etiquet´ees v de meˆme longueur que n. v est
construite de telle sorte que, pour tout i, vi = ei : ni.
Par exemple, labellise([e1; e2]; [5; 1]) retourne la
liste [e1 : 5; e2 : 1].
strip prend en argument un terme T construit `a partir
de valeurs ´etiquet´ees. Elle retourne un terme T’
qui correspond au terme T dont toutes les ´etiquettes
ont ´et´e supprim´ees. Ainsi, strip(A1(:e2; e2 :7))
retourne A(2; 7).
T[v=e]E est une fonction de substitution bas´ee sur les
´etiquettes. Le r´esultat de la substitution T[v =e]E
est le terme T dans lequel les valeurs dont l’´etiquette
apparaˆıt `a la position i dans la liste e ont ´et´e remplac
´ees par la valeur `a la position i dans v. Par
exemple, A(e1 : 2; e2 : 7)[(ea : 3; eb : 4)=(e2; e3)]E
est le terme A(e1 : 2; ea : 3).
Th´eor`eme 3.1 (Stabilit´e une ´etape) 5
Pour tout ´etiquette ei, axiome A, liste de valeurs
num´eriques n et d’´etiquettes ev
telles que
labellise(n; ev
) = v avec v param`etres de A, et
ensemble de r`egles R, si :
ei : A(v) !R e : T
alors, pour toute liste de valeurs v
2 telle que v e* v
2 :
: A(v
2) !R : T’
avec strip(T’) = strip(T[v
2=ev
]E).
Le th´eor`eme 3.1 stipule que, si un axiome A param´etr´e
par v se r´e´ecrit en une ´etape dans le terme T, alors le
mˆeme axiome, param´etr´e par une liste de valeurs dans laquelle
se projette v (restreint par l’´etiquette g´en´er´ee), se
r´e´ecrit en une ´etape dans le terme T’. Les ´etiquettes mises
`a part, ce terme T’ correspond au terme T dans lequel
les valeurs ´etiquet´ees apparaissant dans v ont ´et´e remplac
´ees par les valeurs correspondantes des param`etres
utilis´es pour la r´e´ecriture de T’.
Soit !y
R la fermeture transitive de !R aboutissant `a
un terme sous forme normale. Le corollaire 3.2 est la
sp´ecialisation au cas o`u ei = ; de la g´en´eralisation du
th´eor`eme 3.1 `a!y
R.
Corollaire 3.2 (Reconstructibilit´e) 6
Pour tout axiome A, liste de valeurs num´eriques n et
d’´etiquettes ev
telles que labellise(n; ev
) = v, avec
v param`etres de A, et ensemble de r`egles R, si :
; : A(v) !y
R e : NT
alors, pour toute liste de valeurs v
2 telle que v e* v
2 :
: A(v
2) !y
R : NT’
avec strip(NT’) = strip(NT[v
2=ev
]E ).
3.4 Interpr´etation des ´etiquettes r´esultants de la
r´e´ecriture d’un axiome
Dans la suite de cet article, afin de simplifier la
pr´esentation, les ´etiquettes attribu´ees aux param`etres de
l’axiome initial7 sont index´ees sur les entiers. Ainsi,
e1 est l’´etiquette du premier param`etre, e2 celle du
deuxi`eme, et ainsi de suite. Chacune de ces ´etiquettes est
5La preuve du th´eor`eme 3.1 d´ecoule de l’aspect d´eterministe de la
s´emantique utilis´ee. En effet, `a chaque ´etape de r´e´ecriture, seul l’axiome
le plus `a gauche peut ˆetre r´e´ecrit. De plus, les ´etiquettes des valeurs
intervenant dans l’´evaluation de la condition de la r`egle de r´e´ecriture
retourn´ee par la fonction first font partie de l’´etiquette e g´en´er´ee lors
de l’´etape de r´e´ecriture. Donc toute r´e´ecriture en une ´etape du mˆeme
axiome avec des param`etres dans lesquels se projettent les param`etres
v utilise la mˆeme r`egle de r´e´ecriture.
6La preuve du corollaire 3.2 s’obtient par sp´ecialisation au cas o`u
ei = ; du corollaire ´equivalent o`uien’est pas restreint `a l’ensemble
vide ; ce dernier corollaire ´etant prouv´e par r´ecurrence sur le nombre
d’´etapes de la r´e´ecriture.
7On appelle axiome initial, l’axiome servant de point de d´epart `a la
r´e´ecriture.
compos´ee d’un label unique. Ces labels sont index´es de
la mˆeme fac¸on que les ´etiquettes. Pour tout entier strictement
positif i, ei = flig. L’exemple 3.2 pr´esente l’ensemble
R des r`egles de r´e´ecriture qui sont utilis´ees dans
cette partie.
Exemple 3.2: Ensemble des r`egles des axiomes A et B
A(c; d; x) : c = 0 ! B(d; x)
A(c; d; x) : c > 0 ! v(d + c) A(c 1; d; x)
B(d; x) : d = 0 ! t()
B(d; x) : d > 0 ! u(x) B((d 1); x)
Soit e l’´etiquette associ´ee au terme sous forme normal
r´esultant de la r´e´ecriture de l’axiome C (; : C()v!y
R
e : NT). e contient les labels de tous les param`etres qui
ont influenc´es la s´election des r`egles lors de la r´e´ecriture
de C; et donc la structure g´en´era8ledu terme sous forme
normale obtenu. Par exemple, l’´evaluation de l’axiome
B(e1 : 0; e2 : 3) ext´eriorise9 uniquement l’´etiquette de
son premier param`etre et rend le terme sous forme normale
t(). Celui-ci n’ayant pas de terminaux avec param`
etre, le corollaire 3.2 implique que tout axiome de
la forme B( :0; ) se r´e´ecrit sous forme normale en t().
La r´e´ecriture de l’axiome A(1e: 0; e2 : 0; e3 : 3) fonctionne
de fac¸on similaire. Le r´esultat de sa r´e´ecriture
est donn´e dans l’exemple 3.3. L’interpr´etation du r´esultat
de l’´evaluation de l’axiome A(e1 : 1; e2 : 1; e3 : 1) est
plus complexe. Le r´esultat, donn´e dans l’exemple 3.3,
montre l’ext´eriorisation des ´etiquettes des deux premiers
param`etres uniquement. Il est donc possible d’en d´eduire
que la r´e´ecriture sous forme normale de tout axiome de
la forme A( :1; :1; ) rend un terme ayant pour structure
g´en´erale v( ) u( ) t(). Plus pr´ecis´ement, le param`etre du
terminal v ayant une ´etiquette vide, le corollaire 3.2 implique
que le r´esultat a pour forme v( : 2) u( ) t(). De
plus, ´etant donn´e que le param`etre de u a pour ´etiquette
celle du troisi`eme param`etre de l’axiome initial, ce mˆeme
corollaire implique que la r´e´ecriture sous forme normale
de tout axiome de la forme A( :1; :1; :X) rend un terme
ayant pour forme v( :2) u( :X) t().
Exemple 3.3: R´esultats d’´evaluations
Le tableau suivant pr´esente des exemples d’´evaluation
des axiomes A et B de l’exemple 3.2.
Axiome R´esultat
B(e1 : 0; e2 : 3) e1 : [t()]
A(e1 : 0; e2 : 0; e3 : 3) fl1; l2g : [t()]
A(e1 : 1; e2 : 1; e3 : 1) fl1; l2g : [v(; : 2); u(e3 : 1); t()]
4 APPLICATION `AUN SYST ` EME DE CACHE
Comme pr´esent´e en introduction, le but de ce travail
est d’acc´el´erer la r´e´ecriture des FL-systems pr´esent´es en
section 2 `a l’aide d’un m´ecanisme de cache appel´e cache
8i.e. abstraction faite des param`etres des terminaux.
9On dit qu’une r´e´ecriture ext´eriorise une ´etiquette si cette ´etiquette
se retrouve dans l’´etiquette du terme sous forme normale obtenu.
intelligent. Dans un cache standard, la paire (clef,valeur)
g´en´er´ee par une r´e´ecriture est tr`es simple. La clef correspond
a l’axiome initial. Elle inclue le nom de l’axiome et
la valeur effective de ses param`etres. La valeur associ´ee `a
cette clef est le terme normal obtenu lors de la r´e´ecriture.
Cependant, il arrive qu’un param`etre n’intervienne pas
dans la r´e´ecriture de l’axiome, soit pour une raison de
niveau de d´etails pris en compte, soit parce que le param`
etre intervient uniquement au moment du rendu de
l’environnement virtuel. Ainsi, avec les r`egles propos´ees
dans l’exemple 3.2 et comme indiqu´e dans la section 3.4,
les axiomes B(0; 3) et B(0; 0) se r´e´ecrivent de la mˆeme
fac¸on. En utilisant un calcul de d´ependance comme celui
qui est pr´esent´e en section 3, il est possible d’am´eliorer
la couverture de la clef de fac¸on `a ce qu’une concordance
soit d´eclench´ee dans le cache pour deux axiomes
qui ne diff`erent que par la valeur de param`etres n’intervenant
pas dans la r´e´ecriture de ces axiomes. Cette section
pr´esente tout d’abord la m´ethode de g´en´eration des clefs
´etendues et des valeurs associ´ees. L’utilisation de ces
paires (clef,valeur) est ensuite expliqu´ee et prouv´ee correcte
au regard de la s´emantique donn´ee dans la figure 7.
Enfin, la question de la gestion des paires (clef,valeur) est
abord´ee.
4.1 G´en´eration des clefs et valeurs
Comme expos´e en section 3, `a partir de l’´evaluation
d’un axiome param´etr´e A, il est possible de d´eterminer
automatiquement la forme normale r´e´ecrite d’un ensemble
A d’axiomes de mˆeme nom (A) mais param´etr´es
par des valeurs diff´erentes. Afin d’utiliser ce r´esultat dans
un syst`eme de cache, il reste `a d´efinir une m´ethode pour
extraire automatiquement une clef caract´erisant l’ensemble
A. Il convient ´egalement de d´eterminer la valeur
qui doit ˆetre associ´ee `a cette clef.
Pour ce faire, deux nouvelles fonctions sont d´efinies :
gen prend en argument une liste de valeurs ´etiquet´ees
v et une ´etiquette e. Elle renvoie une liste de
valeurs non-´etiquet´ees. L’´el´ement `a la position i
est la valeur num´erique de vi
10 si l’´etiquette
de vi est un sous-ensemble de e, et sinon.
Par exemple, gen([fl1g:1; fl2g:1; fl3g: 1]; fl1; l2g)
renvoie [1; 1; ].
ffonc prend en argument un terme sous forme normale
T dont les terminaux le composant sont param´etr´es
par des valeurs ´etiquet´ees. Elle renvoie un terme
sous forme normale T’ dont les terminaux le composant
sont param´etr´es par des valeurs non-´etiquet´ees.
tj est le terminal `a la position j dans T, et t0
j celui
`a la mˆeme position dans T’. t0
j est construit `a partir
de tj en remplac¸ant chaque valeur e : v par #i si
l’´etiquette e est compos´ee uniquement du labeli,let
v sinon. Par exemple, ffonc(v(;:2) u(fl3g:1) t())
renvoie “v(2) u(#3) t()”.
Lors d’une r´e´ecriture sous forme normale d’un axiome A
param´etr´e par les valeurs ´etiquet´ees:v
; : A(v) !y
R e : NT
10vi est l’´el´ement `a la position i dans v .
le m´ecanisme de cache g´en`ere la clef A(gen(v ; e)) et
y associe la valeur ffonc(NT). L’exemple 4.1 montre
les paires (clef,valeur) g´en´er´ees par les ex´ecutions de
l’exemple 3.3.
Exemple 4.1: Mise en cache
En utilisant les ´evaluations pr´esent´ees dans
l’exemple 3.3, le tableau suivant pr´esente les couples
(clef,valeur) mis en cache :
Clef Valeur
B(0; ) [t()]
A(0; 0; ) [t()]
A(1; 1; ) [v(2); u(#3); t()]
4.2 Utilisation du cache
Afin de formaliser l’utilisation du cache, une relation
de concr´etisation entre listes d’´el´ements appartenant `a
R+ [ f g est introduite dans la d´efinition 4.1. Une liste
lc est une concr´etisation d’une liste de mˆeme longueurla,
not´e lc la, si et seulement si tout ´el´ement appartenant `a
R+ dans la est ´egal `a l’´el´ement `a la mˆeme position dans
lc.
D´efinition 4.1 (lc la)
– [ ] [ ] est vrai
– [x j RLc] [y j RLa] est vrai ssi :
1. y = x ou y =
2. RLc RLa
On d´efinit ´egalement une fonction not´ee T[]v]. T est un
terme sous forme normale et v est une liste de valeurs
non-´etiquet´ees. Cette fonction substitue dans T les identifiants
introduits par la fonction ffonc (#i) par la valeur
`a la position i dans la liste de valeurs v.
Le cache est utilis´e de la fac¸on suivante. On consid`ere la
r´e´ecriture de l’axiome A param´etr´e par les valeurs non-
´etiquet´eesv
c . Si il existe une paire (A(v
a), T) telle que
v
c v
a, alors le cache rend directement le terme sous
forme normale T[v
c ]]. La correction du m´ecanisme est
prouv´ee par le th´eor`eme 4.3 ; lui-mˆeme prouv´e `a l’aide
des lemmes 4.1 et 4.2 ainsi que du corollaire 3.2. Le
r´esultat de l’application du m´ecanisme de cache `a la
r´e´ecriture de l’axiomeA(1; 1; 5), lorsque A(1; 1; 3) a d´ej`a
´et´e r´e´ecrit, se trouve dans l’exemple 4.2.
Exemple 4.2: Utilisation du cache
Dans cet exemple, le cache contient les paires (clef, valeur)
donn´ees dans le tableau de l’exemple 4.1. Entre
autre, il contient la paire (A(1; 1; ), [v(2); u(#3); t()]).
La liste de valeur (1; 1; 5) est une concr´etisation de
la liste (1; 1; ). Ainsi, pour l’axiome A(1; 1; 5), le
cache rend le terme sous forme normale [v(2); u(5); t()].
Lemme 4.1 (Correction de la clef) Pour toute ´etiquette
e et toutes listes de valeurs ´etiquet´ees v
c et v
a :
v
c gen(v
a; e) ) v
a
e*
v
c
Lemme 4.2 (Correction de la valeur) Pour tout terme
sous forme normale NT, liste de valeurs ´etiquet´ees v
2 ,
et liste d’´etiquettes e telle que l’´etiquette `a la position i
est compos´ee d’un label unique indic´e `a la valeur i :
strip(NT[v
2=e]E) = (ffonc(NT))[v
2 ]]
Th´eor`eme 4.3 (Correction du cache) Pour tout axiome
A, liste de valeurs num´eriques de longueur k n1
et n2
, et
liste d’´etiquettes de longueur k e telle que l’´etiquette `a
la position i est compos´ee d’un label unique indic´e `a la
valeur i, si :
1. ; : A(labellise(n1
; e)) !y
R ef : NT
2. ; : A(labellise(n2
; )) !y
R : NT’
3. n2
gen(labellise(n1
; e); ef )
alors :
strip(NT’) = (ffonc(NT))[n2
]]
4.3 Gestion du cache
Comme pour tout syst`eme de cache, les performances
du m´ecanisme propos´e sont fortement d´ependantes de la
gestion des paires (clef,valeur) par le cache. En effet, si le
cache contient trop de paires, le syst`eme risque de passer
plus de temps `a essayer de faire correspondre l’axiome
`a r´e´ecrire avec une clef du cache qu’`a r´e´ecrire l’axiome
en question. La r´esolution de ce probl`eme s’op`ere `a deux
niveaux. Tout d’abord, il convient de limiter le nombre de
paires (clef,valeur) candidates `a l’insertion dans le cache.
Enfin, le remplacement de paires pr´esentes dans le cache
par de nouvelles doit s’effectuer intelligemment.
Le m´ecanisme de g´en´eration de clefs en produit
´enorm´ement.`A chaque niveau de r´e´ecriture d’un axiome,
une paire (clef,valeur) est g´en´er´ee. Il convient de limiter
cette prolif´eration en ignorant les paires correspondant
`a un nombre r´eduit d’´etapes de r´e´ecriture. Entre
autre, les clefs produites lors d’une r´e´ecriture utilisant
une r`egle dont le membre droit est compos´e exclusivement
de terminaux doivent ˆetre ignor´ees. Il est ´egalement
n´ecessaire de ne pas prendre en compte les paires produites
lors de la r´e´ecriture d’axiomes rencontr´es exceptionnellement.
Une grande part de ce travail peut ˆetre
effectu´ee par l’auteur d’un FL-system en indiquant les
axiomes les plus g´en´eriques, et donc int´eressant a prendre
en compte pour la g´en´eration des clefs. Par exemple,
un FL-system produisant une forˆet fera une utilisation
intensive de l’axiome g´en´erant un arbre. Celui-ci ´etant,
`a priori, relativement complexe, il est int´eressant de le
prendre en compte pour la g´en´eration des paires.
Lors de l’insertion d’une paire dans le cache, les
m´ethodes standards utilis´ees dans le domaine des caches
permettent d’am´eliorer les performances. De plus, le
m´ecanisme introduit dans cet article permet, dans certains
cas, d’augmenter les capacit´es du cache sans augmenter
sa taille. En effet, lors de l’entr´ee dans le cache d’une
paire (c; v), si il existe une paire (c0; v0) pr´esente dans le
cache telle que c0 c, il est possible de remplacer (c0; v0)
par (c; v) sans perte d’expressivit´e du cache. En effet, la
valeur v0 peut ˆetre r´eg´en´er´ee `a partir de v.
! : true ! I(30; 6; 22:5; 10; 1; green)
I(f; n; ; l;w; color) : f > 0 ! A(n; + rand(2; 2) 0:5; l + rand(10; 10) 0:1;
w + rand(2; 2) 0:5; color + rand(10; 10) 0:1) I(f 1; n; ; l; w; color)
I(f; n; ; l;w; color) : f = 0 !
FIG. 8 – FL-system pour une forˆet de buissons utilisant le FL-system de la figure 2 (pour simplifier, nous consid´erons ici
les couleurs comme des r´eels. green est donc une constante r´eelle.)
4.4 R´esultats exp´erimentaux
Le FL-system pr´esent´e en figure 8 ´etend celui de la figure
2. Le param`etre f est ajout´e afin de permettre un dimensionnement
facile du nombre de buissons engendr´es
par le FL-system. Les param`etres suivants sont les mˆemes
qu’auparavant, mais ils sont ici utilis´es en combinaison
avec la fonction rand(a; b) qui d´elivre un entier compris
entre a et b (inclus). Cette derni`ere introduit ainsi du bruit
dans les param`etres des buissons g´en´er´es. Un prototype
utilisant ce FL-system a ´et´e impl´ement´e en Prolog. Il simule
la r´e´ecriture d’un terme sans cache, avec un cache
simple, ou avec le syst`eme de cache propos´e dans cet article.
Chaque clef du cache simple se compose du nom
de l’axiome et des valeurs effectives des param`etres de
l’axiome ayant servi `a la g´en´eration de cette clef. La figure
9 donne, en fonction du type de cache utilis´e, le
temps de r´e´ecriture d’un terme correspondant `a trente
buissons de structure identique mais de formes et de couleurs
diff´erentes, i.e. des axiomes A ayant des valeurs
diff´erentes pour les param`etre , l, w et color. L’axe des
abscisses repr´esente la profondeur de r´e´ecriture, c’est-
`a-dire la valeur du param`etre n donn´e aux axiomes, ou
l’ˆage des buissons. Le gain en temps de r´e´ecriture entre
la m´ethode propos´ee dans cet article et la m´ethode sans
cache est illustr´e par la figure 10. La figure 11, quant `a
elle, montre ce mˆeme gain, mais pour des r´e´ecritures de
profondeur de 10 et un nombre de buissons variant de 10
`a 30.
On constate sur les figures 9 et 10 que, plus la profondeur
augmente, plus notre syst`eme de cache s’av`ere
efficace. En effet, par rapport `a la r´e´ecriture sans cache,
la m´ethode propos´ee ici profite alors de l’augmentation
du nombre de termes joignables11 rencontr´es lors de la
r´e´ecriture d’un buisson, c’est-`a-dire de la r´ep´etition dans
sa structure. La figure 11 permet de constater que la
grande g´en´ericit´e des clefs produites permet de g´en´erer
certains buissons directement `a partir du cache, c’est-`adire
de tirer partie de l’augmentation de la probabilit´e de
retrouver des objets joignables lorsque la taille de l’environnement
augmente. Ceci n’est pas possible avec le
cache simple. Par contre, lors d’une r´e´ecriture ne rencontrant
pas de termes aboutissant `a la mˆeme liste d’appel de
primitives graphiques, notre syst`eme de cache est alors
´equivalent au cache simple, voire l´eg`erement plus lent.
De fait, les efforts de g´en´eralisation des clefs seraient
alors une tˆache vaine.
11Deux termes sont dits joignables si leur r´e´ecriture aboutit au mˆeme
terme sous forme normale
Enfin, il est `a noter que la gestion des m´ecanismes de
base du cache par le prototype est tr`es mauvaise. Ceci est
refl´et´e par les mauvais r´esultats du cache simple. Le prototype
de cache intelligent dispose du mˆeme encodage
des m´ecanismes de base, ce qui laisse `a penser qu’une
meilleure impl´ementation permettrait d’obtenir de bien
meilleurs r´esultats.
0
500
1000
1500
2000
2500
2 3 4 5 6 7 8 9 10
sans cache
avec cache simple
avec cache intelligent
PSfrag replacements
Comparaison des temps de r´e´ecriture avec et sans cache
Temps de la r´e´ecriture en ms
Profondeur de r´e´ecriture (n)
FIG. 9 – Temps de r´e´ecriture pour un nombre de buissons
f=30 et une profondeur de n variant de 2 `a 10.
-30
-25
-20
-15
-10
-5
0
5
10
15
20
25
2 3 4 5 6 7 8 9 10
Gain en %
PSfrag replacements
Gain des temps de r´e´ecriture avec et sans cache
Gain en %
Profondeur de r´e´ecriture (n) (avec 30 buissons)
FIG. 10 – Gain en temps de la r´e´ecriture avec cache intelligent
pour l’exp´erience de la figure 9
5 CONCLUSION
Dans cet article, nous avons pr´esent´e un syst`eme
de cache intelligent bas´e sur un calcul dynamique des
d´ependances. Ce nouveau syst`eme de cache pour les
FL-systems permet une abstraction dans le processus de
18.5
19
19.5
20
20.5
21
21.5
22
22.5
23
10 15 20 25 30
Gain en %
PSfrag replacements
Gain des temps de r´e´ecriture avec et sans cache
Gain en %
Nombre de buissons (f)
FIG. 11 – Gain de la r´e´ecriture pour une profondeur de
n=10 et un nombre de buissons f variant de 10 `a 30.
mod´elisation g´eom´etrique : la r´eutilisation des objets
g´eom´etriques, jusqu’ici explicite, devient implicite. Cette
technique est plus efficace qu’un cache simple grˆace `a la
plus grande g´en´ericit´e des paires (clef,valeur) produites.
Il est ainsi possible de g´en´erer la forme normale d’un
axiome qui n’a pas encore ´et´e rencontr´e par instanciation
de la valeur associ´ee `a une clef proche de l’axiome
`a ´evaluer. N´eanmoins, il est important de ne pas calculer
des paires (clef,valeur) pour chaque r`egle de r´e´ecriture,
sous peine de faire d´eborder le cache. Une solution `a
ce probl`eme consiste `a identifier, lors de l’´ecriture d’un
FL-system ou automatiquement par analyse, les r`egles les
plus utilis´ees.
Notre syst`eme de cache permet une plus grande souplesse
dans la mod´elisation d’environnements tr`es complexes.
En effet, consid´erons un FL-system repr´esentant
un arbre et poss´edant un param`etre color stipulant la couleur
des feuilles de celui-ci. Une fois cet arbre utilis´e pour
mod´eliser une forˆet, la modification de la valeur du param`
etre color pourra ˆetre prise en compte de fac¸on automatique
par le cache. L’objet repr´esentant une feuille sera
alors modifi´e pour prendre en compte le changement de
couleur, et le reste de la forˆet changera de couleur par la
mˆeme occasion, sans modifier le cache et sans n´ecessiter
la moindre r´e´ecriture.
Enfin, le FL-system Intelligent Cache constitue une optimisation
compl´ementaire `a l’instanciation approximative
[Deussen, 1998]. En effet, notre technique permet
de d´eterminer quels sont les termes dont les r´e´ecritures
sont identiques, tandis que l’instanciation approximative
permet de regrouper des termes similaires grˆace `a
leur proximit´e dans l’espace des valeurs des param`etres.
Notre technique permettrait donc d’am´eliorer le clustering
en identifiant les param`etres qui n’influencent pas la
r´e´ecriture. En effet, ceci revient `a r´eduire la dimension de
l’espace des param`etres et, de ce fait, `a faciliter le clustering.
Le couplage de ces deux technique constitue donc
une perspective int´eressante pour nos prochains travaux.
BIBLIOGRAPHIE
[Abadi, 1999] Abadi M., Banerjee A., Heintze N. et
Riecke J. G., A core calculus of dependency. Proceedings
of the ACM Symposium Principles of Programming
Languages, pages 147–160.
[Abadi, 1996] Abadi M., Lampson B. et L´evy J.-J., Analysis
and caching of dependencies. Proceedings of the
1996 ACM International Conference on Functional Programming,
pages 83–91. ACM Press.
[Dershowitz, 1990] Dershowitz N. et Jouannaud J.-P.,
Rewrite systems. In van Leeuwen J., editor, Handbook of
Theoretical Computer Science, Volume B : Formal Models
and Sematics (B), pages 243–320. North-Holland,
Amsterdam.
[Deussen, 1998] Deussen O., Hanrahan P., Lintermann
B., Mˇech R., Pharr M. et Prusinkiewicz P., Realistic modeling
and rendering of plant ecosystems. SIGGRAPH
’98 : Proceedings of the 25th annual conference on Computer
graphics and interactive techniques, pages 275–
286, New York, NY, USA. ACM Press.
[Hart, 1992] Hart J. C., The object instancing paradigm
for linear fractal modeling. Proceedings of the conference
on Graphics interface ’92, pages 224–231. Morgan
Kaufmann Publishers Inc.
[Le Guernic, 2005] Le Guernic G. et Jensen T., Monitoring
information flow. In Sabelfeld A., editor, Proceedings
of the 2005Workshop on Foundations of Computer
Security. DePaul University. LICS’05 Affiliated Workshop.
[Lindenmayer, 1968] Lindenmayer A., Mathematical
models for cellular interactions in development, I & II.
Journal of Theoretic Biology, 18 :280–315.
[Marrin, 1997] Marrin C., Carey R. et Bell G., A vrml
specification. Rapport technique, VRML consortium.
http ://www.vrml.org/Sprecifications/VRML97.
[Marvie, 2003] Marvie J.-E., Perret J. et Bouatouch K.,
Remote interactive walkthrough of city models. Proceedings
of Pacific Graphics, volume 2, pages 389–393.
[Marvie, 2005] Marvie J.-E., Perret J. et Bouatouch K.,
Fl-system : A functional l-system for procedural geometric
modeling. The Visual Computer. To appear.
[Prusinkiewicz, 1990] Prusinkiewicz P., Lindenmayer
A., Hanan J. S. et al., The algorithmic beauty of plants.
Springer-Verlag, New York.
[Prusinkiewicz, 2001] Prusinkiewicz P., Mundermann
L., Karwowski R. et Lane B., The use of positional information
in the modeling of plants. Proceedings of Computer
Graphics and Interactive Techniques, pages 289–300.
ACM Press.
[Pugh, 1989] Pugh W. et Teitelbaum T., Incremental
computation via function caching. Conference Record of
the 16th Annual Symposium on POPL, pages 315–328.
[Smith, 1984] Smith A. R., Plants, fractals, and formal
languages. Proceedings of the 11th annual conference
on Computer graphics and interactive techniques, pages
1–10. ACM Press.
Pierre Weis
Xavier Leroy
LE LANGAGE CAML
Deuxi`eme ´edition
Copyright 1992, 1993, 2009 Pierre Weis et Xavier Leroy.
Ce texte est distribu´e sous les termes de la licence Creative Commons BY-NC-SA. Le
texte complet de la licence est disponible `a l’adresse suivante :
http://creativecommons.org/licenses/by-nc-sa/2.0/fr/legalcode
Voici un r´esum´e des droits et conditions de cette licence.
• Vous ˆetes libres :
– de reproduire, distribuer et communiquer cette cr´eation au public
– de modifier cette cr´eation
• Selon les conditions suivantes :
– Paternit´e. Vous devez citer le nom de l’auteur original de la mani`ere indiqu´ee
par l’auteur de l’oeuvre ou le titulaire des droits qui vous conf`ere cette
autorisation (mais pas d’une mani`ere qui sugg´ererait qu’ils vous soutiennent
ou approuvent votre utilisation de l’oeuvre).
– Pas d’Utilisation Commerciale. Vous n’avez pas le droit d’utiliser cette
cr´eation `a des fins commerciales.
– Partage des Conditions Initiales `a l’Identique. Si vous modifiez, transformez
ou adaptez cette cr´eation, vous n’avez le droit de distribuer la cr´eation qui
en r´esulte que sous un contrat identique `a celui-ci.
• A chaque r´eutilisation ou distribution de cette cr´eation, vous devez faire appara
ˆıtre clairement au public les conditions contractuelles de sa mise `a disposition.
La meilleure mani`ere de les indiquer est un lien la page Web ci-dessus.
• Chacune de ces conditions peut ˆetre lev´ee si vous obtenez l’autorisation du titulaire
des droits sur cette oeuvre.
• Rien dans ce contrat ne diminue ou ne restreint le droit moral de l’auteur ou des
auteurs.
`A
mes parents,
`A
Suzanne et Michel,
`A
Lise, Marie, Jean-Baptiste et Ir`ene,
`A
H´el`ene.
Pierre Weis
Table des mati`eres
Avant-propos xi
I Programmer en Caml 1
Avertissement 3
1 Premiers pas 5
1.1 Id´ees g´en´erales sur Caml 5
1.2 Dialoguer avec Caml 6
1.3 Les d´efinitions 6
1.4 Fonctions 8
1.5 Valeurs et programmes 13
1.6 Impression 13
1.7 Conventions syntaxiques 15
1.8 Diagrammes syntaxiques 17
2 R´ecursivit´e 19
2.1 Fonctions r´ecursives simples 19
2.2 D´efinitions par cas : le filtrage 27
2.3 Les tours de Hanoi 28
2.4 Notions de complexit´e 31
3 Programmation imp´erative 37
3.1 La programmation imp´erative 37
3.2 Boucles 39
3.3 Manipulation de polynˆomes 40
3.4 Impression des polynˆomes 42
3.5 Caract`eres et chaˆınes de caract`eres 46
3.6 Les r´ef´erences 47
3.7 Un programme utilisant des r´ef´erences 49
3.8 R´ecursivit´e et boucles 50
3.9 R`egle d’extensionnalit´e 52
3.10 Effets et ´evaluation 53
4 Fonctionnelles et polymorphisme 57
4.1 Notion de polymorphisme 57
4.2 Fonctions d’ordre sup´erieur 59
4.3 Typage et polymorphisme 61
4.4 Curryfication 64
viii Table des mati`eres
4.5 Une fonctionnelle de tri polymorphe 65
4.6 La pleine fonctionnalit´e 67
4.7 Composition de fonctions 70
5 Listes 75
5.1 Pr´esentation 75
5.2 Programmation assist´ee par filtrage 77
5.3 Tri par insertion 78
5.4 Fonctionnelles simples sur les listes 81
5.5 Les polynˆomes creux 83
5.6 Filtrage explicite 84
5.7 Op´erations sur les polynˆomes creux 85
5.8 Animation des tours de Hanoi 88
5.9 Fonctionnelles complexes sur les listes 91
5.10 Efficacit´e des fonctions sur les listes : ´etude de cas 98
5.11 Listes et r´ecurrence 103
5.12 `A la recherche de l’it´erateur unique 105
6 Les structures de donn´ees 109
6.1 Polynˆomes pleins et polynˆomes creux 109
6.2 Types sommes ´elabor´es 113
6.3 Les types somme 116
6.4 Les types produit 116
6.5 M´elange de types somme et types produit 118
6.6 Structures de donn´ees mutables 118
6.7 Structures de donn´ees et filtrage 120
6.8 Structures de donn´ees et r´ecurrence 122
7 Le docteur 125
7.1 Vue d’ensemble 125
7.2 Les exceptions 126
7.3 Fonctions de recherche dans les listes 130
7.4 Traitements de chaˆınes de caract`eres 133
7.5 Cam´elia 135
7.6 Dialogue avec l’utilisateur 140
7.7 Exemple de session 143
7.8 Pour aller plus loin 144
8 Graphisme 147
8.1 Fractales 147
8.2 Le graphisme de Caml 148
8.3 Les nombres en repr´esentation flottante 149
8.4 Le crayon ´electronique 149
8.5 Premiers dessins 152
8.6 Le flocon de von Koch 154
9 Syntaxe abstraite, syntaxe concr`ete 155
9.1 Pr´esentation 155
9.2 Le retard `a l’´evaluation 156
ix
9.3 L’´evaluation des ordres du langage graphique 158
9.4 Syntaxe et s´emantique 159
9.5 Notions d’analyses syntaxique et lexicale 160
9.6 Analyse lexicale et syntaxique 161
9.7 Ajout des proc´edures 168
10 Programmes ind´ependants et modules 179
10.1 Chargement de fichiers 179
10.2 Programmes ind´ependants 180
10.3 Entr´ees-sorties de base 181
10.4 Programmes en plusieurs modules 183
10.5 Interfaces de modules 187
10.6 Compilations interactives 190
11 Interfaces graphiques 193
11.1 Structure d’une interface graphique 193
11.2 Relier des composants entre eux 194
11.3 Un convertisseur de devises 196
11.4 Le jeu du taquin 199
11.5 Pour aller plus loin 201
II Exemples complets 203
Avertissement 205
12 D´emonstration de propositions 207
12.1 La logique math´ematique 207
12.2 Calculs de tables de v´erit´e 210
12.3 Le principe des d´emonstrations 212
12.4 Repr´esentation et v´erification des propositions 213
12.5 Syntaxe concr`ete des propositions 217
12.6 Le v´erificateur de tautologies 221
12.7 Exemples de th´eor`emes 223
12.8 Pour aller plus loin : l’analyseur lexical universel 228
12.9 Pour aller encore plus loin : le hachage 232
13 Compression de fichiers 237
13.1 La compression de donn´ees 237
13.2 Plan du programme 238
13.3 L’algorithme de Huffman 240
13.4 Annexes 247
13.5 Mise en pratique 252
13.6 Pour aller plus loin 252
14 Simulation d’un processeur 255
14.1 Le pico-processeur 255
14.2 Le simulateur 260
14.3 L’assembleur 267
14.4 Pour aller plus loin 275
x Table des mati`eres
15 Compilation de mini-Pascal 277
15.1 Syntaxe abstraite, syntaxe concr`ete 277
15.2 Typage 283
15.3 Compilation 289
15.4 Pour aller plus loin 304
16 Recherche de motifs dans un texte 305
16.1 Les motifs 305
16.2 Syntaxe abstraite et syntaxe concr`ete des motifs 306
16.3 Les automates 309
16.4 Des expressions rationnelles aux automates 310
16.5 D´eterminisation de l’automate 313
16.6 R´ealisation de la commande grep 319
16.7 Annexe 320
16.8 Mise en pratique 321
16.9 Pour aller plus loin 321
III Introspection 323
17 Ex´ecution d’un langage fonctionnel 325
17.1 Le langage mini-Caml 325
17.2 L’´evaluateur 326
17.3 La boucle d’interaction 331
17.4 Mise en oeuvre 333
17.5 Pour aller plus loin 334
17.6 Annexe 336
18 Un synth´etiseur de types 339
18.1 Principes de la synth`ese de types 339
18.2 L’algorithme de synth`ese de types 344
18.3 Repr´esentation des types 348
18.4 L’unification 353
18.5 Inconnues, g´en´eralisation et sp´ecialisation 356
18.6 Impression des types 357
18.7 La boucle d’interaction 358
18.8 Mise en oeuvre 359
18.9 Pour aller plus loin 360
19 En guise de conclusion 365
19.1 Une m´ethodologie de programmation 365
19.2 La compilation de Caml 367
Index 373
Avant-propos
On prononce Caml avec le « ca » de caf´e et le «mel » de melba.
aml est un langage de programmation de conception r´ecente qui r´eussit `a ˆetre `a
la fois tr`es puissant et cependant simple `a comprendre. Issu d’une longue r´eflexion
sur les langages de programmation, Caml s’organise autour d’un petit nombre
de notions de base, chacune facile `a comprendre, et dont la combinaison se r´ev`ele
extrˆemement f´econde. La simplicit´e et la rigueur de Caml lui valent une popularit´e
grandissante dans l’enseignement de l’informatique, en particulier comme premier langage
dans des cours d’initiation `a la programmation. Son expressivit´e et sa puissance
en font un langage de choix dans les laboratoires de recherche, o`u il a ´et´e utilis´e pour
traiter des probl`emes parmi les plus ardus de l’informatique : d´emonstration assist´ee
par ordinateur, analyses automatique de programmes, syst`emes de r´e´ecriture, compilation
et m´etacompilation. En bref, Caml est un langage facile avec lequel on r´esout des
probl`emes difficiles.
Longtemps r´eserv´e `a de grosses machines coˆuteuses, le langage Caml est maintenant
disponible gratuitement sur toute une gamme de machines, du micro-ordinateur
personnel (PC, Macintosh, . . . ) aux stations de travail les plus puissantes, ce qui le
rend accessible `a un vaste public, de l’amateur curieux au professionnel chevronn´e en
passant par l’´etudiant informaticien. `A ce vaste public, Caml apporte une nouvelle
approche de la programmation, des plus fructueuses. L’investissement que vous ferez
en apprenant Caml ne sera pas vain : vous constaterez que le langage vous ouvre des
horizons nouveaux et qu’il est assez puissant pour que vous y exprimiez simplement des
id´ees complexes. Ce qui se con¸coit bien s’´enonce clairement et les programmes pour le
dire vous viennent ais´ement en Caml.
Ce livre se propose donc de faire d´ecouvrir Caml `a tous ceux qui s’int´eressent `a la
programmation. Nous nous sommes efforc´es d’´ecrire un livre accessible `a tout « honnˆete
homme », mais qui permette cependant de maˆıtriser le langage et d’en saisir les beaut´es.
Pour ce faire, nous avons combin´e une introduction progressive aux principaux traits du
langage avec un v´eritable cours de programmation, illustr´e de tr`es nombreux exemples
de programmes qui vous permettront de saisir comment on utilise Caml et de vous
approprier petit `a petit ce merveilleux outil. Les exemples vont jusqu’au d´eveloppement
de programmes complets et d’une longueur respectable. Nous nous effor¸cons de justifier
ces exemples, en les repla¸cant dans leur contexte et en analysant la clart´e et l’efficacit´e
xii Avant-propos
des solutions propos´ees. Cet ouvrage s’organise comme suit :
• La partie I, «Programmer en Caml », introduit progressivement les traits du
langage et les m´ethodes essentielles de programmation en Caml.
• La partie II, «Exemples complets », montre comment r´esoudre en Caml un certain
nombre de probl`emes r´ealistes de programmation.
• La partie III, « Introspection », ´ebauche une impl´ementation de Caml en Caml,
expliquant ainsi le typage et l’´evaluation de Caml.
En compl´ement de ce livre, les auteurs ont ´ecrit un second ouvrage, intitul´e Manuel
de r´ef´erence du langage Caml et publi´e par le mˆeme ´editeur, contenant tout ce qui
est n´ecessaire au programmeur Caml exp´eriment´e : un manuel de r´ef´erence du langage
Caml et un manuel d’utilisation du syst`eme Caml Light, le compilateur Caml que nous
utilisons dans ce livre. Les deux livres sont con¸cus pour ˆetre utilis´es ensemble : le pr´esent
ouvrage renvoie au manuel de r´ef´erence pour une description exhaustive du langage et
des explications d´etaill´ees de certains points techniques ; le manuel de r´ef´erence suppose
connues les notions introduites dans cet ouvrage.
Tous les exemples de ce livre sont pr´esent´es dans le syst`eme Caml Light, un environnement
de programmation en Caml fonctionnant `a la fois sur micro-ordinateurs
(Macintosh et PC) et sur mini-ordinateurs et stations de travail Unix. Il existe d’autres
impl´ementations du langage Caml, comme par exemple Objective Caml, qui ajoute
`a Caml Light des objets et des classes, ainsi qu’un syst`eme de modules plus puissant.
L’essentiel de ce qui est dit dans ce livre porte sur le langage et s’applique donc `a toutes
les impl´ementations. Nous signalerons les quelques points sp´ecifiques au syst`eme Caml
Light. Les lecteurs qui souhaitent consulter la documentation compl`ete du syst`eme
Caml Light peuvent se reporter au Manuel de r´ef´erence du langage Caml, ou `a notre
site Web http://caml.inria.fr/.
Le syst`eme Caml Light est distribu´e gratuitement et peut ˆetre reproduit librement
`a des fins non commerciales. Pour ceux qui ont acc`es au r´eseau Internet, Caml Light
est disponible sur le Web `a l’adresse http://caml.inria.fr/. L’Institut National de
Recherche en Informatique et en Automatique (INRIA) en assure ´egalement la distribution
sur c´ed´eroms. Pour obtenir ce c´ed´erom, reportez-vous `a l’encadr´e qui figure en
page de copyright.
Nous encourageons le lecteur `a se procurer le syst`eme Caml Light et `a l’installer
sur sa machine, suivant les instructions donn´ees par exemple dans le chapitre 12 du
Manuel de r´ef´erence. Il pourra ainsi essayer les exemples et exp´erimenter par lui-mˆeme,
ce qui lui facilitera grandement la lecture de ce livre.
Remerciements
Nous tenons `a remercier Christian Queinnec, Bernard Serpette et G´erard Huet qui
se sont astreints `a relire ce livre, Val´erie M´enissier-Morain qui a particip´e `a l’illustration,
Ian Jacobs pour son assistance typographique et Christian Rinderknecht qui a restaur´e
les lettrines, une calligraphie anglaise du huiti`eme si`ecle. Le jeu de taquin de la section
11.4 est dˆu `a Fran¸cois Rouaix ; l’exemple de la section 11.2 est traduit d’un programme
de John Ousterhout.
I
Programmer en Caml
Avertissement
a premi`ere partie de ce livre est une introduction progressive au langage
Caml. On n’y suppose pas de connaissances pr´ealables autres que des notions
´el´ementaires de math´ematiques du niveau du lyc´ee. Les exemples de programmes
que nous vous pr´esentons vont de l’exemple d’une ligne au vrai programme de
plusieurs pages. Tous les exemples ont ´et´e mˆurement r´efl´echis pour ˆetre soit ´etonnants
(voire amusants, pourquoi pas ?) soit r´eellement utiles ou repr´esentatifs des programmes
qu’on ´ecrit vraiment. Si bien que nous esp´erons que tous pourront nous lire avec profit,
du d´ebutant en programmation, ignorant compl`etement Caml et d´esirant s’en faire une
id´ee, `a l’´etudiant confirm´e qui trouvera mati`ere `a r´eflexion dans des programmes non
triviaux.
En s’adressant `a un si vaste public, nous avons tent´e d’acc´el´erer la lecture de tous :
le d´ebutant verra souvent des sections qu’on lui sugg`ere de ne pas lire, car elles sont
compliqu´ees et pas indispensables pour la suite, tandis que le sp´ecialiste sera invit´e
`a sauter des chapitres entiers si ses connaissances le lui permettent. Par exemple, le
prochain chapitre d´ebute par un avertissement au sp´ecialiste :
Si vous savez d´ej`a que « 2 + 2 ; ; » font « - : int = 4 », . . . , vous pouvez
sauter ce chapitre.
En revanche, le chapitre 3 contient une section «Effets et ´evaluation », qui s’ouvre par
un avertissement au d´ebutant : «Cette section peut ˆetre saut´ee en premi`ere lecture. »
La d´emarche que nous avons adopt´ee, c’est-`a-dire l’apprentissage par des exemples
int´eressants, nous a conduits `a pr´esenter les notions du langage par n´ecessit´e : nous les
expliquons lorsqu’elles interviennent et uniquement l`a. Il se peut donc que certaines
notions, inutiles `a nos programmes, ne soient pas pass´ees en revue. Cela indique clairement
qu’elles ne sont pas essentielles. Si l’on d´esire absolument une vue exhaustive des
possibilit´es de Caml, on consultera le Manuel de r´ef´erence du langage Caml auquel nous
avons d´ej`a fait allusion.
1
Premiers pas
O`u l’on v´erifie que 2 et 2 font 4.
i vous savez d´ej`a que « 2 + 2 ; ; » font « - : int = 4 » et que « let f
= function x -> . . . » signifie « let f x = . . . », vous pouvez sauter ce
chapitre. Sinon, il vous initiera `a l’interaction avec Caml.
1.1 Id´ees g´en´erales sur Caml
Caml est un langage simple : il y a peu de constructions mais ces constructions
sont les plus g´en´erales possibles. Caml utilise des notations intuitives ou consacr´ees par
l’usage et souvent proches de celles des math´ematiques. Par exemple, pour ajouter 1
et 2, il suffit d’´ecrire 1 + 2. Et les chaˆınes de caract`eres, c’est-`a-dire les textes qui ne
doivent pas ˆetre interpr´et´es par le langage, sont ´ecrites entre des guillemets ", notation
classique en informatique.
Bien que r´ealis´e en France, Caml est anglophone : ses mots-cl´es sont en anglais.
Ainsi, les valeurs de v´erit´e de la logique math´ematique, le vrai et le faux, deviennent
true et false en Caml. Ce n’est pas une r´eelle difficult´e, car les mots-cl´es sont peu
nombreux et nous les traduirons au fur et `a mesure.
Caml apporte une grande aide au programmeur, en s’effor¸cant de d´etecter le plus
possible d’erreurs : le langage analyse les programmes qui lui sont soumis pour v´erifier
leur coh´erence avant toute tentative de compilation ou d’ex´ecution. La principale analyse
de coh´erence qu’il effectue se nomme le typage, m´ecanisme qui v´erifie que les
op´erations qu’on utilise sont d´ej`a d´efinies et que les valeurs qu’on leur applique ont un
sens. Par exemple, l’addition n’est d´efinie que pour les nombres, pas pour les valeurs de
v´erit´e ni pour les chaˆınes de caract`eres. Donc true + 1 sera rejet´e, de la mˆeme fa¸con
que 1 + "oui". Vous constaterez vite qu’il est ainsi plus difficile d’´ecrire en Caml des
programmes manifestement faux : le langage les rejette automatiquement. Le corollaire
est ´evidemment qu’il est plus facile d’´ecrire des programmes corrects !
Si vous ˆetes familier avec un langage algorithmique classique, comme Pascal par
exemple, vous ne serez pas compl`etement d´epays´e par Caml : vous y retrouverez la
notion de fonction et une notion similaire `a celle de proc´edure ; d’autre part nous avons
6 Premiers pas
d´ej`a vu que Caml est un langage typ´e. Ces notions sont simplement g´en´eralis´ees et
simplifi´ees : par exemple le typage est automatique et ne n´ecessite pas d’annotations
dans les programmes comme c’est le cas en Pascal.
1.2 Dialoguer avec Caml
Caml offre non seulement un compilateur traditionnel, qui transforme des fichiers de
code source en code compil´e ex´ecutable par la machine, mais aussi un syst`eme interactif
qui vous permet de dialoguer directement avec Caml, sans passer par l’interm´ediaire
d’un fichier. Dans ce mode, le langage s’utilise comme une « calculette » : vous tapez des
phrases au clavier de l’ordinateur et Caml r´eagit en vous donnant imm´ediatement les
r´esultats de vos programmes. Nous utiliserons d’abord cette m´ethode d’interaction directe
car elle facilite l’apprentissage. Nous verrons plus tard l’utilisation du compilateur
ind´ependant, `a partir du chapitre 10. Vous pouvez donc entrer au terminal les exemples
qui suivent, si vous avez d´ej`a install´e le syst`eme Caml Light sur votre machine.
Toutes les phrases soumises `a Caml doivent ˆetre munies d’une indication de fin de
phrase, ce qu’on note en Caml par ;; (deux points-virgules accol´es). C’est justifi´e pour
un syst`eme qui offre une version interactive, dans la mesure o`u il est impossible de
deviner quand l’utilisateur a termin´e sa phrase : par exemple apr`es 1 + 2, il est permis
d’´ecrire encore + 3 pour ´evaluer 1 + 2 + 3. D’autre part, une phrase peut s’´etendre
sur autant de lignes que n´ecessaire ; la fin de la ligne ne se confond donc pas avec la
fin de la phrase. On devra donc ´ecrire ;; pour signaler la fin de la phrase. Il faut bien
entendu ´egalement appuyer sur la touche « retour chariot » (return en anglais) comme
c’est traditionnel pour toute interaction avec un ordinateur.
En r´eponse au signe d’invite de Caml (le caract`ere # que Caml imprime pour indiquer
qu’il attend que nous tapions quelque chose), demandons-lui d’effectuer un petit
calcul : l’addition de 2 et de 2. Pour cela nous entrons simplement l’op´eration `a effectuer,
2 + 2, suivie de la marque de fin de phrase ;;.
# 2 + 2;;
- : int = 4
Caml nous r´epond imm´ediatement, en indiquant par un signe - que nous avons simplement
calcul´e une valeur, que cette valeur est de type entier (: int) et qu’elle vaut 4 (=
4). Vous constatez que Caml a d´eduit tout seul le type du r´esultat du calcul. Pour un
exemple si simple, ce n’est pas vraiment impressionnant, mais c’est un m´ecanisme absolument
g´en´eral : quelle que soit la complexit´e du programme que vous lui soumettrez,
Caml en d´eduira le type sans aucune intervention de votre part.
1.3 Les d´efinitions
Vous pouvez donner un nom `a une valeur que vous calculez, pour ne pas perdre
le r´esultat de votre calcul. La construction qui permet ainsi de nommer des valeurs
s’appelle une d´efinition.
Les d´efinitions 7
D´efinitions globales
De mˆeme qu’en math´ematiques on ´ecrit : « soit s la somme des nombres 1, 2 et 3 »,
on ´ecrit en Caml (« soit » se traduit par let en anglais) :
# let s = 1 + 2 + 3;;
s : int = 6
Caml nous r´epond que nous avons d´efini un nouveau nom s, qui est de type entier (:
int) et vaut 6 (= 6). Maintenant que le nom s est d´efini, il est utilisable dans d’autres
calculs ; par exemple, pour d´efinir le carr´e de s, on ´ecrirait :
# let s2 = s * s;;
s2 : int = 36
Les d´efinitions sont des liaisons de noms `a des valeurs. On peut consid´erer ces noms
(qu’on appelle aussi identificateurs, ou encore variables) comme de simples abr´eviations
pour la valeur qui leur est li´ee. En particulier, une d´efinition n’est pas modifiable : un
nom donn´e fait toujours r´ef´erence `a la mˆeme valeur, celle qu’on a calcul´ee lors de la
d´efinition du nom. Le m´ecanisme du « let » est donc fondamentalement diff´erent du
m´ecanisme d’affectation, que nous ´etudierons plus loin. Il est impossible de changer la
valeur li´ee `a un nom; on peut seulement red´efinir ce nom par une nouvelle d´efinition,
donc un nouveau « let ».
Une fois d´efini, un nom a toujours la mˆeme valeur
Informatique et math´ematiques
La grande diff´erence entre les math´ematiques et les langages de programmation,
mˆeme ceux qui se rapprochent des math´ematiques comme Caml, est qu’un langage
de programmation calcule avec des valeurs et non pas avec des quantit´es formelles.
Par exemple, en math´ematiques, si x est un entier, alors x − x est ´egal `a 0. Il n’est
pas n´ecessaire de connaˆıtre la valeur de x pour obtenir le r´esultat du calcul ; on parle
d’ailleurs plutˆot de simplification que de calcul. Au contraire, en Caml, on ne peut parler
d’un nom s’il n’a pas ´et´e pr´ec´edemment d´efini. On ne peut donc pas calculer x − x si
x n’est pas li´e `a une valeur pr´ecise, car il est alors impossible de faire effectivement la
soustraction :
# x - x;;
Entr´ee interactive:
>x - x;;
>^
L’identificateur x n’est pas d´efini.
Le langage indique ici que notre phrase est erron´ee puisque le nom x n’a jamais ´et´e
d´efini ; on dit encore que x n’est pas « li´e ». Mais le r´esultat est ´evidemment le bon, d`es
que l’identificateur est d´efini ; nous pouvons par exemple faire le calcul avec s :
# s - s;;
- : int = 0
Une autre diff´erence essentielle entre un programme et une d´efinition math´ematique
r´eside dans la notion d’efficacit´e : un langage de programmation calcule des valeurs de
8 Premiers pas
mani`ere effective, ce qui demande un certain temps. Si ce temps devient prohibitif,
on peut consid´erer que le programme est incorrect, mˆeme si l’on peut prouver qu’il
donnerait un jour le bon r´esultat. En math´ematiques, cette notion de temps de calcul
est sans importance. Un autre ´ecueil majeur de l’informatique est qu’elle ne connaˆıt
pas l’infini. Par exemple, la limite quand n tend vers l’infini de f(n), ce qu’on note en
math´ematiques limn→∞ f(n) et qui signifie la valeur de f(n) quand n devient arbitrairement
grand, existe ´eventuellement en math´ematiques, mais ne peut qu’ˆetre approch´ee
par une machine. Enfin, l’´evaluation des expressions d’un langage de programmation
tel que Caml ne termine pas toujours : les calculs peuvent « boucler » et donc ne jamais
s’achever. Autrement dit, les fonctions d´efinissables par un programme sont en g´en´eral
des fonctions partielles (non d´efinies pour certaines valeurs) plutˆot que des fonctions
totales (toujours d´efinies).
D´efinitions locales
Les d´efinitions de noms que nous venons de voir sont permanentes : elles restent
valides tant que vous n’abandonnez pas le syst`eme Caml. Ces d´efinitions « d´efinitives »
sont qualifi´ees de globales. Cependant, pour faire un petit calcul, il est inutile d’utiliser
des d´efinitions globales : on dispose donc en Caml d’un moyen de d´efinir temporairement
des noms, pour la seule dur´ee du calcul en question. Ces d´efinitions temporaires sont les
d´efinitions locales, qui disparaissent `a la fin de l’´evaluation de la phrase dans laquelle
elles se trouvent. Ces d´efinitions locales ne sont donc plus valides apr`es le calcul de
l’expression qui les suit (apr`es le mot-cl´e in, qui signifie « dans ») :
# let s = 20 in s * 4;;
- : int = 80
Le nom s a ´et´e li´e `a 20 pendant le calcul de s * 4, mais la d´efinition pr´ec´edente
de s reste inchang´ee. Pour s’en rendre compte, il suffit de demander la valeur de s,
c’est-`a-dire le r´esultat du calcul r´eduit `a s :
# s;;
- : int = 6
La d´efinition locale d’un nom est compl`etement ind´ependante du type actuel du nom:
par exemple, s et s2 qui sont actuellement de type int peuvent ˆetre d´efinis localement
avec le type string :
# let s = "Le langage " and s2 = "Caml" in s ^ s2;;
- : string = "Le langage Caml"
Cet exemple utilise l’op´erateur ^ qui met deux chaˆınes de caract`eres bout `a bout (concat
´enation). Notez ´egalement que les d´efinitions multiples consistent en une simple
succession de d´efinitions s´epar´ees par le mot-cl´e and (qui signifie « et »).
1.4 Fonctions
Les fonctions forment les constituants ´el´ementaires des programmes en Caml. Un
programme n’est rien d’autre qu’une collection de d´efinitions de fonctions, suivie d’un
appel `a la fonction qui d´eclenche le calcul voulu.
Fonctions 9
D´efinir une fonction
D´efinir une fonction en Caml est simple et naturel, car la syntaxe est tr`es proche
des notations math´ematiques usuelles. `A la d´efinition math´ematique « soit successeur
la fonction d´efinie par successeur(x) = x+1 » correspond la d´efinition Caml suivante :
# let successeur (x) = x + 1;;
successeur : int -> int =
Caml nous indique encore une fois que nous avons d´efini un nom: successeur. Ce nom
a pour type int -> int (-> se prononce « fl`eche »), qui est le type des fonctions des
entiers (int) vers les entiers (-> int) et ce nom a pour valeur une fonction (= ).
Le syst`eme a trouv´e tout seul le type de la fonction, mais il ne sait pas comment
imprimer les valeurs fonctionnelles, parce que leur repr´esentation interne est faite de
code machine ; il affiche donc simplement sans plus de pr´ecisions. Effectivement,
le nom successeur poss`ede maintenant une valeur :
# successeur;;
- : int -> int =
Une d´efinition de fonction n’est donc pas essentiellement diff´erente d’une d´efinition
d’entier ou de chaˆıne de caract`eres. Elle d´efinit simplement le nom de la fonction et lui
donne une valeur qui est une fonction, ce qu’on appelle une valeur fonctionnelle.
Application de fonctions
L’application d’une fonction `a son argument suit aussi la convention math´ematique
(rappelons que « f(x) » se prononce f de x) :
# successeur (2);;
- : int = 3
Le langage Caml fournit une syntaxe plus souple pour utiliser et d´efinir les fonctions : on
peut supprimer les parenth`eses autour des noms des arguments des fonctions aussi bien
au cours d’une d´efinition que lors d’une application. ´Etant donn´ee la paresse l´egendaire
des programmeurs, c’est bien sˆur cette habitude qui pr´edomine ! Avec cette convention,
on ´ecrit simplement
# let successeur x = x + 1;;
successeur : int -> int =
# successeur 2;;
- : int = 3
D´efinitions locale de fonctions
Rien n’empˆeche de d´efinir une fonction localement, bien que cela surprenne souvent
les d´ebutants en Caml. Voici un exemple de fonction locale :
# let pr´ed´ecesseur x = x - 1 in
(pr´ed´ecesseur 3) * (pr´ed´ecesseur 4);;
- : int = 6
La fonction pr´ed´ecesseur n’est d´efinie que pendant le calcul du produit des
pr´ed´ecesseurs de 3 et 4.
10 Premiers pas
Les d´efinitions locales sont aussi utilis´ees dans les d´efinitions globales, par exemple
pour calculer la formule qui d´efinit une fonction (ce qu’on appelle le corps de la fonction).
D´efinissons par exemple la fonction pr´ed´ecesseur_carr´e qui retourne le carr´e
du pr´ed´ecesseur d’un nombre (la fonction x 7→ (x − 1)2). Nous d´efinissons localement
le pr´ed´ecesseur de l’argument, puis l’´elevons au carr´e :
# let pr´ed´ecesseur_carr´e x =
let pr´ed´ecesseur_de_x = x - 1 in
pr´ed´ecesseur_de_x * pr´ed´ecesseur_de_x;;
pr´ed´ecesseur_carr´e : int -> int =
# pr´ed´ecesseur_carr´e 3;;
- : int = 4
Une fonction peut aussi d´efinir localement une autre fonction. Par exemple, pour
d´efinir la fonction puissance4 qui ´el`eve son argument `a la puissance quatre, il est
naturel d’utiliser la formule x4 = (x2)2, donc d’´elever au carr´e le carr´e de l’argument.
Pour cela, on d´efinit localement la fonction carr´e et on l’utilise deux fois :
# let puissance4 x =
let carr´e y = y * y in (* d´efinition locale d’une fonction *)
carr´e (carr´e x);;
puissance4 : int -> int =
# puissance4 3;;
- : int = 81
Comme on le voit sur cet exemple, les commentaires en Caml sont encadr´es entre (*
et *). Ils peuvent contenir n’importe quel texte, y compris d’autres commentaires, et
s’´etendre sur plusieurs lignes.
Fonctions `a plusieurs arguments
Les fonctions poss´edant plusieurs arguments ont simplement plusieurs noms
d’arguments dans leur d´efinition :
# let moyenne a b = (a + b) / 2;;
moyenne : int -> int -> int =
# let p´erim`etre_du_rectangle longueur largeur =
2 * (longueur + largeur);;
p´erim`etre_du_rectangle : int -> int -> int =
Le type de ces deux fonctions, int -> int -> int, indique qu’elles prennent deux
arguments de type int (int -> int ->) et calculent un entier (-> int).
Lorsque des fonctions ont plusieurs arguments, il faut ´evidemment leur fournir aussi
leur compte d’arguments quand on les applique. Ainsi, un appel `a p´erim`etre_du_rectangle
ou moyenne comportera deux arguments :
# p´erim`etre_du_rectangle 3 2;;
- : int = 10
# moyenne 5 3;;
- : int = 4
Fonctions 11
Fonctions anonymes
Une fonction Caml est un « citoyen `a part enti`ere », on dit aussi « citoyen de premi`ere
classe », c’est-`a-dire une valeur comme toutes les autres. Une fonction a le mˆeme statut
qu’un nombre entier : elle est calcul´ee, on peut la passer en argument ou la retourner en
r´esultat. Les valeurs fonctionnelles sont cr´e´ees lors des d´efinitions de fonctions, comme
nous venons de le voir. Cependant, on peut aussi construire des valeurs fonctionnelles
sans leur donner de nom, en utilisant des fonctions anonymes. Ces fonctions sont introduites
par le mot-cl´e function, suivi de la formule qui les d´efinit :
# (function x -> 2 * x + 1);;
- : int -> int =
Encore une fois, Caml nous indique par le symbole - que nous avons fait un simple
calcul, dont le r´esultat est de type int -> int et dont la valeur est une fonction (=
). On applique les fonctions anonymes comme toutes les autres fonctions, en les
faisant suivre de leur(s) argument(s) :
# (function x -> 2 * x + 1) (2);;
- : int = 5
D´efinition de fonctions `a l’aide de fonctions anonymes
Il existe un autre style de d´efinitions math´ematiques de fonctions :
« Soit successeur : Z → Z
x 7→ x + 1 »
Ce style insiste sur le fait que successeur est une fonction qui `a tout ´el´ement x de
l’ensemble Z des entiers associe x+1. `A l’aide des fonctions anonymes, cette d´efinition
se traduit tr`es simplement en Caml :
# let successeur = function x -> x + 1;;
successeur : int -> int =
Contraintes de type
Pour se rapprocher encore du style de la d´efinition math´ematique, on peut mˆeme
ajouter une contrainte de type sur le nom de la fonction, qui rend compte de l’indication
successeur : Z → Z des math´ematiques. Une contrainte de type (ou annotation de
type) est une indication explicite du type d’une expression Caml. Vous pouvez, si vous
le souhaitez, ajouter des annotations de type dans vos programmes, par exemple pour
aider `a la relecture. Pour annoter un morceau de programme avec un type, il suffit
de mettre ce morceau de programme entre parenth`eses avec son type, avec la mˆeme
convention que le syst`eme interactif, c’est-`a-dire un « : » suivi d’un nom de type :
# ("Caml" : string);;
- : string = "Caml"
Nous obtenons maintenant une d´efinition de la fonction successeur tr`es fid`ele `a celle
des math´ematiques :
12 Premiers pas
# let (successeur : int -> int) = function x -> x + 1;;
successeur : int -> int =
Ce style revient `a d´efinir le nom successeur comme un nom ordinaire, mais dont la
valeur est une fonction. Cette d´efinition est absolument ´equivalente `a la pr´ec´edente
d´efinition de successeur :
let successeur (x) = x + 1;;
Fonctions anonymes `a plusieurs arguments
Le choix entre les deux modes de d´efinition des fonctions est donc, comme en
math´ematiques, une simple affaire de style. En r`egle g´en´erale, le style « let successeur
(x) = » est plus concis, particuli`erement lorsque la fonction a plusieurs arguments,
puisque l’autre style oblige `a introduire chacun des arguments par une construction
« function argument -> ». Par exemple, d´efinir la fonction moyenne dans le style
« function x -> » conduirait `a ´ecrire :
# let moyenne = function a -> function b -> (a + b) / 2;;
moyenne : int -> int -> int =
Au passage, nous remarquons qu’une fonction anonyme a parfaitement le droit d’avoir
plusieurs arguments. Attention : il n’est pas permis d’´ecrire function a b ->, il faut
imp´erativement r´ep´eter le mot-cl´e function, une fois par argument. C’est pourquoi
nous utiliserons la plupart du temps le style le plus l´eger, celui qui ´evite d’employer le
mot function.
Les tests et l’alternative
Caml fournit une construction pour faire des calculs qui d´ependent d’une condition
: c’est l’alternative, le classique « if . . . then . . . else . . . ». Cette construction
correspond au calcul « si condition alors expression1 sinon expression2 », qui signifie
simplement qu’il faut calculer expression1 si la condition est vraie et expression2 sinon.
Nous illustrons cette construction en impl´ementant (c’est-`a-dire en r´ealisant sur machine)
la fonction « valeur absolue », qui calcule la valeur d’un nombre ind´ependamment
de son signe. Cette fonction, not´ee |x| en math´ematiques, est d´efinie comme :
|x| =
(
x si x ≥ 0
−x sinon
Sachant qu’en Caml les comparaisons entre nombres entiers suivent les notations
math´ematiques (<, >, =, >= et <=), nous sommes arm´es pour d´efinir la fonction valeur
absolue :
# let valeur_absolue (x) = if x >= 0 then x else -x;;
valeur_absolue : int -> int =
# valeur_absolue (3);;
- : int = 3
# valeur_absolue (-3);;
- : int = 3
Valeurs et programmes 13
Valeurs de v´erit´e
Remarquons que les tests calculent un r´esultat, une valeur de v´erit´e. Une valeur de
v´erit´e est soit « vrai », soit « faux », ce qui se note true et false en Caml. On appelle
aussi les valeurs de v´erit´e « valeurs bool´eennes », en l’honneur du logicien Boole ; elles
sont du type bool. On peut donc employer les tests pour calculer un bool´een :
# 2 < 1;;
- : bool = false
# (valeur_absolue (3)) = (valeur_absolue (-3));;
- : bool = true
1.5 Valeurs et programmes
Nous venons de faire des calculs. Mais o`u sont donc les programmes ? Ce sont tout
simplement les fonctions ! Un programme consiste en une d´efinition de fonction qui
calcule le r´esultat d´esir´e. En g´en´eral cette fonction utilise `a son tour d’autres fonctions,
qui correspondent `a la notion de sous-programmes. Par exemple, si vous d´esirez calculer
la somme des carr´es de deux nombres, vous d´efinirez d’abord la fonction carr´e :
# let carr´e (x) = x * x;;
carr´e : int -> int =
pour ensuite d´efinir la fonction d´esir´ee :
# let somme_des_carr´es x y = carr´e (x) + carr´e (y);;
somme_des_carr´es : int -> int -> int =
et enfin l’appliquer dans le cas qui vous int´eresse :
# somme_des_carr´es 3 4;;
- : int = 25
En r´esum´e : une fonction manipule des valeurs (entiers, chaˆınes de caract`eres, bool´eens)
qui ont toutes un type ; la fonction elle-mˆeme est une valeur et poss`ede donc un type.
En ce sens, les programmes en Caml sont des valeurs !
1.6 Impression
Notion d’effet
Caml propose bien sˆur le moyen d’imprimer des valeurs `a l’´ecran ou dans des fichiers.
On utilise pour cela des fonctions dont le but n’est pas d’effectuer des calculs mais de
produire des effets, c’est-`a-dire une action sur le monde ext´erieur, par exemple une
interaction avec l’utilisateur du programme, l’´ecriture d’un fichier ou d’un message au
terminal.
Un premier effet
Nous allons r´ealiser un premier effet tr`es simple : nous ´ecrivons «Bonjour ! » `a
l’´ecran en utilisant la fonction pr´ed´efinie print_string qui a justement pour effet
d’imprimer son argument au terminal. Une fonction pr´ed´efinie est une fonction qui
14 Premiers pas
vous est fournie par le syst`eme Caml ; vous n’avez donc pas besoin de l’´ecrire. Ces
fonctions sont d´ecrites en d´etails dans le Manuel de r´ef´erence du langage Caml. Elles
sont aussi appel´ees « fonctions primitives » ou tout simplement « primitives ». Essayons
la primitive print_string :
# print_string "Bonjour!";;
Bonjour!- : unit = ()
L’impression s’est produite comme pr´evu. Cependant Caml nous indique aussi que
nous avons calcul´e un r´esultat de type unit et qui vaut (). Le type unit est un
type pr´ed´efini qui ne contient qu’un seul ´el´ement, « () », qui signifie par convention
« rien ». Nous n’avons pas demand´e ce r´esultat : tout ce que nous voulions, c’est faire
une impression (un effet). Mais toutes les fonctions Caml doivent avoir un argument
et rendre un r´esultat. Lorsqu’une fonction op`ere uniquement par effets, on dit que
cette fonction est une proc´edure On utilise alors « rien », c’est-`a-dire (), en guise de
r´esultat ou d’argument. (En position d’argument dans une d´efinition de fonction, on
peut consid´erer () comme un argument minimal : l’argument (x) auquel on aurait
mˆeme retir´e la variable x ; de mˆeme en r´esultat, () figure une expression parenth´es´ee
dont tout le texte aurait disparu.)
Impressions successives : s´equencement
Supposez qu’il nous faille imprimer deux textes successifs `a l’´ecran : par exemple,
«Bonjour » puis « tout le monde ! ». Nous devons faire deux effets `a la suite l’un de
l’autre, en s´equence. ´Evaluer en s´equence deux expressions e1 et e2 signifie simplement
les ´evaluer successivement : d’abord e1, puis e2. Comme dans la plupart des langages de
programmation, la s´equence est not´ee par un point virgule en Caml. L’op´eration « e1
puis e2 » s’´ecrit donc e1 ; e2. Nous ´ecrivons donc :
# print_string "Bonjour "; print_string "tout le monde!";;
Bonjour tout le monde!- : unit = ()
La machine a d’abord imprim´e Bonjour puis tout le monde!, comme on s’y attendait.
Le r´esultat de toute l’op´eration (de toute la s´equence) est « rien ». Cela s’explique
naturellement parce que le r´esultat de la premi`ere impression (un premier « rien ») a
´et´e oubli´e. De mani`ere g´en´erale, la s´equence « jette » le r´esultat du premier calcul et
renvoie le r´esultat du second : e1 ; e2 s’´evalue en la mˆeme valeur que e2. Comme le
r´esultat de e1 est d´etruit, il est clair que l’expression e1 n’est utile que si elle produit
des effets : il serait stupide d’´evaluer la s´equence (1 + 2); 0 qui rendrait exactement
le mˆeme r´esultat que 0.
# (1 + 2); 0;;
Entr´ee interactive:
>(1 + 2); 0;;
> ^^^^^
Attention: cette expression est de type int,
mais est utilis´ee avec le type unit.
- : int = 0
On constate d’ailleurs que le compilateur ´emet une alerte pour indiquer que l’expression
(1 + 2) produit un r´esultat qui sera ignor´e !
Conventions syntaxiques 15
Pour d´elimiter pr´ecis´ement une s´equence, on l’encadre souvent entre les mots-cl´es
begin (d´ebut) et end (fin) :
# begin
print_string "Voil`a ";
print_string "Caml!";
print_newline ()
end;;
Voil`a Caml!
- : unit = ()
La derni`ere expression, print_newline (), fait imprimer un retour chariot. La fonction
print_newline op`ere enti`erement par effets, elle n’a donc pas de param`etre significatif,
ni de r´esultat significatif.
1.7 Conventions syntaxiques
R´esumons quelques conventions syntaxiques qu’il est bon d’avoir en tˆete pour la
suite.
D´efinitions de fonctions
Pour les d´efinitions de fonctions, nous avons la convention suivante :
let f x = . . . est ´equivalent `a let f = function x -> . . .
On peut it´erer cette convention pour d´efinir les fonctions `a plusieurs arguments :
let f x y = . . . est ´equivalent `a let f = function x -> function y -> . . .
Application de fonctions
Pour ce qui est de l’application de fonction, nous avons vu que les parenth`eses
autour de l’argument ´etait facultatives :
Si x est une variable ou une constante, f x est ´equivalent `a f (x)
Attention : cette convention n’est valable que lorsque x est une variable ou une constante.
Si vous employez cette convention avec une expression plus compliqu´ee, les
parenth`eses retrouvent leur sens habituel en math´ematiques (le groupement des expressions)
et la pr´esence de parenth`eses modifie alors le r´esultat du calcul. Par exemple,
l’argument n´egatif d’une fonction doit imp´erativement ˆetre parenth´es´e : f (−1) sans
parenth`eses est compris comme la soustraction f − 1. De mˆeme, si l’argument est une
expression complexe, vous ne pouvez pas supprimer les parenth`eses sans changer le
r´esultat :
# successeur (2 * 3);;
- : int = 7
16 Premiers pas
# successeur 2 * 3;;
- : int = 9
Cette derni`ere phrase est comprise par Caml comme si vous aviez ´ecrit (successeur
2) * 3. C’est d’ailleurs un ph´enom`ene g´en´eral pour tous les op´erateurs de Caml : les
applications de fonctions en argument des op´erations sont implicitement parenth´es´ees.
Par exemple successeur 2 - successeur 3 est lu comme (successeur 2) -
(successeur 3), et de mˆeme pour tous les op´erateurs : successeur 2 >= successeur
3 est correctement interpr´et´e.
f x + g y est ´equivalent `a (f x) + (g y)
Application de fonctions `a plusieurs arguments
L’application de fonctions `a plusieurs arguments suit les mˆemes conventions :
moyenne (2) (6) est ´equivalent `a moyenne 2 6, mais vous devez conserver les
parenth`eses si vous voulez calculer moyenne (2 * 3) (3 + 3).
Techniquement, on dit que l’application « associe `a gauche » en Caml, ce qui signifie
que les parenth`eses peuvent ˆetre omises dans (f x) y, qui correspond au r´esultat de f de
x appliqu´e `a y, mais qu’elles sont indispensables dans f (g x), qui signifie au contraire
f appliqu´ee au r´esultat de l’application de la fonction g `a x.
f x y est ´equivalent `a (f x) y
Au lieu de moyenne 2 6, on peut donc ´ecrire (moyenne 2) 6 . La deuxi`eme forme est
´evidemment un peu ´etrange, mais elle a la mˆeme signification que la premi`ere. On a
donc beaucoup de mani`eres ´equivalentes d’exprimer l’application de la fonction moyenne
`a 2 et `a 6. La plus simple est ´evidemment sans parenth`eses aucunes : « moyenne 2 6 ».
Mais l’on peut ´ecrire aussi « moyenne (2) (6) » ou, en utilisant la r`egle pr´ec´edente pour
ajouter encore des parenth`eses, « (moyenne (2)) 6 » ou mˆeme « (moyenne (2)) (6) ».
En pratique, nous utiliserons toujours la forme la plus simple, sans parenth`eses.
En revanche, on ne peut absolument pas grouper les arguments 2 et 6 `a l’int´erieur
de parenth`eses : moyenne (2 6) est erron´e. Cela signifierait en effet qu’on d´esire appliquer
moyenne `a un seul argument « 2 6 ». Qui plus est, cela voudrait dire qu’on
tente d’appliquer le nombre 2 au nombre 6 ! Des expressions construites sur le mod`ele
moyenne (2 6), c’est-`a-dire, plus g´en´eralement, du genre f (g y), ont pourtant un
sens. Consid´erez, par exemple le calcul du successeur du successeur de 1. On ´ecrit
naturellement :
# successeur (successeur 1);;
- : int = 3
Mais si l’on ˆote les parenth`eses, on ´ecrit successeur successeur 1 et cela signifie
maintenant que nous voulons appliquer la fonction successeur `a deux arguments (le
premier argument serait la fonction successeur elle-mˆeme et le second argument serait
1). Cependant la fonction successeur n’admet qu’un seul argument ; si nous retirons
les parenth`eses (sciemment ou par inadvertance), Caml nous indique donc une erreur :
Diagrammes syntaxiques 17
# successeur successeur 1;;
Entr´ee interactive:
>successeur successeur 1;;
> ^^^^^^^^^^
Cette expression est de type int -> int,
mais est utilis´ee avec le type int.
Le message indique en effet que l’expression soulign´ee (successeur) est une fonction
de type int -> int : elle ne peut pas ˆetre utilis´ee comme un argument entier.
Retenons de toute fa¸con que :
f (g y) n’est pas ´equivalent `a f g y
1.8 Diagrammes syntaxiques
Nous r´esumons la mani`ere d’´ecrire les constructions de Caml au moyen de d´efinitions
simplifi´ees de syntaxe, telles que :
expression ::= entier
| chaˆıne-de-caract`eres
| bool´een
| . . .
Cette d´efinition signifie qu’une expression du langage Caml (expression) est (::=) ou
bien un entier (entier), ou bien (|) une chaˆıne de caract`eres (chaˆıne-de-caract`eres), ou
bien (|) un bool´een (bool´een), ou bien . . . Ceci n’est qu’un exemple et nous ne faisons
´evidemment pas figurer toutes les constructions concernant les expressions. D’ailleurs,
nous savons d´ej`a qu’une s´equence est une expression ; elle devrait donc figurer dans
l’ensemble des expressions, de mˆeme que les expressions parenth´es´ees (toute expression
entour´ee de parenth`eses est une expression). Avec ce formalisme, une s´equence se d´ecrit
par :
s´equence ::= expression ; expression
ou encore, si elle est d´elimit´ee par les mots-cl´es begin et end :
s´equence ::= begin expression ; expression end
Cette m´ethode de description de la syntaxe d’un langage est appel´ee « syntaxe BNF »,
pour Backus-Naur Form, des noms de John Backus et Peter Naur qui l’ont r´epandue.
l
2
R´ecursivit´e
O`u l’on apprend `a parler de ce qu’on ne connaˆıt pas encore . . .
ous ne connaissez pas les fonctions r´ecursives, ou n’y avez jamais rien
compris, ou bien vous vous passionnez pour les tours de Hanoi ? Alors lisez
ce chapitre, il est fait pour vous. Nous y apprendrons une nouvelle mani`ere
d’utiliser l’ordinateur. Jusqu’`a pr´esent nous nous en servions pour obtenir les solutions
`a des probl`emes que nous savions r´esoudre, mais qui demandaient trop de calculs
math´ematiques pour que nous les traitions `a la main. C’est l’emploi de l’ordinateur le
plus r´epandu actuellement : la machine sert `a effectuer un tr`es grand nombre de fois
des op´erations simples (pensez `a des logiciels de gestion, paye ou comptes en banque).
Avec la r´ecursivit´e, on ´el`eve la programmation `a un rang autrement plus noble : on
´ecrit des programmes qui r´esolvent des probl`emes que l’on ne sait pas forc´ement
r´esoudre soi-mˆeme. Parvenir `a diriger une machine pour qu’elle trouve pour nous la
solution d’un probl`eme est r´eellement fascinant, il est mˆeme grisant de voir apparaˆıtre
cette solution au terminal, quand elle est le r´esultat de l’ex´ecution d’un programme
qu’on a soi-mˆeme ´ecrit sans avoir conscience de savoir r´esoudre le probl`eme.
2.1 Fonctions r´ecursives simples
Notion de r´ecursivit´e
Une d´efinition r´ecursive est une d´efinition dans laquelle intervient le nom qu’on est
en train de d´efinir. Cela correspond dans le langage courant `a une phrase qui « se mord
la queue ». L’exemple typique est la r´eponse `a la question «Qu’est-ce qu’un ´ego¨ıste ? » :
«Quelqu’un qui ne pense pas `a moi ! ». Il est clair qu’on soup¸conne l´egitimement ce genre
de phrases d’ˆetre d´enu´ees de sens et que c’est souvent le cas. Pourtant, les d´efinitions
r´ecursives sont tr`es employ´ees en math´ematiques et en informatique, domaines o`u l’on
se m´efie beaucoup des phrases « d´enu´ees de sens ». Il existe donc forc´ement des phrases
qui « se mordent la queue » et pourtant poss`edent une signification pr´ecise, utilisable en
math´ematiques ou informatique. Toute la difficult´e des d´efinitions r´ecursives provient
de la d´etection des cas o`u la r´ecursivit´e entraˆıne le non-sens. Une d´efinition r´ecursive
sens´ee est qualifi´ee de bien fond´ee. Nous verrons par l’exemple ce que cela veut dire.
20 R´ecursivit´e
L’intuition la plus simple qu’on puisse donner de la r´ecursivit´e est l’id´ee de
« recommencer » la mˆeme chose. La r´ecursivit´e est pr´esente aussi dans le domaine
graphique, un exemple nous est donn´e par le c´el`ebre dessin qui orne les couvercles
de «Vache qui rit », figurant une vache qui porte en boucles d’oreilles des boˆıtes de
«Vache qui rit » (dont les couvercles comportent donc le dessin lui-mˆeme). Dans le
domaine physique, l’infinit´e d’images qui apparaˆıt dans deux miroirs quasi parall`eles
est aussi une bonne analogie (exp´erience habituelle chez le coiffeur).
Prenons un exemple plus informatique : la tr`es c´el`ebre fonction « factorielle »,
qui retourne le produit des nombres entiers inf´erieurs ou ´egaux `a son argument. En
math´ematiques, elle est not´ee par un point d’exclamation (!) plac´e apr`es son argument.
On a par exemple 4! = 4 × 3 × 2 × 1. La fonction factorielle est d´efinie par :
n! =
(
1 si n = 0
n × (n − 1)! sinon.
Cette d´efinition est r´ecursive : le nom « ! » intervient dans le corps de sa propre
d´efinition. Donc, pour comprendre la signification de n! il faut comprendre celle de
(n − 1)!. Cela semble difficile, car on exige la compr´ehension d’une notion qu’on est
justement en train d’expliquer . . . En fait, cela se justifie parce que le calcul de n!
termine toujours : il suffit d’ˆetre patient et de continuer le calcul jusqu’`a atteindre 0, ce
qui arrivera forc´ement puisqu’on explique la signification de n! en fonction de (n−1)!.
Par exemple :
3! = 3 × (3 − 1)! = 3 × 2!
= 3 × 2 × (2 − 1)! = 3 × 2 × 1!
= 3 × 2 × 1 × (1 − 1)! = 3 × 2 × 1 × 0!
= 3 × 2 × 1 × 1 = 6
La d´efinition math´ematique r´ecursive de la fonction factorielle est donc bien fond´ee :
on obtient finalement un r´esultat pour tout argument entier naturel.
Ce genre de d´efinition se traduit tr`es facilement en Caml ; mais pour cela nous
devons explicitement pr´evenir Caml que nous d´esirons faire une d´efinition r´ecursive,
grˆace `a une nouvelle construction : let rec. Avant de l’employer, expliquons pourquoi
il est n´ecessaire d’introduire une nouvelle construction.
Port´ee statique et d´efinitions r´ecursives
En math´ematiques, vous ne pouvez parler d’une entit´e math´ematique avant d’en
avoir donn´e la d´efinition. Le mˆeme axiome est vrai en Caml : vous ne pouvez utiliser
un identificateur s’il n’a re¸cu une d´efinition pr´ealable. C’est ce qu’on appelle la port´ee
statique, parce que vous pouvez trouver la d´efinition de n’importe quel identificateur
ind´ependamment du comportement du programme `a l’ex´ecution (au contraire de la
port´ee dynamique, o`u la valeur d’un identificateur d´epend de la fa¸con dont le calcul
se d´eroule). En Caml, pour une occurrence quelconque d’un identificateur, disons x, il
vous suffit d’examiner le texte du programme qui pr´ec`ede x pour trouver la liaison qui
a d´efini x. Cette liaison est soit une d´efinition de x : let x =, soit une d´efinition de
fonction qui a x pour param`etre : function x ->.
Fonctions r´ecursives simples 21
# let x = 1 in
let x = x + 1 in
x + 3;;
- : int = 5
L’identificateur x qui apparaˆıt dans x + 1 dans la d´efinition let x = x + 1 est li´e `a 1
(par la pr´ec´edente d´efinition let x = 1), alors que le dernier x dans x + 3 est li´e `a 2
par la pr´ec´edente d´efinition let x = x + 1, comme le sugg`ere ce sch´ema :
let x = 1 in
let x = x + 1 in
x + 3
i
6
i
6
Le m´ecanisme de liaison est similaire pour des d´efinitions simultan´ees (d´efinitions
s´epar´ees par le mot-cl´e and).
# let x = 1 in
let x = x + 1
and y = x + 2 in x + y;;
- : int = 5
Les deux x intervenant dans les d´efinitions let x = ... and y = ... font tous les
deux r´ef´erence au nom x pr´ec´edemment d´efini par let x = 1. Les liaisons sont mises
en ´evidence dans ce sch´ema :
let x = 1 in
let x = x + 1
and y = x + 2 in
x + y
i
i
6
i
6
i 6
On retiendra que, dans une d´efinition Caml (y compris une d´efinition simultan´ee),
Un nom fait toujours r´ef´erence `a une d´efinition pr´ealable.
La construction let rec
Ceci pose ´evidemment probl`eme pour d´efinir des fonctions r´ecursives : nous ne pouvons
utiliser une d´efinition introduite par un let, `a cause de la r`egle de port´ee statique.
En effet, si nous ´ecrivons let f = ... f ..., l’occurrence de f dans l’expression
d´efinissante ... f ... ne correspond pas au nom f que nous sommes en train de
d´efinir (en particulier parce que f n’est pas encore d´efinie !) mais doit correspondre `a
une d´efinition pr´ec´edente de f. Un petit sch´ema vaut mieux qu’un long discours : la
liaison de f s’´etablit vers le pass´e.
let f = ... fi...in
6
C’est pourquoi une simple construction let ne permet pas de d´efinir une fonction
r´ecursive :
22 R´ecursivit´e
# let factorielle n = if n = 0 then 1 else n * factorielle (n - 1);;
Entr´ee interactive:
>let factorielle n = if n = 0 then 1 else n * factorielle (n - 1);;
> ^^^^^^^^^^^
L’identificateur factorielle n’est pas d´efini.
En bref : une liaison let n’est pas r´ecursive ; il y a donc en Caml une construction
sp´eciale, let rec, destin´ee `a introduire les d´efinitions r´ecursives. Cette construction
´etablit une liaison de la forme suivante :
let rec f = ... fi...in
?
Maintenant, nous d´efinissons facilement la fonction factorielle :
# let rec factorielle n =
if n = 0 then 1 else n * factorielle (n - 1);;
factorielle : int -> int =
# factorielle 3;;
- : int = 6
Compter `a l’endroit et `a l’envers
Pour comprendre comment s’ex´ecute un appel `a une fonction r´ecursive, d´efinissons
une fonction qui ´enum`ere les nombres par ordre d´ecroissant jusqu’`a 1, `a partir d’une
certaine limite : par exemple, pour une limite de 5 nous voulons obtenir l’impression de
« 5 4 3 2 1 » sur l’´ecran.
Bien que le but de ce programme soit exclusivement de produire des effets, la
r´ecursivit´e s’y introduit naturellement, puisque ´enum´erer `a partir d’une certaine limite
n, c’est : si la limite est 0, alors ne rien faire ; sinon, imprimer n, puis ´enum´erer les
nombres pr´ec´edents. Si l’on se rend compte que « ´enum´erer les nombres pr´ec´edents »
consiste tout simplement `a appeler notre fonction avec la nouvelle limite n − 1, on
obtient le programme suivant :
# let rec compte_`a_rebours n =
if n = 0 then () else
begin
print_int n; print_string " ";
compte_`a_rebours (n - 1)
end;;
compte_`a_rebours : int -> unit =
# compte_`a_rebours 10;;
10 9 8 7 6 5 4 3 2 1 - : unit = ()
La fonction d’impression des entiers au terminal se nomme tout naturellement
print_int, par analogie avec la fonction d’impression des chaˆınes print_string. Vous
devinez le sch´ema de nommage de ces fonctions, qui consiste `a suffixer le nom print_
par le type de l’argument. Ainsi, la fonction d’impression des nombres flottants (les
valeurs du type float que nous verrons au chapitre 8) s’appelle print_float, et celle
pour les caract`eres (type char) s’appelle print_char.
Telle qu’elle est ´ecrite, la fonction compte_`a_rebours ne termine pas si on lui passe
un argument n´egatif (la d´efinition n’est donc pas bien fond´ee). Il serait plus sˆur de
remplacer le test n = 0 par le test n <= 0.
Fonctions r´ecursives simples 23
Par curiosit´e, inversons l’appel r´ecursif et les impressions : autrement dit rempla
¸cons print_int n; print_string " "; compte_`a_rebours (n - 1) par
compte_`a_rebours (n - 1); print_int n; print_string " ". Et afin de ne pas
perdre notre fonction pr´ec´edente, nous nommons compte cette version modifi´ee de
compte_`a_rebours. Nous obtenons :
# let rec compte n =
if n = 0 then () else
begin
compte (n - 1);
print_int n; print_string " "
end;;
compte : int -> unit =
# compte 10;;
1 2 3 4 5 6 7 8 9 10 - : unit = ()
Cette fonction compte `a l’endroit ! C’est plus difficile `a comprendre : l’impression se
produit au retour des appels r´ecursifs. On doit d’abord atteindre n = 0 avant d’imprimer
le premier nombre, qui est alors 1. En effet, c’est toujours pendant l’´evaluation de
compte 1 que nous appelons compte 0. Apr`es avoir imprim´e 1, compte 1 retourne `a
l’´evaluation de compte 2, qui ´ecrit 2 et retourne `a compte 3, et ainsi de suite.
Nous allons utiliser le m´ecanisme de « trace » de Caml pour suivre les appels r´ecursifs
et les impressions. Ce m´ecanisme imprime `a l’´ecran les appels successifs d’une fonction,
ainsi que les r´esultats que la fonction calcule. Tra¸cons par exemple la fonction
successeur :
# let successeur x = x + 1;;
successeur : int -> int =
# trace "successeur";;
La fonction successeur est dor´enavant trac´ee.
- : unit = ()
# successeur 2;;
successeur <-- 2
successeur --> 3
- : int = 3
Vous l’avez devin´e, l’appel d’une fonction est indiqu´e par le signe <-- suivi de
l’argument concern´e, tandis que le signe --> signale un retour de fonction et affiche
le r´esultat obtenu. Nous suivons maintenant le d´eroulement des appels `a compte et
compte_`a_rebours :
# trace "compte"; trace "compte_`a_rebours";;
La fonction compte est dor´enavant trac´ee.
La fonction compte_`a_rebours est dor´enavant trac´ee.
- : unit = ()
# compte 3;;
compte <-- 3
compte <-- 2
compte <-- 1
compte <-- 0
compte --> ()
1 compte --> ()
24 R´ecursivit´e
2 compte --> ()
3 compte --> ()
- : unit = ()
On voit clairement que compte i s’ach`eve avant l’impression de i−1 et que compte 0 se
termine avant toute impression. Cela contraste avec compte_`a_rebours, qui imprime
i avant l’appel compte_`a_rebours (i − 1) :
# compte_`a_rebours 3;;
compte_`a_rebours <-- 3
3 compte_`a_rebours <-- 2
2 compte_`a_rebours <-- 1
1 compte_`a_rebours <-- 0
compte_`a_rebours --> ()
compte_`a_rebours --> ()
compte_`a_rebours --> ()
compte_`a_rebours --> ()
- : unit = ()
´E
peler `a l’endroit et `a l’envers
Nous allons maintenant montrer la r´ecursion `a l’oeuvre sur les chaˆınes de caract`eres.
Pour ce faire, nous avons besoin d’op´erations suppl´ementaires sur les chaˆınes de caract`
eres. La fonction pr´ed´efinie string_length renvoie la longueur d’une chaˆıne de caract`
eres. La notation s.[i] d´esigne le ii`eme caract`ere de la chaˆıne de caract`eres s. Le premier
caract`ere a pour num´ero 0 ; le dernier a donc pour num´ero string_length s−1.
Acc`es dans une chaˆıne s ::= s .[ indice ]
# let le_langage = "Caml";;
le_langage : string = "Caml"
# string_length le_langage;;
- : int = 4
# le_langage.[0];;
- : char = ‘C‘
Un caract`ere en Caml est donc un signe typographique quelconque compris entre deux
symboles ‘.
Voici deux fonctions qui ´epellent des mots. La premi`ere ´epelle `a l’envers, en commen
¸cant par le dernier caract`ere de la chaˆıne et en s’appelant r´ecursivement sur le
caract`ere pr´ec´edent.
# let rec ´epelle_envers_aux s i =
if i >= 0 then
begin
print_char s.[i]; print_char ‘ ‘;
´epelle_envers_aux s (i - 1)
end;;
´epelle_envers_aux : string -> int -> unit =
# let ´epelle_envers s = ´epelle_envers_aux s (string_length s - 1);;
´epelle_envers : string -> unit =
Fonctions r´ecursives simples 25
# ´epelle_envers "snob";;
b o n s - : unit = ()
La seconde ´epelle `a l’endroit, en commen¸cant par le premier caract`ere et en s’appelant
r´ecursivement sur le prochain caract`ere.
# let rec ´epelle_aux s i =
if i < string_length s then
begin
print_char s.[i]; print_char ‘ ‘;
´epelle_aux s (i + 1)
end;;
´epelle_aux : string -> int -> unit =
# let ´epelle s = ´epelle_aux s 0;;
´epelle : string -> unit =
# ´epelle "snob";;
s n o b - : unit = ()
Ces deux exemples utilisent une forme nouvelle de l’alternative : la construction
« if . . . then . . . » sans partie else. La partie else omise est implicitement compl´et´ee
par le compilateur, qui ajoute else (), autrement dit « sinon rien ». Ainsi, le code :
if i >= 0 then begin ... end;;
est compris par Caml comme si nous avions ´ecrit :
if i >= 0 then begin ... end else ();;
Cette compl´etion automatique vous explique pourquoi la phrase suivante est mal typ´ee :
# if true then 1;;
Entr´ee interactive:
>if true then 1;;
> ^
Cette expression est de type int,
mais est utilis´ee avec le type unit.
Retenons la d´efinition d’une alternative sans partie else :
if cond then e est ´equivalent `a if cond then e else ()
Les palindromes
Un palindrome est un mot (ou un groupe de mots sans blancs) qui se lit aussi bien
`a l’endroit qu’`a l’envers. Pour d´eterminer si un mot constitue un palindrome, il suffit
de v´erifier que ses premier et dernier caract`eres sont identiques, puis de v´erifier que le
mot situ´e entre ces deux caract`eres est lui aussi un palindrome.
chaˆıne s c
mˆemes caract`eres
c
palindrome s’
Il faut aussi remarquer qu’un mot r´eduit `a un seul caract`ere est un palindrome et que
la chaˆıne vide est elle aussi un palindrome (puisqu’elle se lit aussi bien `a l’endroit qu’`a
26 R´ecursivit´e
l’envers). Pour obtenir une sous-chaˆıne d’une chaˆıne de caract`eres, on utilise la fonction
pr´ed´efinie sub_string (sous-chaˆıne), qui extrait une sous-chaˆıne partant d’un indice
donn´e et d’une longueur donn´ee :
# sub_string "Le langage Caml" 3 7;;
- : string = "langage"
En particulier, sub_string s 1 (string_length s - 2) retourne la chaˆıne s priv´ee
de son premier et de son dernier caract`ere. Ceci se traduit par la fonction r´ecursive
suivante :
# let rec palindrome s =
let longueur = string_length s in
if longueur <= 1 then true else
if s.[0] = s.[longueur - 1]
then palindrome (sub_string s 1 (longueur - 2))
else false;;
palindrome : string -> bool =
# palindrome "serres";;
- : bool = true
# palindrome "toto";;
- : bool = false
Op´erateurs bool´eens
Cette fonction s’´ecrit plus ´el´egamment `a l’aide des op´erateurs « et » et « ou » des
bool´eens. Par d´efinition, si P et Q sont des bool´eens, alors l’expression P et Q est vraie
quand P et Q sont vraies simultan´ement. Naturellement, l’expression P ou Q est vraie
d`es que P ou bien Q est vraie et a fortiori si P et Q sont vraies. En Caml le « ou » se
note || et le « et » &&.
Les op´erateurs || et && remplacent certaines formes d’expressions conditionnelles.
En effet, la construction if P then true else Q calcule la mˆeme valeur bool´eenne que
P || Q et de mˆeme if P then Q else false calcule la mˆeme valeur que P && Q. Bien
sˆur, if P then true else false se simplifie en P. On clarifie souvent les programmes
en appliquant ces ´equivalences. Voici donc une version plus simple de palindrome qui
utilise les op´erateurs bool´eens :
# let rec palindrome s =
let longueur = string_length s in
(longueur <= 1) ||
(s.[0] = s.[longueur - 1]) &&
(palindrome (sub_string s 1 (longueur - 2)));;
palindrome : string -> bool =
Les constructions || et && ont les mˆemes priorit´es relatives que + et *, c’est-`a-dire le
mˆeme parenth´esage implicite. Ainsi, de la mˆeme fa¸con que a + b * c se lit en fait
a + (b * c), l’expression a || b && c est lue a || (b && c) par la machine. On
lit alors le code de palindrome tr`es naturellement : une chaˆıne est un palindrome si sa
longueur est inf´erieure `a 1, ou si ses caract`eres de d´ebut et de fin sont les mˆemes et que
la sous-chaˆıne qu’ils d´elimitent est un palindrome.
D´efinitions par cas : le filtrage 27
Fonction r´ecursive `a plusieurs arguments
Pour plus d’efficacit´e, nous r´e´ecrivons la fonction palindrome en comparant directement
les caract`eres de la chaˆıne argument deux `a deux, sans cr´eer de sous-chaˆınes.
On prend donc deux indices dans la chaˆıne argument s. L’indice i d´emarre au premier
caract`ere ; l’indice j d´emarre au dernier caract`ere (au d´epart de la boucle on a donc
n´ecessairement i ≤ j, sauf si la chaˆıne est vide). `A chaque ´etape, on compare les caract`
eres d’indice i et j. S’ils sont ´egaux, on continue ; sinon, la chaˆıne n’est ´evidemment
pas un palindrome. La r´ecursion s’arrˆete quand l’indice i atteint ou d´epasse j. Dans le
cas i = j, on est sur le caract`ere central de la chaˆıne et il n’y a rien `a faire (il ne reste
qu’un caract`ere `a examiner forc´ement ´egal `a lui-mˆeme) : s est un palindrome. Dans le
cas i > j, il n’y a rien `a faire non plus : on a d´epass´e le milieu de la chaˆıne en ayant
compar´e deux `a deux tous les caract`eres, donc s est un palindrome. Cet exemple nous
fournit notre premi`ere fonction r´ecursive `a plusieurs arguments.
# let rec palin s i j =
(i >= j) || (s.[i] = s.[j]) && (palin s (i + 1) (j - 1));;
palin : string -> int -> int -> bool =
# let palindrome s = palin s 0 (string_length s - 1);;
palindrome : string -> bool =
# palindrome "eluparcettecrapule";;
- : bool = true
On simplifie encore un peu ce programme en ´ecrivant la palin `a l’int´erieur de
palindrome, ce qui lui ˆote l’argument s, qui est li´e par la fonction palindrome et
qui est donc visible par la fonction locale palin. C’est la version la plus jolie. Par
coquetterie, nous avons aussi supprim´e les parenth`eses autour des tests, car elles sont
implicites.
# let palindrome s =
let rec palin i j =
i >= j || s.[i] = s.[j] && palin (i + 1) (j - 1) in
palin 0 (string_length s - 1);;
palindrome : string -> bool =
# palindrome "tulaStroP´ecras´eC´esarc´ePortSalut";;
- : bool = true
2.2 D´efinitions par cas : le filtrage
Nous avons donn´e la d´efinition r´ecursive suivante de la fonction factorielle :
let rec factorielle n = if n = 0 then 1 else n * factorielle (n - 1);;
Caml dispose d’une mani`ere encore plus concise de d´efinir cette fonction : l’analyse de
cas. Il y a ici deux cas possibles pour l’argument de factorielle, ou bien c’est 0 ou
bien il est diff´erent de 0. On l’´ecrit ainsi :
# let rec factorielle = function
| 0 -> 1
| n -> n * factorielle (n - 1);;
factorielle : int -> int =
28 R´ecursivit´e
L’analyse de cas | 0 -> 1 | n -> n * factorielle (n - 1) signifie simplement :
si l’argument de la fonction est 0 alors renvoyer 1, sinon nommer n l’argument de la
fonction et retourner n * factorielle (n - 1). La barre verticale « | » introduit donc
les cas et correspond `a un « ou bien », tandis que la fl`eche « -> » indique ce qu’il faut
calculer dans le cas correspondant.
L’analyse de cas porte le nom technique de filtrage que nous emploierons d´esormais.
Le filtrage est un trait extrˆemement puissant de Caml. Il est int´egr´e dans de nombreuses
constructions du langage et tr`es fr´equemment employ´e dans les programmes.
Il arrive dans certains cas qu’on n’utilise pas l’argument de la fonction pour calculer
le r´esultat :
# let ´egal_un = function | 1 -> true | x -> false;;
´egal_un : int -> bool =
Pour bien montrer que le nom x ne sert `a rien, puisque sa valeur n’est pas n´ecessaire
pour retourner false, on se sert d’un symbole sp´ecial « _ » (le soulign´e), qui signifie
« dans tous les autres cas » :
# let est_un = function | 1 -> true | _ -> false;;
est_un : int -> bool =
# est_un 1;;
- : bool = true
# est_un 0;;
- : bool = false
Nous abordons maintenant un probl`eme apparemment tr`es difficile, qu’une fonction
r´ecursive r´esout sans difficult´e et avec une grande ´el´egance.
2.3 Les tours de Hanoi
La l´egende
Le jeu des tours de Hanoi consiste en une plaquette de bois sur laquelle sont plant´ees
trois tiges. Sur ces tiges sont enfil´es des disques de bois dont les diam`etres sont tous
diff´erents. La seule r`egle du jeu est de ne jamais poser un disque sur un disque plus
petit que lui, et de ne d´eplacer qu’un seul disque `a la fois. Au d´ebut du jeu tous les
disques sont pos´es sur la tige de gauche. Le but du jeu est de d´eplacer les disques d’une
tige sur l’autre, sans jamais violer la r`egle, pour finalement les amener tous sur la tige
de droite.
Le jeu original ´etait accompagn´e d’une notice racontant la l´egende de moines d’un
temple de Hanoi qui passaient leur temps `a r´esoudre ce jeu pour atteindre le nirvana.
En effet, les moines croyaient que la fin du monde arriverait lorsque le jeu serait achev´e.
Leur jeu grandeur nature occupait la cour d’un temple. Il se composait de 64 disques
d’or et de trois tiges d’ivoire d’un m`etre de haut. Cette l´egende a ´et´e invent´ee par le
math´ematicien fran¸cais Edouard Lucas en 1883.
Notre but est d’´ecrire un programme qui indique les mouvements `a faire pour
r´esoudre le jeu. Si vous n’ˆetes pas trop impatient, cherchez quelques instants vousm
ˆeme la solution. C’est difficile, n’est-ce pas ? Et pourtant, ce jeu est ´etrangement
facile `a r´esoudre avec une proc´edure r´ecursive.
Les tours de Hanoi 29
A
plus gros disque
autres
disques
B C
D´eplacer les autres disques sur B en respectant la r`egle :
hanoi A C B (n - 1)
A B C
plus gros disque
autres
disques
D´eplacer le disque restant vers C :
mouvement A C
A B C
plus gros disque
autres
disques
D´eplacer les autres disques de B vers C en respectant la r`egle :
hanoi B A C (n - 1)
A B C
plus gros disque
autres
disques
Figure 2.1: Comment r´esoudre le probl`eme des tours de Hanoi.
30 R´ecursivit´e
Le programme
Supposons que les tiges s’appellent A, B et C, que n soit le nombre de disques, tous
pos´es au d´epart sur la tige A, et que nous devions les mettre sur la tige C. L’astuce
consiste `a se rendre compte que si nous savions comment r´esoudre le probl`eme pour
n − 1 disques alors nous saurions le faire pour n, sans violer la r`egle. En effet, si l’on
suppose les n − 1 disques d´ej`a pos´es sur la tige B, le dernier disque encore pos´e sur la
tige A est le plus gros disque. Il nous suffit donc de le poser sur la tige C qui est vide
(pas de violation possible de la r`egle), puis de d´eplacer les n − 1 disques de la tige B `a
la tige C. C’est possible puisque nous supposons savoir comment d´eplacer n−1 disques
d’une tige `a une autre et puisque c’est le plus gros disque qui est maintenant pos´e sur
C, il n’y a pas de violation de la r`egle en posant les n−1 disques de B sur la tige C (voir
la figure 2.1). Mais nous savons aussi r´esoudre le probl`eme pour 0 disques : il n’y a rien
`a faire. Nous savons donc r´esoudre le probl`eme des tours de Hanoi pour tout n. C’est
encore plus facile `a dire en Caml : nous d´efinissons d’abord une fonction auxiliaire pour
imprimer les mouvements, puis la proc´edure principale.
# let mouvement de vers =
print_string
("D´eplace un disque de la tige " ^ de ^ " `a la tige " ^ vers);
print_newline ();;
mouvement : string -> string -> unit =
# let rec hanoi d´epart milieu arriv´ee = function
| 0 -> ()
| n -> hanoi d´epart arriv´ee milieu (n - 1);
mouvement d´epart arriv´ee;
hanoi milieu d´epart arriv´ee (n - 1);;
hanoi : string -> string -> string -> int -> unit =
Les noms des arguments d´epart, milieu et arriv´ee sont ´echang´es lorsque nous voulons
d´eplacer les disques d’une tige `a l’autre : par exemple, pour d´eplacer un disque de la tige
de nom d´epart vers la tige argument milieu, nous ´ecrivons hanoi d´epart arriv´ee
milieu 1.
# hanoi "A" "B" "C" 3;;
D´eplace un disque de la tige A `a la tige C
D´eplace un disque de la tige A `a la tige B
D´eplace un disque de la tige C `a la tige B
D´eplace un disque de la tige A `a la tige C
D´eplace un disque de la tige B `a la tige A
D´eplace un disque de la tige B `a la tige C
D´eplace un disque de la tige A `a la tige C
- : unit = ()
V´erifiez : le casse-tˆete est r´esolu. C’est magique ! On n’a pas vraiment l’impression
d’avoir ´ecrit un programme si savant . . .
Ne vous inqui´etez pas si vous ´eprouvez des difficult´es `a comprendre la proc´edure
hanoi. C’est normal, car c’est le premier exemple de programme Caml qui nous oblige
`a changer franchement notre fa¸con d’appr´ehender les programmes. En effet, il est
extrˆemement difficile de comprendre comment la proc´edure marche. Au contraire, il
Notions de complexit´e 31
faut se demander pourquoi elle marche. Le pourquoi est simple : il est enti`erement contenu
dans la figure 2.1. Si vous ˆetes persuad´e du bien-fond´e de la m´ethode de r´esolution
que la figure sugg`ere et que vous ˆetes convaincu que la proc´edure hanoi impl´emente
correctement cette m´ethode, alors ne cherchez pas plus loin : vous avez tout compris.
Si en revanche vous essayez de suivre le d´eroulement des appels r´ecursifs et les permutations
d’arguments qui se d´eroulent `a l’ex´ecution de la proc´edure (par exemple
en utilisant la trace de Caml), vous serez vite perdu. En fait, mˆeme si vous suiviez
pr´ecautionneusement ce d´eroulement vous n’en apprendriez pas plus, si ce n’est que
¸ca marche, puisque vous constateriez que les bons arguments se mettent en place au
bon moment pour produire les bons r´esultats, comme par miracle. Il faut se d´ecider
`a penser que ce suivi pas `a pas du d´eroulement des programmes est du ressort de la
machine exclusivement. Notre compr´ehension est de bien plus haut niveau : elle consiste
essentiellement `a prouver que le programme ne peut que marcher ; comment le
programme parvient effectivement au bon r´esultat ne nous regarde pas. Il est heureux
que cette noble activit´e de r´eflexion sur le bien-fond´e d’une m´ethode de r´esolution d’un
probl`eme nous appartienne en propre, alors que nous d´el´eguons aux machines la mise
en oeuvre effective. Un ´equilibre se cr´ee ainsi : si la r´eflexion sur la m´ethode est hors de
port´ee de la machine, la gestion sans erreurs des passages de param`etres et la reprise
des appels r´ecursifs en suspens est un jeu d’enfant pour la machine, alors que nous
serions incapables d’une telle rigueur. Rendons donc aux machines ce qui appartient
aux machines.
Pour ceux que cela int´eresse, la section suivante esquisse les fondements th´eoriques
de la m´ethode qui explique pourquoi la proc´edure hanoi marche effectivement. Accessoirement,
il permet aussi de calculer la date `a laquelle les moines auront achev´e leur
travail et donne donc une bonne id´ee de la date de la fin du monde ! Si tout cela ne
vous pr´eoccupe pas, passez directement au chapitre suivant.
2.4 Notions de complexit´e
La complexit´e est l’´etude du nombre d’op´erations n´ecessaires `a l’ach`evement d’un
calcul. Une analyse de complexit´e permet donc de se faire une id´ee du temps de calcul
n´ecessaire `a l’ach`evement d’un programme, en fonction de l’argument qui lui est
soumis. En g´en´eral, on compte le nombre d’op´erations ´el´ementaires (additions, multiplications,
soustractions et divisions, comparaisons de valeurs, affectations d’´el´ements
de tableau) et/ou le nombre d’appels de fonctions. Par exemple, la fonction successeur
demande une seule op´eration, quel que soit son argument. En revanche, la complexit´e
de la fonction factorielle d´epend de son argument : elle demande n op´erations pour
l’argument n. Plus pr´ecis´ement, il faut n multiplications, n+1 appels r´ecursifs `a la fonction
factorielle et n soustractions. Si l’on consid`ere que ces trois types d’op´erations
ont des coˆuts voisins, alors la complexit´e de factorielle est de l’ordre de 2n+(n+1),
c’est-`a-dire de l’ordre de 3n. On consid´erera donc que la fonction factorielle a une
complexit´e qui augmente au mˆeme rythme que son argument, ce qu’on note O(n) et
qu’on prononce « grand-o de n ». Plus pr´ecis´ement, O(n) signifie « un certain nombre
de fois » n, plus des termes n´egligeables devant n quand n devient grand, comme par
exemple une constante. On ne s’int´eresse en effet qu’`a un ordre de grandeur de la com32
R´ecursivit´e
plexit´e : cette complexit´e augmente-t-elle comme l’argument (algorithme lin´eaire), ou
comme le carr´e de l’argument (algorithme quadratique), ou comme une exponentielle de
l’argument (algorithme exponentiel ) ? Dans le cas de factorielle, on r´esume l’´etude
en notant une complexit´e lin´eaire O(n), puisque la complexit´e r´eelle est 3n + 1.
Principe de r´ecurrence
Les ´etudes de complexit´e et les d´efinitions r´ecursives de fonctions reposent sur un
raisonnement simple sur les propri´et´es qui concernent les nombres entiers : le principe
de r´ecurrence. Nous allons l’expliquer, puis l’utiliser pour d´emontrer des propri´et´es de
la fonction hanoi.
Le principe de r´ecurrence s’´enonce informellement ainsi : si une certaine propri´et´e
sur les nombres entiers est vraie pour 0 et si la propri´et´e est vraie pour le successeur
d’un nombre d`es qu’elle est vraie pour ce nombre, alors cette propri´et´e est vraie pour
tous les nombres. Formellement : soit P(n) une propri´et´e qui d´epend d’un entier n. Si
les phrases suivantes sont vraies :
1. P(0) est vraie,
2. si P(n) est vraie alors P(n + 1) est vraie,
alors P(n) est vraie pour tout n.
Ce principe est en fait ´evident : les deux propri´et´es demand´ees par le principe de
r´ecurrence permettent facilement de d´emontrer la propri´et´e P pour toute valeur enti`ere.
Par exemple, supposons que P v´erifie les deux propri´et´es et qu’on veuille d´emontrer
que P est vraie pour 2. Puisque P est vraie pour 0 elle est vraie pour son successeur, 1.
Mais puisque P est vraie pour 1 elle est vraie pour son successeur, donc elle est vraie
pour 2. Il est clair que ce raisonnement se poursuit sans probl`eme pour tout nombre
entier fix´e `a l’avance.
C’est ce principe que nous avons utilis´e pour r´esoudre le probl`eme des tours de
Hanoi :
1. nous avons montr´e que nous savions le r´esoudre pour 0 disque ;
2. nous avons montr´e qu’en sachant le r´esoudre pour n − 1 disques nous savions le
r´esoudre pour n disques.
Ces deux cas correspondent exactement aux deux clauses de la fonction hanoi (cas 0 ->
et cas n ->). Le principe de r´ecurrence nous prouve donc que nous savons effectivement
r´esoudre le probl`eme pour tout n, mˆeme si cela ne nous apparaissait pas clairement au
d´epart.
La difficult´e intuitive de ce genre de d´efinitions r´ecursives est d’oser utiliser
l’hypoth`ese de r´ecurrence : il faut supposer qu’on sait d´ej`a faire pour n − 1 disques et
´ecrire le programme qui r´esout le probl`eme pour n disques. Dans la proc´edure hanoi,
on suppose ainsi deux fois que la fonction saura bien faire toute seule pour n − 1
disques et l’on ne s’occupe que de d´eplacer le gros disque, ce qui semble un travail
facile. Finalement, on a l’impression de voir tourner du code que l’on n’a pas ´ecrit,
tellement il semble astucieux `a l’ex´ecution.
L’´ecriture de fonctions r´ecursives se r´eduit ainsi tr`es souvent au sch´ema :
Notions de complexit´e 33
let rec f = function
| 0 -> « solution simple »
| n -> ... f (n - 1) ... f (n - 1) ...;;
On d´emontre en math´ematiques qu’il n’est pas interdit d’appeler f sur d’autres arguments
que n - 1, pourvu qu’ils soient plus petits que n (par exemple n - 2), mais
alors il faut pr´evoir d’autres cas simples (par exemple 1 ->). Un exemple de ce sch´ema
de programme est la fonction de Fibonacci d´efinie par :
# let rec fib = function
| 0 -> 1
| 1 -> 1
| n -> fib (n - 1) + fib (n - 2);;
fib : int -> int =
# fib 10;;
- : int = 89
Remarquez que cette fonction fait effectivement deux appels r´ecursifs sur deux valeurs
diff´erentes, mais toutes les deux plus petites que l’argument donn´e.
Complexit´e de la proc´edure hanoi
Il est facile d’´ecrire un programme qui compte le nombre de mouvements n´ecessaires
pour r´esoudre le jeu pour n disques : il y a 0 mouvement `a faire pour 0 disque, l’appel `a
la proc´edure mouvement produit 1 mouvement et le nombre de mouvements n´ecessaires
aux appels r´ecursifs est forc´ement compt´e par la fonction r´ecursive de comptage que
nous sommes en train de d´efinir. En effet, on suppose une fois de plus que pour n − 1
la fonction « sait faire » et on se contente de trouver le r´esultat pour n.
# let rec compte_hanoi d´epart milieu arriv´ee = function
| 0 -> 0
| n -> compte_hanoi d´epart arriv´ee milieu (n - 1) + 1 +
compte_hanoi milieu d´epart arriv´ee (n - 1);;
compte_hanoi : ’a -> ’a -> ’a -> int -> int =
Les arguments contenant les noms des tiges sont bien sˆur inutiles et il suffit d’´ecrire :
# let rec compte_hanoi_na¨ıf = function
| 0 -> 0
| n -> compte_hanoi_na¨ıf (n - 1) + 1 + compte_hanoi_na¨ıf (n - 1);;
compte_hanoi_na¨ıf : int -> int =
qu’on simplifie encore en
# let rec compte_hanoi = function
| 0 -> 0
| n -> (2 * compte_hanoi (n - 1)) + 1;;
compte_hanoi : int -> int =
# compte_hanoi 3;;
- : int = 7
# compte_hanoi 10;;
- : int = 1023
# compte_hanoi 16;;
- : int = 65535
On devine la propri´et´e suivante : pour tout n, compte_hanoi (n) = 2n −1. Nous allons
la d´emontrer en utilisant le principe de r´ecurrence. Nous d´efinissons donc formellement
34 R´ecursivit´e
la propri´et´e P par : P(n) est vraie si et seulement si compte_hanoi (n) = 2n − 1. La
proposition P(0) est vraie car compte_hanoi (0) = 0 et 20 − 1 = 1 − 1 = 0. Supposons
P(n) vraie et montrons qu’alors P(n + 1) est vraie. Pour montrer P(n + 1), il faut
d´emontrer
compte_hanoi (n + 1) = 2n+1 − 1.
Or, d’apr`es la d´efinition de la fonction compte_hanoi, on a :
compte_hanoi (n + 1) = 2 × compte_hanoi ((n + 1) − 1) + 1,
soit compte_hanoi (n + 1) = 2 × compte_hanoi (n) + 1. Mais, par hypoth`ese de
r´ecurrence, P(n) est vraie, donc compte_hanoi (n) = 2n−1. En reportant dans l’´egalit´e
pr´ec´edente, on obtient :
compte_hanoi (n + 1) = 2 × (2n − 1) + 1.
Mais 2 × (2n − 1) + 1 = 2n+1 − 2 + 1 = 2n+1 − 1, donc
compte_hanoi (n + 1) = 2n+1 − 1
et P(n + 1) est vraie. Il s’ensuit, d’apr`es le principe de r´ecurrence, que P(n) est vraie
pour tout n.
Avec ce nouveau r´esultat, nous sommes autoris´es `a red´efinir compte_hanoi comme
la fonction qui `a n associe 2n − 1. Pour avoir une id´ee du nombre de mouvements
n´ecessaires pour r´esoudre le probl`eme avec 64 disques, nous sommes oblig´es de faire les
calculs en « virgule flottante » car le r´esultat exc`ede de beaucoup la limite sup´erieure des
entiers repr´esentables en Caml. Nous reviendrons plus tard sur les nombres en virgule
flottante, aussi appel´es nombres flottants (chapitre 8). Pour l’instant il suffit de savoir
qu’un nombre flottant est caract´eris´e par le point qui pr´ec`ede sa partie d´ecimale et que
les op´erations associ´ees aux flottants sont suffix´ees ´egalement par un point (+., -., *.,
etc.). Nous impl´ementons donc notre fonction en utilisant la fonction « puissance » des
nombres flottants (power).
# let compte_hanoi_rapide n = power 2.0 n -. 1.0;;
compte_hanoi_rapide : float -> float =
# compte_hanoi_rapide 64.0;;
- : float = 1.84467440737e+19
Un algorithme correct mais inutilisable
Grˆace `a notre d´emonstration math´ematique, nous avons ´etabli une formule de calcul
direct du nombre de mouvements n´ecessaires `a la r´esolution du jeu pour n disques.
Nous avons ainsi tr`es fortement acc´el´er´e la fonction compte_hanoi. C’´etait indispensable
car notre premi`ere version, la fonction compte_hanoi_na¨ıf, quoique parfaitement
correcte d’un point de vue math´ematique, n’aurait pas pu nous fournir le r´esultat pour
64. En effet cette version calcule son r´esultat en utilisant uniquement l’addition. Plus
pr´ecis´ement, elle n’ajoute toujours que des 1 : il lui aurait donc fallu faire 264 − 1 additions.
Mˆeme en supposant qu’on fasse 1 milliard d’additions par seconde, ce qui est
`a la limite de la technologie actuelle, il aurait fallu, avec le programme de la premi`ere
version de compte_hanoi,
Notions de complexit´e 35
# let nombre_de_secondes_par_an = 3600.0 *. 24.0 *. 365.25;;
nombre_de_secondes_par_an : float = 31557600.0
# let nombre_d’additions_par_an = nombre_de_secondes_par_an *. 1E9;;
nombre_d’additions_par_an : float = 3.15576e+16
# compte_hanoi_rapide 64.0 /. nombre_d’additions_par_an;;
- : float = 584.542046091
c’est-`a-dire plus de 584 ann´ees pour achever le calcul ! Nous sommes donc ici en pr´esence
d’une fonction qui donne effectivement le bon r´esultat au sens des math´ematiques,
mais qui le calcule tellement lentement qu’elle devient inutilisable. `A la diff´erence des
math´ematiques, il ne suffit donc pas en informatique d’´ecrire des programmes corrects,
il faut encore que leur complexit´e ne soit pas trop ´elev´ee pour qu’ils calculent le r´esultat
correct en un temps raisonnable.
La fonction compte_hanoi_na¨ıve n´ecessite 2n−1 additions pour l’argument n. Son
temps de calcul est donc proportionnel `a une puissance (2n) dont l’exposant est son
argument n : l’algorithme est exponentiel. La seconde version utilisant la multiplication
n´ecessite n multiplications, l’algorithme est donc lin´eaire. Un algorithme lin´eaire demande
un temps de calcul qui augmente comme la valeur de son argument (O(n)), ce
qui est raisonnable. En effet, cette version nous aurait permis d’obtenir notre r´esultat,
puisque pour n = 64 il aurait fallu 64 multiplications seulement. La derni`ere version,
quant `a elle, est en temps constant. Elle ne n´ecessite que deux op´erations flottantes quel
que soit son argument : c’est l’algorithme id´eal. On retiendra qu’un algorithme exponentiel
est vite susceptible d’exiger un temps de calcul prohibitif quand son argument
augmente.
Date de la fin du monde
Calculons le nombre d’ann´ees n´ecessaires aux moines pour achever leur jeu `a 64
disques. Supposons qu’ils puissent effectuer sans arrˆet, jour et nuit, dix mouvements
par secondes, ce qui est vraiment le maximum qu’on puisse exiger de ces pauvres moines.
Il leur faudrait alors :
# let nombre_de_mouvements_par_an =
nombre_de_secondes_par_an *. 10.0;;
nombre_de_mouvements_par_an : float = 315576000.0
# compte_hanoi_rapide 64.0 /. nombre_de_mouvements_par_an;;
- : float = 58454204609.1
soit plus de 58 milliards d’ann´ees. C’est beaucoup plus que la dur´ee de vie estim´ee du
Soleil. Il semble donc que l’heure de la fin du monde aura sonn´e tr`es longtemps avant
la fin du jeu !
Calcul de la complexit´e de la seconde version
Dans la section pr´ec´edente, nous avons affirm´e que la seconde version de
compte_hanoi :
# let rec compte_hanoi = function
| 0 -> 0
| n -> 2 * compte_hanoi (n - 1) + 1;;
compte_hanoi : int -> int =
36 R´ecursivit´e
n´ecessitait n multiplications. La d´emonstration en est tr`es simple. Nous noterons
Op(compte_hanoi (n)) le nombre d’op´erations n´ecessaires pour effectuer le calcul
de compte_hanoi (n) `a l’aide de cette version de compte_hanoi. Nous d´emontrons
par r´ecurrence la propri´et´e P(n) d´efinie par : P(n) est vraie si et seulement si
Op(compte_hanoi (n)) = n. La propri´et´e P(0) est vraie car Op(compte_hanoi (0)) = 0.
Supposons P(n) vraie et montrons qu’alors P(n+1) est vraie. Pour montrer P(n+1),
il faut d´emontrer Op(compte_hanoi (n + 1)) = (n + 1). Or, d’apr`es le code de
la fonction compte_hanoi, quand on a le r´esultat de compte_hanoi (n - 1), il
faut faire une multiplication de plus pour obtenir compte_hanoi (n). On a donc :
Op(compte_hanoi (n+1)) = 1+Op(compte_hanoi (n)) ; mais, d’apr`es l’hypoth`ese de
r´ecurrence, Op(compte_hanoi (n)) = n, et donc Op(compte_hanoi (n+1)) = n+1. Il
s’ensuit que P(n) est vraie pour tout n.
Remarquons pour finir que nous avons calcul´e la complexit´e de hanoi en utilisant
la fonction compte_hanoi, dont nous avons dˆu `a nouveau ´etudier la complexit´e, pour
l’optimiser (sous peine de ne pas obtenir effectivement la complexit´e de hanoi). Il faut
d´ecid´ement r´efl´echir sur les programmes qu’on ´ecrit . . .
3
Programmation imp´erative
O`u l’on apprend que 2x + 2x font 4x.
ous mettons en place dans ce chapitre quelques outils indispensables `a la programmation
imp´erative. En particulier, nous introduisons la notion de tableau,
et l’utilisons pour calculer des identit´es remarquables. Nous serons par exemple
en mesure d’´etablir par programme la formule (x + 1)2 = x2 + 2x + 1. En termes savants
nous ferons du calcul formel sur des polynˆomes `a une ind´etermin´ee. Si vous savez
d´ej`a qu’il y a autre chose dans la vie que la programmation fonctionnelle et que vous
connaissez les boucles « for » et «while », vous pouvez sauter ce chapitre.
3.1 La programmation imp´erative
Jusqu’`a pr´esent, nous avons ´ecrit de petits programmes dans un sous-ensemble de
Caml : la partie d´eclarative, la plus proche des math´ematiques. Nous avons toujours
d´efini des fonctions qui retournaient le r´esultat que nous voulions calculer. Ces fonctions
calculent le r´esultat souhait´e au sens des calculs math´ematiques, c’est-`a-dire par
simplifications successives d’une expression. Ce style de programmation `a l’aide de
fonctions s’appelle la programmation fonctionnelle.
Une autre fa¸con de calculer consiste `a consid´erer qu’un calcul est un processus
´evolutif, o`u le temps a son importance. Il s’agit de modifier un ´etat : l’ordinateur commence
l’ex´ecution du programme dans un certain ´etat initial, que l’ex´ecution du programme
modifie jusqu’`a parvenir `a un ´etat final qui contient le r´esultat voulu. On
change l’´etat courant par modification du contenu de la m´emoire de l’ordinateur (`a
l’aide d’affectations), ou encore par interaction avec le monde ext´erieur : interrogation
de l’utilisateur, affichage de r´esultats, lecture ou ´ecriture de fichiers, bref tout ce qu’on
nomme les entr´ees-sorties. Toutes ces op´erations qui modifient physiquement le contenu
des adresses m´emoire sont appel´ees effets (ou encore effets de bord) :
Un effet est une modification d’une case de la m´emoire (tableau ou
r´ef´erence), ou encore une interaction avec le monde ext´erieur (impression
ou lecture).
38 Programmation imp´erative
Ce style de programmation par effets s’appelle la programmation imp´erative. Ce nom
provient ´evidemment de la signification du mode imp´eratif dans la conjugaison des
verbes. En effet, les programmes imp´eratifs d´ecrivent explicitement `a la machine la
suite des op´erations `a effectuer (fais ci, fais ¸ca). Au contraire, en programmation fonctionnelle,
on laisse la machine calculer le r´esultat comme elle le peut `a partir d’une formule,
sans lui pr´eciser compl`etement l’ordre dans lequel elle doit op´erer. Par exemple,
pour calculer le carr´e d’un nombre x, on ´ecrit x * x en programmation fonctionnelle.
Au contraire, une m´ethode imp´erative serait de r´eserver une case m´emoire comme accumulateur,
de l’initialiser avec x, puis de remplacer le contenu de cet accumulateur
par son contenu multipli´e par lui-mˆeme. Le r´esultat cherch´e serait maintenant dans
l’accumulateur. Dans un cas si simple, ces descriptions sont ´evidemment caricaturales,
mais l’id´ee est la bonne.
Le style imp´eratif implique la modification de l’´etat de la m´emoire, donc l’utilisation
de structures de donn´ees modifiables (par exemple les tableaux dont les ´el´ements peuvent
ˆetre chang´es dynamiquement) et l’emploi de commandes. Les commandes sont des
expressions qui ne retournent pas de valeurs int´eressantes ; leur r´esultat est simplement
une modification de l’´etat courant, c’est-`a-dire un effet. Lorsqu’une fonction se contente
d’ex´ecuter une s´erie de commandes, on l’appelle souvent proc´edure. Une proc´edure en
Caml est donc simplement une fonction qui se contente de faire des effets, sans produire
de r´esultat au sens math´ematique.
Nous aurions pu nous cantonner au sous-ensemble fonctionnel de Caml et cependant
´ecrire de tr`es jolis programmes. Mais c’eˆut ´et´e donner une fausse image de Caml : ce qui
fait la puissance du langage c’est justement qu’il ne se limite pas `a la programmation
fonctionnelle, mais int`egre harmonieusement programmation fonctionnelle et programmation
imp´erative. De plus, nous cherchons avant tout `a vous montrer les programmes
les plus simples et les plus clairs possibles : nous avons donc besoin de tous les outils
que Caml met `a notre disposition.
De surcroˆıt, la programmation imp´erative n’est pas seulement indispensable pour
traiter les probl`emes d’interaction avec le monde ext´erieur (entr´ees-sorties). Dans certains
cas un algorithme, c’est-`a-dire une m´ethode de r´esolution d’un probl`eme, exige
moins de calculs lorsqu’il est ´ecrit en style imp´eratif que lorsqu’il est ´ecrit en style fonctionnel.
Enfin, certains algorithmes s’expriment naturellement en termes d’´evolution
d’un ´etat ; la programmation imp´erative s’impose alors.
Nous avons pour l’instant illustr´e les effets d’entr´ees-sorties, plus pr´ecis´ement les
impressions. Nous allons maintenant faire des effets sur la m´emoire, ce qu’on appelle
aussi des modifications physiques ou modifications en place de donn´ees. Pour cela il nous
faut disposer de cases m´emoire modifiables par le programme. Caml propose pour cela
les notions de r´ef´erences et de tableaux. Nous commen¸cons par ´etudier les tableaux, qui
sont plus simples.
Puisque la notion de temps intervient en programmation imp´erative, il nous faut un
moyen de sp´ecifier au langage « fait ceci d’abord » et « fait cela ensuite » : c’est la notion
de s´equence que nous avons d´ej`a vue au chapitre 1. Nous avons ´egalement besoin de
r´ep´eter des suites d’effets : c’est la notion de boucles. Nous d´ecrivons ces construction,
puis appliquons ces outils au calcul sur les polynˆomes.
Boucles 39
3.2 Boucles
Caml fournit deux sortes de boucles pour r´ep´eter des effets : la boucle « pour » et
la boucle « tant que ». La boucle « pour » r´ep`ete un calcul un nombre de fois fix´e `a
l’avance ; la boucle « tant que » r´ep`ete un calcul tant qu’une condition reste vraie.
Boucle « tant que »
Boucle « tant que » ::= while expression (while : tant que)
do expression done (do : faire, done : fait)
La signification de while condition do actions done est simplement de faire les actions
tant que la condition est vraie. La condition est test´ee au d´ebut de chaque it´eration. Si
elle est initialement fausse, les actions ne sont jamais ex´ecut´ees. Dans certains cas, la
boucle « tant que » sert `a r´ep´eter ind´efiniment les mˆemes actions jusqu’`a un ´ev´enement
exceptionnel. Dans ce cas, la condition de boucle est tout simplement le bool´een true,
comme dans while true do actions done.
Boucle « pour »
Boucle « pour » ::= for ident = expression (for : pour)
(to | downto) expression (to : jusqu’`a, down : en bas)
do expression done (do : faire, done : fait)
La s´emantique, c’est-`a-dire la signification, de l’expression for i = d´ebut to fin do
actions done est de faire les actions avec i = d´ebut, puis avec i = d´ebut + 1 et ainsi de
suite, jusqu’`a i = fin. En particulier, si d´ebut > fin, on n’´evalue jamais actions. Pour la
version downto, on d´ecr´emente l’indice de boucle i (on lui soustrait 1) `a chaque tour,
au lieu de l’incr´ementer (lui ajouter 1). L’indice de boucle est forc´ement du type entier.
Le nom associ´e `a l’indice de boucle est introduit par la boucle (comme par une liaison
let) ; sa liaison n’est valide que pendant le corps de la boucle. Prenons un exemple
simple : nous imprimons les dix chiffres `a l’aide d’une boucle de 0 `a 9. Nous d´efinissons
une proc´edure imprime_chiffre dont l’argument est « rien », et nous la d´eclenchons
en l’appliquant `a « rien ».
# let imprime_chiffres () =
for i = 0 to 9 do
print_int i
done;
print_newline ();;
imprime_chiffres : unit -> unit =
# imprime_chiffres ();;
0123456789
- : unit = ()
40 Programmation imp´erative
3.3 Manipulation de polynˆomes
Nous continuons l’apprentissage de la programmation imp´erative par l’´etude des
tableaux. `A titre d’illustration, nous ´ecrivons un jeu de fonctions qui impl´ementent les
op´erations de base sur les polynˆomes. Avant de nous lancer dans la programmation,
nous rappelons bri`evement ce que sont les polynˆomes.
Les polynˆomes `a une ind´etermin´ee
Des classes ´el´ementaires, on retient souvent qu’un polynˆome est une somme de
puissances de x. Par exemple, p = x2+2x+3 est un polynˆome. La variable x est appel´ee
l’ind´etermin´ee du polynˆome. Un polynˆome est une somme de termes ´el´ementaires qu’on
nomme monˆomes (par exemple x2 et 2x). ´Etant donn´ee une variable x, on appelle
monˆome de coefficient ai et de degr´e i l’expression ai xi. Le degr´e d’un polynˆome est
celui de son monˆome de plus haut degr´e. On rappelle que x1 = x et x0 = 1. Le monˆome
de degr´e 0 est donc r´eduit `a une constante (c’est 3 pour p) et celui de degr´e 1 au
produit d’un nombre par l’ind´etermin´ee (c’est 2x pour p). D’autre part, nous utiliserons
la propri´et´e : pour tout n et m entiers positifs, xn × xm = xn+m.
Nous mod´elisons les polynˆomes `a l’aide de tableaux d’entiers : le tableau des coefficients
de leurs monˆomes. Les degr´es seront donc implicites, simplement d´etermin´es
par l’indice du coefficient dans le tableau qui repr´esente le polynˆome. Par exemple, le
polynˆome p = x2 + 2x + 3 sera repr´esent´e par le tableau contenant les nombres 3, 2, 1
dans cet ordre, puisque 3 est le coefficient de degr´e 0 de p, 2 est le coefficient de degr´e 1
et 1 le coefficient de degr´e 2. Nous ´etudions donc maintenant bri`evement les tableaux
de Caml.
Tableaux
Les tableaux, aussi appel´es « vecteurs », sont des suites finies et modifiables de
valeurs d’un mˆeme type. Leur type est not´e ′a vect (o`u ′a signifie « n’importe quel
type »). Puisque les ´el´ements des tableaux sont tous de la mˆeme nature (du mˆeme
type), on qualifie les tableaux de suites homog`enes de valeurs. Les valeurs d’un tableau
sont enregistr´ees dans des cellules de m´emoire cons´ecutives. Les positions des ´el´ements
dans un tableau d´ebutent `a la position 0.
Construction de tableaux
Un tableau se d´efinit de deux fa¸cons : soit en dressant directement la liste de ses
´el´ements, soit en cr´eant le tableau et en remplissant ses cases ult´erieurement. Si un
tableau est d´efini par la liste de ses ´el´ements, cette liste est entour´ees des symboles [|
et |], tandis que les ´el´ements sont s´epar´es par des « ; ». Notre polynˆome p = x2+2x+3
se d´efinit donc par la phrase :
# let p = [| 3; 2; 1 |];;
p : int vect = [|3; 2; 1|]
Graphiquement, on repr´esente naturellement les tableaux par une succession de
cases. Par exemple, p sera repr´esent´e ainsi :
Manipulation de polynˆomes 41
p 3 2 1
|0 {1z 2}
indices
Pour construire des tableaux dont on remplira les cases plus tard, on dispose de la
fonction pr´ed´efinie make_vect. Avec cette fonction, on cr´ee un tableau en donnant sa
taille et un ´el´ement qui sera mis au d´epart dans toutes les cases du tableau : la valeur
d’initialisation du tableau. D´efinissons par exemple un tableau de taille 4 contenant des
2 et un tableau de taille 3 contenant la chaˆıne "Bonjour" :
# let q = make_vect 4 2;;
q : int vect = [|2; 2; 2; 2|]
# let r = make_vect 3 "Bonjour";;
r : string vect = [|"Bonjour"; "Bonjour"; "Bonjour"|]
La taille d’un tableau s’obtient en appelant la primitive vect_length.
# vect_length q;;
- : int = 4
Une fois le tableau cr´e´e, on peut consulter et modifier le contenu de ses cases. Si t est
un tableau et n un entier, t.(n) d´esigne l’´el´ement d’indice n du tableau t.
t
t.(0) t.(n) t.(vect_length(t)−1)
# let a0 = p.(0);;
a0 : int = 3
On affecte la valeur v `a la case n du tableau t par la construction t.(n) <- v. Cela
correspond graphiquement `a :
t
t.(0) t.(n − 1) t.(n + 1) t.(vect_length(t)−1)
v
La valeur retourn´ee par cette construction est (), la valeur « rien ».
# q.(0) <- 1;;
- : unit = ()
# q;;
- : int vect = [|1; 2; 2; 2|]
# r.(1) <- "tout"; r.(2) <- "le monde!";;
- : unit = ()
# r;;
- : string vect = [|"Bonjour"; "tout"; "le monde!"|]
Nous savons maintenant d´efinir des tableaux, en lire et modifier les ´el´ements. Il
nous faut encore apprendre `a les parcourir. C’est tr`es facile en utilisant les boucles que
nous avons d´ecrites `a la section pr´ec´edente. Puisqu’il s’agit de parcourir un tableau,
42 Programmation imp´erative
on connaˆıt `a l’avance le nombre de r´ep´etitions : on utilise donc une boucle « pour ».
Le parcours complet d’un tableau t s’effectue par une boucle commen¸cant en 0 et
finissant en vect_length t - 1. En effet, puisque les indices d’´el´ements de tableaux
commencent toujours `a 0, le dernier ´el´ement d’un tableau a pour indice la longueur du
tableau moins un. Par exemple :
# for i = 0 to vect_length r - 1 do
print_string r.(i)
done;;
Bonjourtoutle monde!- : unit = ()
Pour rendre la sortie plus jolie, il suffit d’ajouter un blanc apr`es chaque ´el´ement :
# for i = 0 to vect_length r - 1 do
print_string r.(i);
print_string " "
done;;
Bonjour tout le monde! - : unit = ()
Syntaxe des tableaux
Pour m´emoire, voici la syntaxe BNF correspondant `a ces deux constructions et `a la
d´efinition des tableaux sous la forme de liste d’´el´ements.
La syntaxe des d´efinitions de tableaux est la suivante :
Tableaux ::= [| expression ( ; expression)∗ |]
Nous utilisons ici un nouveau symbole pour la description des constructions syntaxiques
qui acceptent les r´ep´etitions : l’´etoile « ∗ ». La formule quelque-chose∗ signifie
la r´ep´etition de quelque-chose un nombre quelconque de fois, y compris z´ero fois si
n´ecessaire (ce qui correspond alors `a ignorer compl`etement quelque-chose). Nous indiquons
ainsi que le premier ´el´ement du tableau est ´eventuellement suivi d’autres
´el´ements, en nombre quelconque, s´epar´es par des points-virgules.
La syntaxe de l’affectation et de l’acc`es aux ´el´ements de tableaux est la suivante :
Acc`es dans un tableau ::= vect .( indice )
Modification d’un ´el´ement de tableau ::= vect .( indice ) <- expression
Attention `a la signification des parenth`eses dans cette description. Elles font ici partie
de la syntaxe d´ecrite (il faut les ´ecrire dans les programmes), alors que dans la notation
( ; expression)∗, les parenth`eses nous servaient `a regrouper les constructions syntaxiques
« ; » et « expression ». (La diff´erence de nature des parenth`eses se traduit par un
changement de police de caract`eres.)
3.4 Impression des polynˆomes
Nous savons maintenant repr´esenter les polynˆomes `a l’aide des tableaux. Pour les
manipuler, nous savons parcourir leurs coefficients `a l’aide d’une boucle for. Nous pouvons
donc commencer l’impl´ementation des op´erations ´el´ementaires sur les polynˆomes.
Commen¸cons par ´ecrire une proc´edure d’impression des polynˆomes pour visualiser
simplement nos r´esultats. Il suffit de parcourir le tableau repr´esentant le polynˆome
en imprimant ses monˆomes. Nous ´ecrivons donc d’abord la fonction d’impression d’un
Impression des polynˆomes 43
monˆome de coefficient c et de degr´e d. C’est tr`es simple : si le degr´e est 0, il suffit
d’´ecrire le coefficient ; sinon, on ´ecrit le coefficient et le degr´e sous la forme cX^d. Par
exemple, 3x2 sera ´ecrit 3x^2. Cet imprimeur n’est pas tr`es ´elabor´e : il se contente de
ne pas ´ecrire les monˆomes nuls ni les coefficients ´egaux `a 1 ; il traite aussi sp´ecialement
le cas particulier des monˆomes de degr´e 0 et 1. Ainsi il ´ecrit x^2 pour le monˆome 1x2,
3 pour le monˆome 3x0 et 4x pour le monˆome 4x1.
# let imprime_mon^ome coeff degr´e =
if degr´e = 0 then print_int coeff else
if coeff <> 0 then
begin
print_string " + ";
if coeff <> 1 then print_int coeff;
print_string "x";
if degr´e <> 1 then
begin print_string "^"; print_int degr´e end
end;;
imprime_mon^ome : int -> int -> unit =
La primitive <> correspond au pr´edicat math´ematique 6= et teste donc si deux valeurs
sont diff´erentes.
Il est temps de donner le nom technique des polynˆomes mod´elis´es par des
tableaux d’entiers : on les appelle polynˆomes pleins, ce qui signifie simplement que leur
repr´esentation comporte la liste exhaustive de leurs monˆomes, y compris ceux dont
le coefficient est nul. C’est pourquoi nous appelons la fonction d’impression de ces
polynˆomes imprime_polyn^ome_plein. Cette fonction se contente d’it´erer la proc´edure
imprime_mon^ome sur tout le polynˆome, `a l’aide d’une boucle « pour ».
# let imprime_polyn^ome_plein p =
for i = 0 to vect_length p - 1 do imprime_mon^ome p.(i) i done;;
imprime_polyn^ome_plein : int vect -> unit =
Le polynˆome p = x2 + 2x + 3 s’imprime comme suit :
# imprime_polyn^ome_plein p;;
3 + 2x + x^2- : unit = ()
Addition des polynˆomes
L’addition des polynˆomes se fait monˆome par monˆome, en ajoutant les coefficients
des monˆomes de mˆeme degr´e :
(1 + 2x + 3x2) + (4 + 5x + 6x2) = (1 + 4) + (2 + 5)x + (3 + 6)x2
= 5 + 7x + 9x2.
Math´ematiquement, on a : si P = p0 + p1x + p2x2 + · · · + pmxm et Q = q0 + q1x +
q2x2 + · · · + qnxn, alors
P + Q = (p0 + q0) + (p1 + q1)x + (p2 + q2)x2 + · · · + (pmax(m,n) + qmax(m,n))xmax(m,n)
Cette d´efinition utilise la convention qu’un coefficient de degr´e sup´erieur au degr´e du
polynˆome est implicitement 0. On peut exprimer ces formules de fa¸con plus synth´etique
44 Programmation imp´erative
en introduisant la notation math´ematique pour r´esumer les sommes de termes : si
formule est une expression qui d´epend de l’entier i, on note
Xn
i=0
formule (i) pour formule (0) + formule (1) + · · · + formule (n).
(La notation
Pn
i=0 formule (i) se lit « somme de i ´egale 0 `a n de formule (i) ».) Par
exemple, si la formule est r´eduite `a i, on obtient la somme des nombres de 0 `a n :
Xn
i=0
i = 0 + 1 + · · · + n.
De mˆeme, si la formule est i2, la somme correspondante est celle des carr´es des nombres
entre 0 et n :
Xn
i=0
i2 = 02 + 12 + · · · + n2.
On exprime ainsi de mani`ere tr`es concise deux polynˆomes g´en´eraux P et Q et leur
somme P + Q:
Si P =
mX
i=0
pi xi et Q =
Xn
i=0
qi xi alors P + Q =
maxX(m,n)
i=0
(pi + qi) xi.
La traduction en Caml de cette d´efinition est tr`es simple : on cr´ee d’abord un tableau
somme, pour contenir la somme des deux polynˆomes P et Q. Ce tableau a pour longueur
le maximum des longueurs de P et Q, qu’on calcule avec la fonction pr´ed´efinie max. Il
suffit de recopier les coefficients de l’un des polynˆomes dans les cases du r´esultat, puis
d’y ajouter les coefficients de l’autre.
# let ajoute_polyn^omes_pleins p q =
let somme = make_vect (max (vect_length p) (vect_length q)) 0 in
for i = 0 to vect_length p - 1 do
somme.(i) <- p.(i)
done;
for i = 0 to vect_length q - 1 do
somme.(i) <- somme.(i) + q.(i)
done;
somme;;
ajoute_polyn^omes_pleins : int vect -> int vect -> int vect =
Comme promis, nous pouvons maintenant calculer la valeur de 2x + 2x :
# imprime_polyn^ome_plein (ajoute_polyn^omes_pleins [|0; 2|] [|0; 2|]);;
0 + 4x- : unit = ()
et v´erifier un de nos calculs pr´ec´edents :
# imprime_polyn^ome_plein
(ajoute_polyn^omes_pleins [|1; 2; 3|] [|4; 5; 6|]);;
5 + 7x + 9x^2- : unit = ()
et mˆeme (qui l’eˆut cru ?) calculer x − x et trouver 0 :
# imprime_polyn^ome_plein
(ajoute_polyn^omes_pleins [|0; 1|] [|0; -1|]);;
0- : unit = ()
Impression des polynˆomes 45
Multiplication des polynˆomes
On d´efinit le produit des polynˆomes en utilisant les r`egles classiques de
d´eveloppement des expressions alg´ebriques. En termes savants, on dit que l’on
utilise la distributivit´e de la multiplication par rapport `a l’addition. Par exemple, pour
tout polynˆome Q, on a (1 + 2x + 3x2) × Q = 1 × Q + 2x × Q + 3x2 × Q, et donc
(1 + 2x + 3x2) × (4 + 5x + 6x2)
= 1 × (4 + 5x + 6x2) + 2x × (4 + 5x + 6x2) + 3x2 × (4 + 5x + 6x2)
= (4 + 5x + 6x2) + (8x + 10x2 + 12x3) + (12x2 + 15x3 + 18x4)
= 4 + 13x + 28x2 + 27x3 + 18x4.
La remarque fondamentale est que le produit des coefficients des monˆomes de degr´e i du
premier polynˆome et de degr´e j du second forme une partie du coefficient du monˆome
de degr´e i + j du produit. Par exemple, pour les monˆomes 2x et 6x2, le produit 2 × 6
entrera dans la composition du coefficient du monˆome de degr´e trois du r´esultat, ce
qui signifie simplement que 2x × 6x2 = 12x3. Pour prendre en compte le produit des
monˆomes 2x et 6x2 dans le r´esultat final, il suffit donc d’ajouter le produit 2×6 dans la
case correspondant au coefficient de x3 du r´esultat final. Ainsi, notre proc´edure Caml
va parcourir les monˆomes des deux polynˆomes deux `a deux, en les multipliant et en
enregistrant le produit de leurs coefficients dans le monˆome de degr´e correspondant du
produit.
Pour les fanatiques des formules, ceci se traduit par la d´efinition math´ematique
suivante :
Le produit des deux polynˆomes P =
mX
i=0
pi Xi et Q =
Xn
j=0
qj Xj
est le polynˆome (P × Q) =
mX+n
k=0
rk Xk avec rk =
X
i+j=k
pi × qj ,
ou de fa¸con ´equivalente, (P × Q) =
mX+n
k=0
Xk
i=0
pi × qk−i
!
Xk.
Remarquez que ces formules d’apparence r´ebarbative ne font que r´esumer de fa¸con tr`es
succinte notre explication en fran¸cais, mais en aucun cas ne la rendent inutile.
Pour coder la multiplication des polynˆomes en Caml, le plus difficile est de calculer
la longueur du tableau r´esultat. On sait cependant que le monˆome de plus
haut degr´e du r´esultat a pour degr´e la somme des degr´es des monˆomes de plus haut
degr´e des polynˆomes multipli´es. Or, le degr´e du monˆome de plus haut degr´e d’un
polynˆome repr´esent´e par un tableau v de longueur l est l − 1. C’est donc, en Caml,
vect_length(v) − 1. Par exemple, le polynˆome p = x2 + 2x + 3, est repr´esent´e par
un tableau `a trois cases et son monˆome de plus haut degr´e est de degr´e 2. Mais le
monˆome de degr´e maximum du produit des polynˆomes p et q a pour degr´e la somme
des degr´es des monˆomes de degr´e maximum de p et q, soit (vect_length(p) − 1) +
(vect_length(q)−1). On en d´eduit facilement que le tableau repr´esentant p×q a pour
longueur vect_length(p) + vect_length(q) − 1.
Le programme Caml est bien plus court que ces explications :
46 Programmation imp´erative
# let multiplie_polyn^omes_pleins p q =
let produit = make_vect (vect_length p + vect_length q - 1) 0 in
for i = 0 to vect_length p - 1 do
for j = 0 to vect_length q - 1 do
produit.(i + j) <- p.(i) * q.(j) + produit.(i + j)
done
done;
produit;;
multiplie_polyn^omes_pleins : int vect -> int vect -> int vect =
Notre programme effectue sans peine le produit des polynˆomes (1 + 2x + 3x2) et
(4 + 5x + 6x2) que nous avions pr´ec´edemment calcul´e `a la main.
# imprime_polyn^ome_plein
(multiplie_polyn^omes_pleins [|1; 2; 3|] [|4; 5; 6|]);;
4 + 13x + 28x^2 + 27x^3 + 18x^4- : unit = ()
Comme exemple plus consistant, calculons (x + 1)2 puis (x + 1)4 et (x + 1)8.
# let p = [| 1; 1|] in
let p2 = multiplie_polyn^omes_pleins p p in
let p4 = multiplie_polyn^omes_pleins p2 p2 in
let p8 = multiplie_polyn^omes_pleins p4 p4 in
print_string "(x + 1) ** 2 = ";
imprime_polyn^ome_plein p2; print_newline ();
print_string "(x + 1) ** 4 = ";
imprime_polyn^ome_plein p4; print_newline ();
print_string "(x + 1) ** 8 = ";
imprime_polyn^ome_plein p8; print_newline ();;
(x + 1) ** 2 = 1 + 2x + x^2
(x + 1) ** 4 = 1 + 4x + 6x^2 + 4x^3 + x^4
(x + 1) ** 8 = 1 + 8x + 28x^2 + 56x^3 + 70x^4 + 56x^5 + 28x^6 + 8x^7 + x^8
- : unit = ()
3.5 Caract`eres et chaˆınes de caract`eres
En Caml les chaˆınes de caract`eres sont consid´er´ees comme des structures de
donn´ees physiquement modifiables : les chaˆınes se comportent essentiellement comme
des tableaux de caract`eres. On b´en´eficie ainsi d’un acc`es direct aux caract`eres et de la
possibilit´e de modifier en place les caract`eres. La syntaxe de l’affectation et de l’acc`es
aux caract`eres des chaˆınes est similaire `a celle des tableaux, avec des crochets [...] `a
la place des parenth`eses (...) :
Acc`es dans une chaˆıne s ::= s .[ indice ]
Modification d’un caract`ere d’une chaˆıne s ::= s .[ indice ] <- expression
Comme pour les tableaux, on parcourt donc compl`etement une chaˆıne de caract`eres
par une boucle for commen¸cant en 0 et finissant `a la longueur de la chaˆıne moins 1,
c’est-`a-dire string_length s−1. Par exemple, on calcule l’image miroir d’une chaˆıne
en cr´eant une chaˆıne de mˆeme longueur dont on ´ecrit tous les caract`eres `a l’aide d’une
boucle for :
Les r´ef´erences 47
# let rev_string s =
let l = string_length s in
let res = make_string l ‘ ‘ in
for i = 0 to l - 1 do
res.[i] <- s.[l - 1 - i]
done;
res;;
rev_string : string -> string =
La primitive make_string permet de cr´eer une chaˆıne de caract`eres d’une longueur
donn´ee et initialis´ee avec un caract`ere donn´e : c’est donc l’analogue de make_vect pour
les chaˆınes de caract`eres.
Au passage, cela donne une autre id´ee pour ´ecrire une version simple et lin´eaire de
la fonction palindrome de la section 2.1 :
# let palindrome s =
let r = rev_string s in
r = s;;
palindrome : string -> bool =
et mˆeme encore plus bri`evement :
# let palindrome s = rev_string s = s;;
palindrome : string -> bool =
3.6 Les r´ef´erences
Les r´ef´erences sont des structures de donn´ees pr´ed´efinies qui mod´elisent les cases
m´emoire de la machine. La propri´et´e caract´eristique des cases m´emoire est qu’on peut
les lire et les ´ecrire : la lecture renvoie leur contenu courant, l’´ecriture change ce contenu.
Les cases m´emoire sont utilis´ees pour repr´esenter des compteurs ou des accumulateurs,
dont le contenu ´evolue au cours du calcul.
Lire et ´ecrire les cases m´emoire
Poursuivant l’analogie avec les cases m´emoire, vous pouvez vous figurer une r´ef´erence
comme une boˆıte (la case m´emoire) qui contient une valeur : vous pouvez placer quelque
chose dans la boˆıte (´ecriture), ou demander `a ouvrir la boˆıte pour examiner son contenu
(lecture). Les r´ef´erences sont cr´e´ees `a l’aide de la construction ref(val), o`u val est la
valeur initialement contenue dans la r´ef´erence. D´efinissons par exemple un compteur
qui vaut initialement 0 :
# let compteur = ref 0;;
compteur : int ref = ref 0
La valeur de compteur est donc une boˆıte contenant 0, qu’on peut repr´esenter ainsi :
compteur 0
Le contenu courant d’une r´ef´erence est renvoy´e par l’op´erateur de d´er´ef´erencement,
c’est-`a-dire de lecture d’une r´ef´erence, not´e « ! ». (Il ne faut pas confondre cette notation
avec l’op´erateur “factorielle” des math´ematiques, que nous avons vu au chapitre 2, et
qui se place apr`es son argument ; le ! Caml se place avant son argument.)
48 Programmation imp´erative
# !compteur;;
- : int = 0
compteur 0
!
On change le contenu d’une r´ef´erence (´ecriture) en utilisant le symbole traditionnel de
l’affectation « := ».
# compteur := 2;;
- : unit = ()
L’affectation est, graphiquement, l’op´eration inverse de « ! » :
compteur 2
:=
Apr`es l’affectation, le contenu de la boˆıte compteur est donc 2.
# !compteur;;
- : int = 2
Pour incr´ementer compteur, nous devons ajouter 1 au contenu courant de la boˆıte :
# compteur := 1 + !compteur;;
- : unit = ()
# !compteur;;
- : int = 3
Une r`egle g´en´erale en Caml est que tous les objets du langage sont manipulables comme
des valeurs sans restrictions particuli`eres : on les passe en param`etre et on les rend en
r´esultat, au mˆeme titre que les valeurs de base. Les r´ef´erences ne d´erogent pas `a cette
r`egle. Nous pouvons donc passer des r´ef´erences en param`etre et d´efinir une proc´edure
qui incr´emente le contenu de n’importe quelle r´ef´erence contenant un entier (cette
proc´edure est pr´ed´efinie sous le nom incr dans le syst`eme Caml, mais nous en ´ecrivons
le code `a titre d’exemple). La fonction prend une r´ef´erence c en argument et modifie
son contenu (c := . . . ) pour y mettre la valeur courante de la r´ef´erence plus un (1 +
!c) :
# let incr´emente c = c := 1 + !c;;
incr´emente : int ref -> unit =
# incr´emente compteur; !compteur;;
- : int = 4
Les variables imp´eratives
Un identificateur li´e `a une r´ef´erence se comporte comme les variables des langages
imp´eratifs (C, Pascal, Ada), puisqu’on peut modifier `a volont´e le contenu de la r´ef´erence.
La seule diff´erence est qu’en Caml il faut explicitement d´er´ef´erencer l’identificateur `a
l’aide de l’op´erateur !, pour en obtenir la valeur courante ; la distinction entre l’objet
variable et la valeur courante de cet objet est donc plus nette.
Comme nous l’avions annonc´e `a la section 1.3, la d´efinition d’un nom par la construction
let est diff´erente de l’affectation d’une variable. Nous sommes maintenant en
mesure de comprendre cette diff´erence, en comparant la red´efinition d’un identificateur
par un nouveau let et l’affectation d’un identificateur li´e `a une r´ef´erence :
Un programme utilisant des r´ef´erences 49
# let x = 1;;
x : int = 1
# let f y = x + y;;
f : int -> int =
# let x = 2;;
x : int = 2
# f 0;;
- : int = 1
# let x = ref 1;;
x : int ref = ref 1
# let f y = !x + y;;
f : int -> int =
# x := 2;;
- : unit = ()
# f 0;;
- : int = 2
Dans la colonne de gauche, la red´efinition de x ne modifie en rien la valeur de x dans le
corps de la fonction f. En revanche `a droite, l’identificateur x est li´e `a une r´ef´erence. La
valeur de !x dans le corps de f change donc ´evidemment apr`es l’affectation (cependant x
est toujours li´e `a la mˆeme valeur : la mˆeme r´ef´erence). On constate ainsi que les fonctions
qui utilisent des r´ef´erences non locales sont susceptibles de changer dynamiquement de
comportement, au gr´e des affectations des r´ef´erences qu’elles emploient.
3.7 Un programme utilisant des r´ef´erences
Un exemple r´ealiste d’utilisation des r´ef´erences nous est fourni par la fonction
« factorielle », qui retourne le produit des nombres entiers inf´erieurs ou ´egaux `a son
argument. Nous en avions donn´e la d´efinition r´ecursive suivante au chapitre 2 :
n! =
(
1 si n = 0
n × (n − 1)! sinon.
Voici une autre d´efinition, dont nous admettrons qu’elle est math´ematiquement
´equivalente :
0! = 1
n! = 1 × 2 × · · · × (n − 1) × n
Cette d´efinition avec trois petits points « . . . » est allusive et se traduit g´en´eralement
par une impl´ementation sur machine `a base de boucles et d’accumulateurs. Ainsi, on
d´efinira une r´ef´erence pour accumuler les multiplications par les nombres plus petits
que n, durant l’ex´ecution d’une boucle allant de 1 `a n. `A chaque tour on multiplie le
contenu actuel de l’accumulateur par l’indice de boucle courant (accu := i * !accu),
si bien qu’`a la fin de la boucle l’accumulateur contient le r´esultat voulu ; on renvoie
donc son contenu (!accu).
# let fact n =
if n = 0 then 1 else
begin
let accu = ref 1 in
for i = 1 to n do accu := i * !accu done;
!accu
end;;
fact : int -> int =
50 Programmation imp´erative
# fact 10;;
- : int = 3628800
Une petite remarque : on peut supprimer le test if n = 0 sans changer la s´emantique
de la fonction. En effet, lorsque n est nul, la boucle s’arrˆete instantan´ement, alors que
la r´ef´erence accu vaut 1, ce qui est le r´esultat correct dans ce cas. On obtient plus
simplement :
# let fact n =
let accu = ref 1 in
for i = 1 to n do accu := i * !accu done;
!accu;;
fact : int -> int =
Cet exemple nous permet de comparer `a meilleur escient les styles imp´eratif et fonctionnel.
En effet, nous avons dˆu indiquer `a la machine la suite des op´erations `a effectuer,
en g´erant explicitement les modifications successives du contenu de l’accumulateur
accu : il s’agit vraiment ici d’un programme de style imp´eratif. En revanche, souvenezvous
de notre pr´ec´edente impl´ementation r´ecursive de la fonction factorielle :
# let rec factorielle = function
| 0 -> 1
| n -> n * factorielle (n - 1);;
factorielle : int -> int =
Dans ce cas, on a presque l’impression d’avoir recopi´e la d´efinition math´ematique !
Vous comprenez ais´ement que le style imp´eratif est plus descriptif du calcul `a effectuer
que le style fonctionnel. Le style imp´eratif d´ecrit comment faire le calcul, tandis que
le style fonctionnel d´ecrit quoi calculer. On dit que le style fonctionnel est davantage
d´eclaratif. En effet, en ´ecrivant la version fonctionnelle de fact, nous n’avons pas d´ecrit
comment faire : c’est le compilateur qui a g´er´e lui-mˆeme l’enchaˆınement des calculs.
3.8 R´ecursivit´e et boucles
Cette section montre qu’une d´efinition r´ecursive peut cacher une boucle et qu’on
peut d´efinir une fonction r´ecursive localement `a une autre fonction. Rappelons la
d´efinition de la fonction ´epelle :
# let rec ´epelle_aux s i =
if i < string_length s then
begin
print_char s.[i]; print_char ‘ ‘;
´epelle_aux s (i + 1)
end;;
´epelle_aux : string -> int -> unit =
# let ´epelle s = ´epelle_aux s 0;;
´epelle : string -> unit =
Comme dans le cas des palindromes, si vous estimez que la fonction auxiliaire
´epelle_aux n’a pas d’int´erˆet en soi, puisqu’elle ne sert qu’`a d´efinir ´epelle, rien ne
vous empˆeche de la d´efinir localement `a l’int´erieur de la fonction ´epelle :
R´ecursivit´e et boucles 51
# let ´epelle s =
let rec ´epelle_aux s i =
if i < string_length s then
begin
print_char s.[i]; print_char ‘ ‘;
´epelle_aux s (i + 1)
end in
´epelle_aux s 0;;
´epelle : string -> unit =
# ´epelle "Bonjour";;
B o n j o u r - : unit = ()
Si l’on remarque alors que la chaˆıne s ne varie jamais pendant les appels `a la fonction
´epelle_aux, on la supprime purement et simplement des arguments de ´epelle_aux (car
s est li´ee `a l’ext´erieur de ´epelle_aux par la fonction ´epelle). On obtient maintenant
# let ´epelle s =
let rec ´epelle_aux i =
if i < string_length s then
begin
print_char s.[i]; print_char ‘ ‘;
´epelle_aux (i + 1)
end in
´epelle_aux 0;;
´epelle : string -> unit =
On constate alors que la fonction ´epelle_aux n’est autre qu’une boucle for
d´eguis´ee : son premier argument est 0, son dernier argument string_length s − 1,
et ´epelle_aux augmente l’indice i de 1 `a chaque appel r´ecursif. On r´e´ecrit donc
facilement ´epelle avec une boucle for :
# let ´epelle s =
for i = 0 to string_length s - 1 do
print_char s.[i]; print_char ‘ ‘
done;;
´epelle : string -> unit =
# ´epelle "Caml";;
C a m l - : unit = ()
C’est ´evidemment le cas aussi pour compte et compte_`a_rebours :
# let compte n =
for i = 1 to n do print_int i; print_string " " done;;
compte : int -> unit =
# let compte_`a_rebours n =
for i = n downto 1 do print_int i; print_string " " done;;
compte_`a_rebours : int -> unit =
# compte 10; compte_`a_rebours 10;;
1 2 3 4 5 6 7 8 9 10 10 9 8 7 6 5 4 3 2 1 - : unit = ()
On peut donc h´esiter entre les deux styles de programmation. Chaque fois qu’une
d´efinition r´ecursive code une boucle for, il faut sans conteste employer une boucle :
les indices sont en tˆete de boucle, il n’y a pas besoin de fonction auxiliaire, c’est donc
bien plus clair. En ce qui concerne l’efficacit´e, il n’est pas clair que l’une des versions
52 Programmation imp´erative
soit meilleure que l’autre : tout d´epend du compilateur. Remarquez en particulier que
les versions r´ecursives ne font que des appels r´ecursifs terminaux, c’est-`a-dire plac´es en
fin de fonction. Ce genre d’appels r´ecursifs est tr`es bien optimis´e par les compilateurs
Caml, qui les transforment automatiquement en boucles.
Le processus de r´e´ecriture d’une fonction r´ecursive `a l’aide de boucles, que nous
avons vu ici sur des exemples, s’appelle la « d´er´ecursivation ». Cette op´eration est souvent
difficile ; essayez par exemple de d´er´ecursiver la fonction hanoi. A contrario, les
fonctions r´ecursives permettent d’´ecrire facilement les boucles les plus complexes, en
particulier lorsque la boucle comporte plusieurs sorties possibles ou lorsque l’indice ne
varie pas de fa¸con uniforme, ou simplement lorsqu’il faut retourner une valeur significative
(diff´erente de ()) `a la fin de la boucle. Cependant la r´ecursivit´e ne se limite
certainement pas `a coder des boucles : c’est un outil extrˆemement puissant, comme vous
l’avez constat´e avec le jeu de Hanoi. Nous en verrons encore beaucoup d’exemples non
triviaux dans la suite.
3.9 R`egle d’extensionnalit´e
Il nous faut faire ici une remarque importante, que nous utiliserons quelques fois.
Il s’agit d’un exemple de r`egle de calcul sur les programmes qui permet `a l’occasion
de simplifier les programmes. Ce genre de r`egles constitue l’´equivalent informatique
des r`egles de simplification des math´ematiques. Cette r`egle est tr`es facile : elle stipule
qu’il est inutile de d´efinir une fonction qui se contente d’en appeler imm´ediatement une
autre.
# let successeur x = x + 1;;
successeur : int -> int =
# let succ = function x -> successeur x;;
succ : int -> int =
La fonction succ applique imm´ediatement la fonction successeur `a son argument x ;
elle retournera donc forc´ement toujours les mˆemes valeurs que la fonction successeur :
c’est la mˆeme fonction que successeur. On dit que la fonction succ est ´egale `a la
fonction successeur. D’ailleurs, on aurait tr`es bien pu la d´efinir par :
# let succ = successeur;;
succ : int -> int =
Plus g´en´eralement on a,
Pour toute fonction f, function x -> f x est ´equivalent `a f
De la mˆeme fa¸con qu’en math´ematiques les r`egles du calcul alg´ebrique permettent de
remplacer x − x par 0, nous utiliserons la r`egle pr´ec´edente pour ´ecrire successeur au
lieu du programme function x -> successeur x. Nous aurons ainsi simplifi´e notre
programme en utilisant une r`egle universelle, sans mˆeme avoir besoin de r´efl´echir au
contenu du programme.
On se convainc facilement de la validit´e de la r`egle pr´ec´edente en remarquant que
les deux fonctions retournent toujours le mˆeme r´esultat quel que soit leur argument.
En effet, (function x -> f x) (y) s’´evalue comme f y (en rempla¸cant x par y dans
Effets et ´evaluation 53
f x). On peut ´egalement consid´erer que cette r`egle est la simple traduction de la
d´efinition math´ematique des fonctions : la fonction f est celle qui `a tout ´el´ement x
de son ensemble de d´epart fait correspondre son image par f, c’est-`a-dire f (x). La
fonction f est donc la correspondance x 7→ f(x), c’est exactement ce que traduit la
r`egle « f = function x -> f x ».
Cette r`egle est appel´ee « r`egle d’extensionnalit´e » ou encore « r`egle » (la lettre
grecque se prononce « ˆeta »). Quand on remplace f par l’expression plus complexe
function x -> f x, on dit qu’on fait une -expansion. Inversement, quand on simplifie
function x -> f x en f, on fait une -contraction. La plupart du temps, nous
emploierons la r`egle dans le sens de la simplification (-contraction).
Les conventions syntaxiques de d´efinition et d’application des fonctions se combinent
avec la r`egle pour ´etablir que :
let g x = f x ; ; est ´equivalent `a let g = f ; ;
En effet, la convention syntaxique des d´efinitions de fonctions nous permet d’´ecrire :
let g = function x -> f x au lieu de let g x = f x ; ;
Puis, en appliquant la r`egle , on simplifie function x -> f x en f et l’on obtient :
let g = f ; ;
Vous pouvez constater que nous avons ici raisonn´e sur un petit programme
ind´ependamment de sa signification : on ne sait pas ce que fait f ni pourquoi on
d´efinit g. C’est une force de connaˆıtre ce genre de raisonnements tr`es g´en´eraux qui
s’appliquent dans toutes les situations.
Nous n’irons pas plus loin dans ces consid´erations un peu complexes et formelles.
La r`egle restera notre seule r`egle de calcul sur les programmes. Son nom grec ne doit
pas effrayer, car la r`egle est intuitivement tr`es naturelle : elle stipule simplement que
la fonction qui `a x associe f(x) est la fonction f, et r´eciproquement.
3.10 Effets et ´evaluation
Cette section peut ˆetre saut´ee en premi`ere lecture.
Effets et appels de fonctions
Avec les effets, nous sortons du monde intemporel des math´ematiques pour
entrer dans un monde qui connaˆıt les notions de pass´e et d’avenir et dans lequel
l’enchevˆetrement des calculs a son importance. Pour calculer une expression sans effets
comme 1 * 2 + 3 * 4, peu importe l’ordre dans lequel on effectue les calculs : qu’on
commence par calculer 1 * 2 ou 3 * 4, le r´esultat est identique. Il n’en va pas de
mˆeme si l’on m´elange calculs et effets. Pour mettre ce ph´enom`ene en ´evidence, ajoutons
des effets dans le calcul de 1 * 2 + 3 * 4 en y mˆelant des impressions au terminal.
Rempla¸cons d’abord les nombres par des s´equences qui les impriment, par exemple
rempla¸cons 1 par (print_int 1; 1). (On doit obligatoirement parenth´eser une
s´equence pour l’inclure dans une op´eration.) Puis effectuons le calcul en commen¸cant
par l’une ou l’autre de ses sous-expressions : d’abord 1 * 2, puis 3 * 4.
54 Programmation imp´erative
# let un_fois_deux = (print_int 1; 1) * (print_int 2; 2) in
let trois_fois_quatre = (print_int 3; 3) * (print_int 4; 4) in
un_fois_deux + trois_fois_quatre;;
2143- : int = 14
# let trois_fois_quatre = (print_int 3; 3) * (print_int 4; 4) in
let un_fois_deux = (print_int 1; 1) * (print_int 2; 2) in
un_fois_deux + trois_fois_quatre;;
4321- : int = 14
On n’obtient ´evidemment pas les mˆemes impressions `a l’´ecran. Laissons le compilateur
nous d´evoiler l’ordre qu’il choisit :
# (print_int 1; 1) * (print_int 2; 2) +
(print_int 3; 3) * (print_int 4; 4);;
4321- : int = 14
Un autre compilateur aurait pu choisir un autre ordre. La conclusion de cette exp´erience
est qu’il ne faut jamais m´elanger effets et appels de fonctions, car on ne sait pas alors
d´eterminer le moment o`u les effets vont intervenir. En effet, l’ordre d’´evaluation des arguments
d’une fonction n’est pas garanti par le langage. Seules la s´equence, l’alternative
et la construction let ont un ordre d’´evaluation d´etermin´e. Ce n’est pas ´etonnant pour
la s´equence, puisque c’est son rˆole de fixer l’ordre d’´evaluation de deux expressions. Pour
l’alternative, il est clair qu’on ne peut d´ecider la branche `a choisir qu’apr`es avoir ´evalu´e
la condition. En ce qui concerne le let, on ´evalue toujours l’expression d´efinissante
d’abord : dans let x = e1 in e2 on ´evalue e1 avant e2, garantissant ainsi que la valeur
de l’identificateur x est connue pendant le calcul de l’expression e2.
Effets et r`egle
La r`egle du paragraphe pr´ec´edent stipule que l’expression (function x -> f x) est
´equivalente `a f. Nous avons pr´ecis´e que cette r`egle s’applique quand f est une fonction.
En fait, cette r`egle s’´etend facilement au cas o`u f est une expression quelconque, mais
seulement dans le cas o`u cette expression f ne produit pas d’effets. Insistons : la r`egle est
parfaitement correcte pour toute fonction f, que f produise des effets ou non. De plus
cette r`egle s’´etend `a toute expression, pourvu que cette expression ne produise aucun
effet. Il est pourtant impossible d’´etendre la r`egle `a une expression quelconque, car
certaines expressions produisant des effets l’invalident. Il est si tentant d’utiliser cette
r`egle ´etendue sans v´erifier que l’expression impartie est sans effets que nous pensons
n´ecessaire d’´etudier un exemple o`u les effets empˆechent de l’utiliser sous peine d’erreur.
D´efinissons une fonction f qui incr´emente son argument, puis retourne une fonction en
r´esultat :
# let f x = incr x; (function z -> z + 1);;
f : int ref -> int -> int =
Puis nous d´efinissons une autre fonction, g, qui appelle f avec la variable d´ej`a d´efinie
compteur. Nous prenons ´egalement bien soin de suivre l’´evolution du contenu de la
r´ef´erence compteur.
# !compteur;;
- : int = 4
Effets et ´evaluation 55
# let g y = f compteur y;;
g : int -> int =
# !compteur;;
- : int = 4
On constate que la d´efinition de g n’a pas modifi´e la valeur de compteur, ce qui semble
normal. En revanche, chaque fois qu’on appelle la fonction g avec une valeur v, on
´evalue l’expression f compteur v, si bien que la valeur de compteur est incr´ement´ee `a
chaque appel de g, ce qui semble toujours un comportement raisonnable.
# g 0;;
- : int = 1
# !compteur;;
- : int = 5
Mais supposez maintenant que nous utilisions la r`egle pour simplifier la d´efinition
de g en supprimant l’argument y. C’est bien sˆur interdit, car nous utiliserions la r`egle
avec l’expression « f compteur » qui n’est pas une fonction (c’est une application) et
qui de surcroˆıt produit des effets. Pour montrer que le comportement du programme
changerait, faisons-le tout de mˆeme, en suivant toujours soigneusement l’´evolution de
la valeur de compteur.
# let g = f compteur;;
g : int -> int =
# !compteur;;
- : int = 6
On constate que la valeur de compteur a ´et´e modifi´ee en d´efinissant g. En effet, pour
d´efinir g on applique maintenant f `a compteur et cela produit tout naturellement
un effet sur compteur pendant la d´efinition de g, puisque l’´evaluation de f compteur
provoque l’ex´ecution de la s´equence incr x; (function z -> z + 1) o`u x est li´e
`a compteur. On incr´emente donc compteur et l’on renvoie la fonction. Maintenant,
appelons g comme pr´ec´edemment :
# !compteur;;
- : int = 6
# g 0;;
- : int = 1
# !compteur;;
- : int = 6
La valeur de compteur n’est plus modifi´ee `a l’appel de g. En effet, g a maintenant pour
valeur la fonction function z -> z + 1 qui ne fait bien sˆur aucun effet sur la valeur
de compteur. Par la suite, les appels `a g n’incr´ementeront donc plus jamais compteur.
Ce comportement est dˆu `a l’effet retard induit par les param`etres de fonction : quand
on d´efinit g avec un argument explicite y, il faut attendre l’application de g `a une valeur
pour commencer l’ex´ecution du corps de g, donc l’´evaluation de f compteur y. Dans
le cas d’une fonction d´efinie sans argument (par un calcul), les effets interviennent
imm´ediatement puisqu’il n’y a aucune valeur de param`etre `a attendre.
56 Programmation imp´erative
4
Fonctionnelles et polymorphisme
O`u l’on apprend qu’il y a des fonctions qui fabriquent des
fonctions et des types qui remplacent n’importe quoi.
uoique r´eput´ees difficiles, les notions de polymorphisme et de pleine
fonctionnalit´e s’introduisent tr`es naturellement en Caml et vous constaterez
dans ce chapitre qu’elles ne sont pas si ardues. Si vous n’avez jamais entendu
parler de polymorphisme, lisez la premi`ere section. Les sections suivantes, jusqu’`a la
section 4.7, montrent le polymorphisme `a l’oeuvre dans des situations pratiques. Au
passage (section 4.3), nous ferons le point sur l’alg`ebre de types de Caml.
4.1 Notion de polymorphisme
´E
tymologiquement, polymorphe signifie plusieurs (poly) formes (morphe). On emploie
ce mot par exemple en psychologie pour parler de pervers polymorphes (pervers
qui ne sont pas fix´es sur une forme pr´ecise de perversion, ce qui est un stade normal
de d´eveloppement psychologique de l’enfant), ou bien en m´edecine pour des maladies
qui entraˆınent des symptˆomes variables, ou des virus dont l’aspect varie. En informatique,
ce terme d´esigne des objets ou des programmes qui peuvent servir sans modifi-
cations dans des contextes tr`es divers. Par exemple, une fonction de tri d’objets sera
monomorphe si elle ne s’applique qu’`a un seul type d’objets (par exemple les entiers)
et polymorphe si elle s’applique `a tous les types d’objets qu’on peut comparer pour les
ranger du plus petit au plus grand. Dans ce dernier cas, le mˆeme programme de tri
s’appliquera sans modifications `a des entiers (comparaison ≤), `a des nombres flottants
(comparaison ≤ des flottants) et `a des chaˆınes de caract`eres (ordre du dictionnaire).
Du point de vue du typage, cela signifie que la fonction de tri pourra ˆetre employ´ee
avec plusieurs types diff´erents.
Le polymorphisme n’est pas l’apanage des fonctions : certaines valeurs non fonctionnelles
peuvent aussi ˆetre utilis´ees avec plusieurs « formes », c’est-`a-dire plusieurs
types. Les exemples se trouvent du cˆot´e des structures de donn´ees comme les tableaux
et les listes : clairement, un tableau de nombres entiers ne pourra pas ˆetre employ´e avec
un autre type, mais vous admettrez facilement que le tableau vide (le tableau `a z´ero
´el´ement) peut ˆetre vu comme un tableau d’entiers aussi bien que comme un tableau
58 Fonctionnelles et polymorphisme
de chaˆınes. Nous allons nous int´eresser d’abord aux fonctions polymorphes, parce que
c’est dans le domaine des fonctions que cette notion est la plus naturelle et la plus facile
`a appr´ehender.
Pour exprimer le polymorphisme dans les expressions de types, nous avons besoin
d’une notion de types qui puissent remplacer plusieurs types diff´erents : ce sont les
param`etres de type, qu’on distingue syntaxiquement des types ordinaires en les faisant
pr´ec´eder d’une apostrophe (’). Par exemple, ’a est un param`etre de type nomm´e a.
Le polymorphisme de Caml est techniquement qualifi´e de param´etrique. Intuitivement
cela signifie que ce polymorphisme fonctionne en « tout ou rien ». La signification
d’un param`etre de type est de remplacer n’importe quel autre type et non pas un certain
nombre d’autres types. On n’aura donc pas de programmes Caml uniquement valables
pour un ensemble d´etermin´e de types. Par exemple, il n’y a aucun moyen de d´efinir
une fonction qui s’appliquerait uniquement `a des entiers et des chaˆınes de caract`eres
(et qui aurait donc un type du genre (int ou string) -> ...) Un programme Caml
s’applique soit `a tous les types possibles, soit `a un seul et unique type. Dans le premier
cas le type du programme comporte un param`etre (par exemple ’a -> ...), dans le
second cas il n’en comporte pas (par exemple int -> ...). Voyons un premier exemple :
# let successeur x = x + 1;;
successeur : int -> int =
La fonction est monomorphe, comme on s’y attend : elle ne s’applique qu’`a des entiers,
puisqu’on doit faire une addition avec son argument. Mais supposons qu’on supprime
l’addition qui entraˆıne cette contrainte sur l’argument x et qu’on renvoie directement
1.
# let fonction_un x = 1;;
fonction_un : ’a -> int =
La fonction fonction_un est maintenant polymorphe : elle ne fait rien de son argument,
on peut donc l’appliquer `a n’importe quoi.
# fonction_un 2;;
- : int = 1
# fonction_un "oui";;
- : int = 1
# fonction_un true;;
- : int = 1
Contrairement `a ce que sugg`ere l’exemple fonction_un, une fonction polymorphe peut
utiliser son argument, par exemple en le renvoyant tel quel. Nous supprimons encore
une fois l’addition dans le code de successeur, mais cette fois nous renvoyons x au lieu
de 1 :
# let identit´e x = x;;
identit´e : ’a -> ’a =
Nous obtenons encore une fonction polymorphe. Notez que le type de la fonction
identit´e indique `a juste titre que le type du r´esultat est exactement celui de
l’argument. Le param`etre ’a remplace n’importe quel type, en particulier string ou
int, l´egitimant ainsi l’emploi de identit´e avec le type string -> string, et aussi
avec le type int -> int :
# identit´e "non";;
- : string = "non"
# identit´e 1;;
- : int = 1
Fonctions d’ordre sup´erieur 59
Ce m´ecanisme de remplacement d’un param`etre de type par un type quelconque
s’appelle la sp´ecialisation. Nos deux exemples consistent donc `a sp´ecialiser ’a en
string, puis en int. On n’est pas oblig´e de sp´ecialiser un param`etre avec un type de
base, comme nous l’avons fait jusqu’`a pr´esent ; on le sp´ecialise tout aussi bien avec
un type complexe, par exemple int -> int. Dans le cas de la fonction identit´e, on
obtient le type (int -> int) -> (int -> int). Cela sugg`ere d’appeler la fonction
identit´e sur un argument qui est lui-mˆeme une fonction ; et pourquoi pas la fonction
successeur ?
# identit´e successeur;;
- : int -> int =
La fonction identit´e renvoie toujours son argument sans modification ; elle renvoie
donc tout simplement la fonction successeur quand on l’applique `a successeur. Par
exemple :
# let success = identit´e successeur;;
success : int -> int =
# success 3;;
- : int = 4
4.2 Fonctions d’ordre sup´erieur
Les fonctions d’ordre sup´erieur sont des fonctions dont les arguments ou les r´esultats
sont eux-mˆemes des fonctions. Une fonction d’ordre sup´erieur est encore appel´ee une
fonctionnelle. Ces fonctions sont souvent polymorphes et surtout employ´ees avec des
structures de donn´ees plus complexes que les types de base. Il n’est pas n´ecessaire de
tout connaˆıtre sur le polymorphisme et les fonctions d’ordre sup´erieur pour les utiliser.
Pour le lecteur plus int´eress´e par les programmes que par la th´eorie, il suffit donc de
lire cette section pour comprendre le reste des exemples de ce livre.
Nous commencerons par les fonctions qui renvoient d’autres fonctions, puis nous
verrons les fonctions dont les arguments sont fonctionnels. Les exemples pr´esent´es ici
seront sans doute un peu artificiels, puisque nous ne disposons pas encore des outils
suffisants pour montrer des utilisations r´ealistes de fonctionnelles sur des structures de
donn´ees complexes.
Fonctions retournant des fonctions
Supposez que nous voulions d´efinir la fonction fois_x qui, ´etant donn´e un entier x,
fabrique la fonction qui multipliera par x. La d´efinition en pseudo-code Caml serait :
let fois_x (x) = « la fonction qui multiplie par x »;;
Nous ´ecrivons donc du vrai code pour la p´eriphrase « la fonction qui multiplie par x » :
# let fois_x (x) = (function y -> x * y);;
fois_x : int -> int -> int =
La fonction fois_x est une fonctionnelle : quand on l’applique `a un argument elle
fabrique une fonction qu’elle renvoie en r´esultat ! Ainsi, on obtient la multiplication par
2 en appliquant fois_x `a 2.
60 Fonctionnelles et polymorphisme
# let double = fois_x (2);;
double : int -> int =
# double (3);;
- : int = 6
On constate ainsi qu’on a d´efini la fonction double non pas en donnant les arguments
et le corps de la fonction (par la construction function), mais par un calcul : nous
avons calcul´e une fonction. Il n’est d’ailleurs mˆeme pas n´ecessaire de donner un nom `a
la fonction double pour calculer double (3) : nous pouvons directement appliquer la
fonction calcul´ee fois_x (2) `a la valeur 3.
# (fois_x (2)) (3);;
- : int = 6
La syntaxe de Caml autorise une ´ecriture encore simplifi´ee de cette expression, sans
aucune parenth`ese. Rappelons que les conventions syntaxiques pour l’application des
fonctions en Caml stipulent en effet que
• f x est lu comme f (x)
• f x y est lu comme (f x) y.
En employant la premi`ere r`egle on obtient d’abord (fois_x 2) 3, puis en appliquant
la seconde, on obtient la forme la plus simple fois_x 2 3.
# fois_x 2 3;;
- : int = 6
Fonctions dont les arguments sont des fonctions
Faisons un pas de plus : d´efinissons une fonction avec un argument fonctionnel.
Par exemple, la fonctionnelle double_le_r´esultat_de qui double le r´esultat
de sa fonction argument : ´etant donn´es une fonction f et un argument x pour f,
double_le_r´esultat_de retourne la valeur 2 * f(x), c’est-`a-dire double (f x).
# let double_le_r´esultat_de (f : int -> int) =
function x -> double (f x);;
double_le_r´esultat_de : (int -> int) -> int -> int =
Avec cette fonctionnelle nous pouvons `a nouveau calculer des fonctions. Par exemple, la
fonction qui retourne le double du successeur de son argument, function x -> 2 * (x
+ 1), se calcule en appliquant la fonctionnelle double_le_r´esultat_de `a la fonction
successeur. C’est un calcul tout `a fait normal, si ce n’est qu’il implique des fonctions
et que le r´esultat est en fait une fonction.
# let double_du_successeur = double_le_r´esultat_de successeur;;
double_du_successeur : int -> int =
# double_du_successeur 3;;
- : int = 8
Typage et polymorphisme 61
La fonctionnelle « sigma »
`A
l’occasion de la d´efinition des op´erations sur les polynˆomes, nous avons vu la
notation math´ematique , d´efinie par :
Xn
i=0
formule (i) = formule (0) + formule (1) + · · · + formule (n).
Avec le vocabulaire des langages fonctionnels, la notation n’est rien d’autre qu’une
fonctionnelle qui prend en argument une fonction repr´esentant formule et l’applique
successivement `a 0, 1, . . . , n. Il est tr`es facile de d´efinir cette fonctionnelle en Caml, `a
l’aide d’une boucle et d’un accumulateur :
# let sigma formule n =
let r´esultat = ref 0 in
for i = 0 to n do r´esultat := !r´esultat + formule (i) done;
!r´esultat;;
sigma : (int -> int) -> int -> int =
ou mˆeme `a l’aide d’une fonction r´ecursive
# let rec sigma formule n =
if n <= 0 then 0 else formule n + sigma formule (n - 1);;
sigma : (int -> int) -> int -> int =
Nous pouvons maintenant faire calculer par Caml les exemples que nous avions
donn´es. Si la formule est r´eduite `a i, on obtient la somme des nombres de 0 `a n :
Xn
i=0
i = 0 + 1 + · · · + n.
Cette formule correspond `a appeler la fonctionnelle sigma avec l’argument (function
i -> i).
# sigma (function i -> i) 10;;
- : int = 55
# sigma identit´e 10;;
- : int = 55
De mˆeme la somme des carr´es des nombres entre 0 et n,
Xn
i=0
i2 = 02 + 12 + · · · + n2,
s’obtient par application de sigma `a l’argument (function i -> i * i).
# sigma (function i -> i * i) 10;;
- : int = 385
4.3 Typage et polymorphisme
Synth`ese du type le plus g´en´eral
Comme nous l’avons d´ej`a dit, le compilateur de Caml donne un type `a chaque phrase
entr´ee par l’utilisateur ; cette inf´erence de types ne n´ecessite aucune participation de
62 Fonctionnelles et polymorphisme
l’utilisateur : elle se produit automatiquement sans n´ecessit´e d’indiquer les types dans
les programmes. Connaissant les types des valeurs de base et des op´erations primitives,
le contrˆoleur de types produit un type pour une phrase en suivant des r`egles de typage
pour les constructions du langage comme la d´efinition et l’application des fonctions.
De plus, le type inf´er´e contient le plus petit ensemble de contraintes n´ecessaires au bon
d´eroulement de l’ex´ecution du programme (ici, « bon d´eroulement » signifie qu’il n’y
aura pas d’erreurs de type `a l’ex´ecution). On dit que le contrˆoleur de type trouve le
type le plus g´en´eral de chaque expression (notion introduite par Robin Milner en 1978).
Par exemple, la fonction successeur re¸coit le type int -> int parce que son argument
doit ˆetre un entier, puisqu’on lui ajoute 1. En revanche la fonction identit´e a le type
’a -> ’a parce qu’il n’y a pas de contrainte sur son argument. Le polymorphisme
s’introduit donc naturellement `a partir de l’absence de contraintes sur le type d’un
argument ou d’une valeur. Par exemple, rappelons la d´efinition de la fonctionnelle
double_le_r´esultat_de :
# let double_le_r´esultat_de (f : int -> int) =
function x -> double (f x);;
double_le_r´esultat_de : (int -> int) -> int -> int =
L’argument f devait ˆetre une fonction des entiers vers les entiers, `a cause de la contrainte
de type (f : int -> int), explicitement ´ecrite dans le programme. Mais si nous
retirons cette contrainte de type, nous obtenons une fonctionnelle plus g´en´erale :
# let double_le_r´esultat_de f = function x -> double (f x);;
double_le_r´esultat_de : (’a -> int) -> ’a -> int =
La fonctionnelle devient polymorphe, car le contrˆoleur de type a d´ecouvert que f devait
seulement renvoyer un entier en r´esultat, mais qu’il n’est nullement obligatoire qu’elle
prenne un entier en argument. Voici un exemple o`u f re¸coit une chaˆıne de caract`eres :
# let double_de_la_longueur = double_le_r´esultat_de string_length;;
double_de_la_longueur : string -> int =
# double_de_la_longueur "Caml";;
- : int = 8
Le polymorphisme d´ecoule donc de l’absence de contraintes sur une valeur. Cela
explique pourquoi un param`etre de type peut ˆetre remplac´e sans risque d’erreurs par
n’importe quel type, y compris un type lui-mˆeme polymorphe. Par exemple, on applique
la fonction identit´e `a elle-mˆeme en l’employant avec le type (’a -> ’a) -> (’a ->
’a) :
# let id x = (identit´e identit´e) x;;
id : ’a -> ’a =
Puisque la fonction identit´e renvoie toujours son argument, (identit´e identit´e)
s’´evalue en identit´e, et la fonction id est donc tout simplement ´egale `a la fonction
identit´e.
L’alg`ebre des types de Caml
Nous allons maintenant pr´eciser davantage l’ensemble des types qu’utilise le syst`eme
Caml, ce qu’on nomme techniquement son alg`ebre des types. Tout type Caml entre dans
l’une des cat´egories suivantes :
Typage et polymorphisme 63
• Types de base (comme int ou string).
• Types composites (comme int -> int ou int vect).
• Param`etres de type (comme ’a).
Les types composites sont construits avec des constructeurs de types, tels que la
fl`eche ->. ´Etant donn´es deux types t1 et t2, le constructeur de type fl`eche construit le
type t1 -> t2, qui est le type des fonctions ayant un argument du type t1 et rendant
un r´esultat du type t2, autrement dit les fonctions de t1 dans t2. Remarquons que le
constructeur fl`eche est un op´erateur binaire (deux arguments) et infixe (situ´e entre
ses arguments, comme l’est le symbole de l’addition +). En revanche, le constructeur
de types vect est unaire, puisqu’`a partir d’un unique type t1, il construit le type
t1 vect. Ce constructeur est postfixe, c’est-`a-dire plac´e apr`es son argument. Tous les
constructeurs de types unaires sont postfix´es en Caml. Par extension, les types n’ayant
pas d’arguments (int par exemple) sont appel´es constructeurs de types constants.
Les paires
Il existe un autre constructeur de type binaire et infixe dont nous n’avons pas encore
parl´e : le constructeur pr´ed´efini « * ». ´Etant donn´es deux types t1 et t2, la notation t1 * t2
est donc un type. C’est le produit cart´esien des types t1 et t2. Il d´enote le type des
couples d’un ´el´ement du type t1 avec un ´el´ement du type t2. En math´ematiques, le
produit cart´esien de deux ensembles A et B est l’ensemble des couples (x, y) tels que
x est ´el´ement de A et y ´el´ement de B. Le produit cart´esien de A et B est not´e A × B.
Cette analogie avec la notation de la multiplication est aussi employ´ee en Caml, d’o`u
le symbole * dans les types.
Les valeurs de types produit se notent comme en math´ematiques : on ´ecrit les deux
´el´ements du couple entre parenth`eses et s´epar´es par une virgule. Une petite diff´erence
d’appellation cependant : en informatique on parle plus volontiers de paires que de
couples. De plus, en Caml, les parenth`eses autour des paires ne sont pas toujours
strictement n´ecessaires.
# (1, 2);;
- : int * int = 1, 2
Les paires sont aussi utilis´ees en tant qu’arguments ou r´esultats de fonctions.
# let addition (x, y) = x + y;;
addition : int * int -> int =
# addition (1, 2);;
- : int = 3
`A
l’aide de paires, on ´ecrit des fonctions qui rendent plusieurs r´esultats. Par exemple,
la fonction suivante calcule simultan´ement le quotient et le reste d’une division enti`ere :
# let quotient_reste (x, y) = ((x / y), (x mod y));;
quotient_reste : int * int -> int * int =
# quotient_reste (5, 3);;
- : int * int = 1, 2
Les notations pour les paires se g´en´eralisent aux triplets, aux quadruplets, et en fait
aux n-uplets pour n’importe quel nombre d’´el´ements n. Par exemple, (1, 2, 3) est
un triplet d’entiers et poss`ede le type int * int * int.
64 Fonctionnelles et polymorphisme
4.4 Curryfication
`A
proprement parler, une fonction prenant une paire comme argument ne poss`ede
quand mˆeme qu’un seul argument et non pas deux. La fonction addition ci-dessus,
qui prend un seul argument qui se trouve ˆetre une paire, est diff´erente de la fonction
add suivante, qui prend deux arguments.
# let add x y = x + y;;
add : int -> int -> int =
Du point de vue pratique, la diff´erence est minime, il est vrai. D’un point de vue technique,
une fonction qui re¸coit ses arguments un par un (comme add) est dite curryfi´ee.
En revanche, une fonction qui re¸coit tous ses arguments `a la fois sous la forme d’une
paire ou plus g´en´eralement d’un n-uplet de valeurs est dite non curryfi´ee. Le n´eologisme
« curryfier » n’est pas une allusion `a la cuisine indienne, mais un hommage au logicien
Haskell Curry.
Application partielle
La diff´erence essentielle entre add et addition tient dans la mani`ere de les appliquer
: il est l´egal d’appliquer la fonction add `a un seul argument, obtenant ainsi une
fonction comme r´esultat, tandis que la fonction addition doit forc´ement recevoir ses
deux entiers en mˆeme temps. Cette capacit´e des fonctions curryfi´ees de ne recevoir
qu’un certain nombre de leurs arguments permet l’application partielle. Par exemple,
en appliquant (partiellement) add `a l’entier 1, on obtient la fonction successeur.
# let successeur = add 1;;
successeur : int -> int =
# successeur 3;;
- : int = 4
Curryfication et type fl`eche
Une fonction curryfi´ee est donc un cas particulier de fonctionnelle, puisqu’elle permet
de cr´eer d’autres fonctions, en fixant certains de ses arguments. Cette propri´et´e
est en fait inscrite dans le type d’une fonction curryfi´ee. Par exemple, le type de add
est int -> int -> int. Or, le constructeur de type -> associe `a droite, ce qui signifie
que le type de add n’est autre que int -> (int -> int). Cette ´ecriture explicitement
parenth´es´ee indique clairement que add est une fonctionnelle : ´etant donn´e un entier,
add retourne une autre fonction dont le type est justement (int -> int). Cela paraˆıt
difficile `a comprendre au premier abord, mais c’est simplement une autre mani`ere de
voir des phrases aussi simple que « ajouter 2 au r´esultat pr´ec´edent », qui signifie en
fait : utiliser l’addition avec l’un des arguments fix´e `a 2 et appliquer cette fonction au
r´esultat pr´ec´edent. En Caml, cela correspondrait `a ´evaluer :
(add 2) (« r´esultat pr´ec´edent »);;
Une autre approche f´econde est de consid´erer add comme une fonction g´en´erique, qui
permet d’obtenir la famille de toutes les fonctions qui ajoutent une constante `a leur
argument (et qui sont donc de type int -> int). Par exemple, la fonction add_3, qui
ajoute 3 `a son argument, est d´efinie par :
Une fonctionnelle de tri polymorphe 65
# let add_3 = add 3;;
add_3 : int -> int =
L’application partielle d’une fonction curryfi´ee pour fixer certains de ces arguments se
justifie lorsque la fonction est tr`es g´en´erale. Dans ce cas, cette op´eration de sp´ecialisation
permet de retrouver des fonctions int´eressantes en elles-mˆemes. Nous en verrons un
exemple avec le tri, o`u fixer l’argument fonctionnel correspondant `a la comparaison
permet de d´efinir le tri en ordre croissant ou le tri en ordre d´ecroissant.
De cette ´etude des fonctions curryfi´ees, retenons que le constructeur de type → est
associatif `a droite, ce qui signifie tout simplement que :
t1 → t2 → t3 est ´equivalent `a t1 → (t2 → t3)
4.5 Une fonctionnelle de tri polymorphe
Le polymorphisme n’est pas r´eserv´e au style fonctionnel. Pour le montrer, nous
d´efinissons ici une proc´edure qui trie en place un tableau. La proc´edure ne calcule pas
de valeurs, mais modifie l’ordre des ´el´ements dans le tableau. Nous g´en´eralisons ensuite
cette proc´edure pour la rendre applicable `a tout type d’ordre.
Trier des tableaux en ordre croissant
L’algorithme de tri employ´e ici repose sur une id´ee tr`es simple : on cherche le minimum
des ´el´ements du tableau et on le met `a la premi`ere place. Puis on cherche le minimum
du reste du tableau et on le met `a la seconde place. Il suffit d’it´erer ce proc´ed´e
jusqu’`a avoir parcouru compl`etement le tableau. Ce tri s’appelle le tri par s´election.
Son principe s’illustre graphiquement par le sch´ema suivant, qui montre la ii`eme ´etape
du tri par s´election, consistant `a d´eplacer t.(j) en t.(i), o`u j est l’indice tel que t.(j)
est le plus petit des ´el´ements t.(i), t.(i + 1), . . .
t
0 i − 1 i j
t.(j) est le minimum `a partir de i
vect_length(t)−1
d´efinitivement en place
z }| {
Pour traduire cet algorithme en Caml, nous avons besoin d’une proc´edure auxiliaire
qui se charge d’´echanger deux ´el´ements dans un tableau. Il est bien connu que
cette tˆache pr´esente une petite difficult´e : il faut garder une copie d’un des ´el´ements,
puisqu’on perd cet ´el´ement quand on ´ecrit l’autre `a sa place. Cela m´erite bien une
proc´edure ind´ependante de la fonction de tri. La proc´edure d’´echange est naturellement
polymorphe : elle peut s’appliquer `a tout type de tableau puisqu’elle effectue une
op´eration ind´ependante de la nature des ´el´ements du tableau.
# let ´echange t i j = (* ´echange les ´el´ements i et j de t *)
let ´el´ement_i = t.(i) in
t.(i) <- t.(j);
66 Fonctionnelles et polymorphisme
t.(j) <- ´el´ement_i;;
´echange : ’a vect -> int -> int -> unit =
Il n’y a plus de difficult´e `a ´ecrire en Caml le tri par s´election :
# let tri t =
for i = 0 to vect_length t - 2 do
let min = ref i in
for j = i + 1 to vect_length t - 1 do
if t.(j) <= t.(!min) then min := j
done;
´echange t i !min
done;;
tri : ’a vect -> unit =
G´en´eralisation `a tout type d’ordre
Pour rendre cette proc´edure polymorphe encore plus g´en´erale, il suffit de remarquer
que c’est l’emploi de la primitive <= pour comparer les ´el´ements du tableau qui impose
le rangement par ordre croissant. Il suffit donc de passer la fonction de comparaison
en argument pour trier selon toute sorte d’ordres. Lorsqu’on passe ainsi en argument
une fonction utilis´ee dans le corps d’une d´efinition, on dit qu’on « abstrait » la fonction.
Dans le cas du tri on abstrait donc la comparaison et la fonction tri prend alors un
argument suppl´ementaire, ordre, une fonction `a deux arguments x et y renvoyant true
si x est inf´erieur ou ´egal `a y et false sinon (ces fonctions sont appel´ees pr´edicats).
# let tri ordre t =
for i = 0 to vect_length t - 2 do
let min = ref i in
for j = i + 1 to vect_length t - 1 do
if ordre t.(j) t.(!min) then min := j
done;
´echange t i !min
done;;
tri : (’a -> ’a -> bool) -> ’a vect -> unit =
Trions par ordre croissant ou d´ecroissant un tableau d’entiers, en changeant simplement
l’ordre :
# let t = [|3; 1; 2|] in
tri (function x -> function y -> x <= y) t; t;;
- : int vect = [|1; 2; 3|]
# let t = [|3; 1; 2|] in
tri (function x -> function y -> x >= y) t; t;;
- : int vect = [|3; 2; 1|]
Ce n’est pas plus difficile pour les tableaux de chaˆınes de caract`eres, en utilisant les
fonctions pr´ed´efinies de comparaison ge_string (sup´erieur ou ´egal sur les chaˆınes) ou
le_string (inf´erieur ou ´egal), qui comparent deux chaˆınes dans l’ordre lexicographique,
c’est-`a-dire l’ordre du dictionnaire.
# let t = [|"Salut "; "les "; "copains!"|] in
tri (function x -> function y -> ge_string x y) t; t;;
- : string vect = [|"les "; "copains!"; "Salut "|]
La pleine fonctionnalit´e 67
# let t = [|"Salut "; "les "; "copains!"|] in
tri (function x -> function y -> le_string x y) t; t;;
- : string vect = [|"Salut "; "copains!"; "les "|]
On constate sur cet exemple que les lettres majuscules pr´ec`edent les lettres minuscules
dans l’ordre lexicographique utilis´e en Caml. Nous pouvons maintenant appliquer partiellement
la proc´edure tri `a des ordres habituels, pour obtenir des proc´edures de tri
sp´ecialis´ees :
# let tri_croissant t = tri (function x -> function y -> x <= y) t;;
tri_croissant : ’a vect -> unit =
# let tri_d´ecroissant t = tri (function x -> function y -> x >= y) t;;
tri_d´ecroissant : ’a vect -> unit =
# let tri_du_dictionnaire = tri le_string;;
tri_du_dictionnaire : string vect -> unit =
# let t = [| "Bonjour"; "tout"; "le"; "monde" |] in
tri_du_dictionnaire t; t;;
- : string vect = [|"Bonjour"; "le"; "monde"; "tout"|]
En conclusion, nous avons pu d´efinir une proc´edure de tri tr`es g´en´erale : grˆace au
polymorphisme, cette proc´edure s’applique `a tout type de tableau ; grˆace `a la pleine
fonctionnalit´e, elle s’applique `a tout type d’ordre. On retrouve les proc´edures de tri
habituelles en sp´ecialisant certains param`etres de la proc´edure g´en´erale.
4.6 La pleine fonctionnalit´e
Nous avons vu que les fonctions peuvent ˆetre pass´ees en arguments ou rendues
en r´esultat, comme toutes les autres donn´ees. Plus ´etonnant encore, on les manipule
comme des valeurs ordinaires `a l’int´erieur des structures de donn´ees. Nous ´etudions
maintenant un exemple qui nous am`ene tr`es naturellement `a utiliser des tableaux de
fonctions.
Menu `a deux cas
Notre but est d’´ecrire une fois pour toutes une proc´edure qui affiche un menu, lit le
choix de l’utilisateur et lance l’option correspondante du menu. Pour simplifier, nous
nous restreignons dans un premier temps aux menus qui offrent exactement deux possibilit
´es. La proc´edure prend donc quatre arguments : deux messages d’invite `a afficher et
deux proc´edures correspondantes. Apr`es avoir affich´e le menu, elle lit l’option retenue
par l’utilisateur `a l’aide de la fonction pr´ed´efinie read_int, qui lit un entier tap´e au
clavier, puis appelle l’option correspondante, en testant la r´eponse de l’utilisateur.
# let menu invite1 option1 invite2 option2 =
print_string ("<0>: " ^ invite1); print_string " ";
print_string ("<1>: " ^ invite2); print_newline ();
print_string "Choisissez votre option: ";
let r´eponse = read_int () in
if r´eponse = 0 then option1 () else option2 ();;
menu : string -> (unit -> ’a) -> string -> (unit -> ’a) -> ’a =
68 Fonctionnelles et polymorphisme
Pour nos essais, nous d´efinissons deux petites proc´edures qui impriment simplement un
message au terminal :
# let au_revoir () = print_string "Au revoir"; print_newline ();;
au_revoir : unit -> unit =
# let continuer () = print_string "Continuons!"; print_newline ();;
continuer : unit -> unit =
Nous obtenons alors le dialogue suivant :
# menu "Arr^eter" au_revoir
"Continuer" continuer;;
<0>: Arr^eter <1>: Continuer
Choisissez votre option: 1
Continuons!
- : unit = ()
Menu `a plusieurs cas
Pour g´en´eraliser la proc´edure pr´ec´edente `a un nombre quelconque d’options, il suffit
de lui passer deux tableaux en arguments : un tableau de chaˆınes de caract`eres pour les
messages d’invite et un tableau de proc´edures pour les options. Il faut maintenant ´ecrire
le menu avec une boucle for parcourant le tableau des messages, puis lire l’option choisie
par l’utilisateur et s´electionner la proc´edure correspondante du tableau des options.
# let menu invites options =
for i = 0 to vect_length invites - 1 do
print_string
("<" ^ (string_of_int i) ^ ">: " ^ invites.(i) ^ " ")
done;
print_newline ();
print_string "Choisissez votre option: ";
let r´eponse = read_int () in
options.(r´eponse) ();;
menu : string vect -> (unit -> ’a) vect -> ’a =
La fonction pr´ed´efinie string_of_int renvoie la chaˆıne de caract`eres correspondant `a
son argument entier.
`A
titre d´emonstratif, nous appelons la proc´edure avec une troisi`eme option qui consiste
`a ne rien faire : la proc´edure associ´ee est simplement la fonction identit´e (sp´ecialis´ee
au type unit) que nous fournissons comme une fonction anonyme.
# menu [| "Arr^eter"; "Continuer"; "Ne rien faire" |]
[| au_revoir; continuer; (function () -> ()) |];;
<0>: Arr^eter <1>: Continuer <2>: Ne rien faire
Choisissez votre option 2
- : unit = ()
Utiliser les types pour ´eviter les erreurs
Fournir deux tableaux distincts pour les options et les messages d’invite est source
d’erreurs, puisque le typage n’assure pas la correspondance entre l’invite et l’option. La
correction est ais´ee : il suffit de n’utiliser qu’un seul tableau contenant des paires dont
La pleine fonctionnalit´e 69
le premier ´el´ement est un message d’invite et le second l’option associ´ee. Cet exemple
nous am`ene `a d´efinir les fonctions d’acc`es aux composantes d’une paire, traditionnellement
nomm´ees fst (pour first, qui signifie « premier » en anglais) et snd (pour second,
« second »). Bien que ces fonctions soient pr´ed´efinies en Caml, nous ´ecrivons leur code
car il est ´el´egant. On op`ere tout simplement par filtrage de la paire argument :
# let fst (x, y) = x;;
fst : ’a * ’b -> ’a =
# let snd (x, y) = y;;
snd : ’a * ’b -> ’b =
Une fois de plus, le polymorphisme nous autorise `a d´efinir ces deux fonctions pour tous
les types de paires. La fonction menu est maintenant sans surprises.
# let menu invites_options =
for i = 0 to vect_length invites_options - 1 do
print_string ("<" ^ (string_of_int i) ^ ">: ");
print_string (fst (invites_options.(i)) ^ " ")
done;
print_newline ();
print_string "Choisissez votre option: ";
let r´eponse = read_int () in
(snd (invites_options.(r´eponse))) ();;
menu : (string * (unit -> ’a)) vect -> ’a =
# menu [| ("Arr^eter", au_revoir);
("Continuer", continuer);
("Ne rien faire", (function () -> ())) |];;
<0>: Arr^eter <1>: Continuer <2>: Ne rien faire
Choisissez votre option: 0
Au revoir
- : unit = ()
Un menu polymorphe tr`es g´en´eral
R´efl´echissons encore un peu sur la proc´edure menu : la quintessence de cette
proc´edure n’est pas d’appliquer directement les options, mais plutˆot de retourner
un certain ´el´ement d’un tableau d’options, selon la r´eaction de l’utilisateur aux
propositions affich´ees. Un pas de plus dans la g´en´eralisation consiste donc `a ne pas
consid´erer que les options doivent forc´ement ˆetre des proc´edures. On se contente alors
de retourner le deuxi`eme ´el´ement du couple correspondant au message d’invite choisi
par l’utilisateur.
# let menu invites_options =
for i = 0 to vect_length invites_options - 1 do
print_string ("<" ^ (string_of_int i) ^ ">: ");
print_string (fst (invites_options.(i)) ^ " ");
print_string " "
done;
print_newline ();
print_string "Choisissez votre option";
let r´eponse = read_int () in
snd (invites_options.(r´eponse));;
70 Fonctionnelles et polymorphisme
menu : (string * ’a) vect -> ’a =
Ainsi, la proc´edure menu retourne aussi bien des entiers que des fonctions. Voici par
exemple un morceau de programme qui d´eterminerait le niveau de difficult´e `a prendre
en compte dans un jeu. Ici la fonction menu retourne un entier.
# let niveau_de_difficult´e =
print_string "^Etes-vous"; print_newline ();
menu [| ("D´ebutant ?", 1);
("Amateur ?", 2);
("Amateur confirm´e ?", 5);
("Expert ?", 10) |];;
^Etes-vous
<0>: D´ebutant ? <1>: Amateur ? <2>: Amateur confirm´e ? <3>: Expert ?
Choisissez votre option: 0
niveau_de_difficult´e : int = 1
Nous avons cependant toujours le loisir d’appeler menu avec des options fonctionnelles.
# let option =
menu [| ("Arr^eter", au_revoir);
("Continuer", continuer);
("Ne rien faire", (function () -> ())) |] in
option ();;
<0>: Arr^eter <1>: Continuer <2>: Ne rien faire
Choisissez votre option: 0
Au revoir
- : unit = ()
Il est bien entendu que la fonction menu reste na¨ıve : il lui faudrait tester la validit´e
de la r´eponse de l’utilisateur et l’interroger `a nouveau en cas d’erreur. La validation
de la r´eponse pourrait s’effectuer `a l’aide d’une fonction, argument suppl´ementaire de
menu. On peut aussi envisager de lire des chaˆınes de caract`eres au lieu de nombres
(par exemple "oui" ou "non"). Il n’en demeure pas moins que le polymorphisme et la
pleine fonctionnalit´e nous permettent d’´ecrire une fonction tr`es g´en´erale dans laquelle
les probl`emes de mise en page des menus, d’obtention d’une r´eponse et de validation
de la r´eponse obtenue seront factoris´es une fois pour toutes.
Vous en savez maintenant assez pour passer au chapitre suivant. Ce qui suit est
´etonnant mais technique. En particulier, nous verrons que le langage est assez puissant
pour d´efinir un moyen automatique de passer de la version curryfi´ee `a la version non
curryfi´ee d’une fonction.
4.7 Composition de fonctions
En utilisant des fonctionnelles, on parvient `a programmer des notions math´ematiques
qui paraissent a priori hors de port´ee d’une machine. Pour les lecteurs f´erus de
math´ematiques, nous allons ´etudier un exemple surprenant : la composition des fonctions.
Il est non seulement possible de d´efinir la composition de deux fonctions donn´ees
en Caml, mais mˆeme d’´ecrire un programme qui impl´emente le fameux op´erateur « ◦ ».
Rappelons que composer deux fonctions revient `a les appliquer successivement : la
compos´ee des fonctions f et g, qu’on note f ◦ g en math´ematiques (prononcer « f rond
g »), est la fonction h d´efinie par h(x) = f(g(x)). On fait souvent le sch´ema suivant :
Composition de fonctions 71
A
B
C
×x
×
y = g (x)
×
z = f (y)
= f (g (x))
g f
f ◦ g
Ainsi, l’op´erateur ◦ des math´ematiques est une fonctionnelle qui prend deux fonctions
en arguments et renvoie une fonction : leur compos´ee. Il n’y a pas de difficult´es `a d´efinir
l’op´erateur ◦ en Caml ; nous l’impl´ementons sous le nom de compose.
# let compose f g = function x -> f (g x);;
compose : (’a -> ’b) -> (’c -> ’a) -> ’c -> ’b =
Le type de la fonction compose refl`ete fid`element les restrictions qu’on doit imposer
`a deux fonctions pour pouvoir effectivement les composer. D’ailleurs, ces restrictions
apparaissent dans notre sch´ema : il faut que l’ensemble de d´epart de la fonction f soit
le mˆeme que l’ensemble d’arriv´ee de la fonction g. De plus, par d´efinition, la compos´ee
f ◦ g de f et de g a pour ensemble de d´epart celui de g et pour ensemble d’arriv´ee
celui de f. On le constate graphiquement, si l’on ne fait figurer dans le sch´ema de la
composition que les ensembles et les fonctions qui interviennent (sch´ema ci-dessous `a
gauche). Le contrˆoleur de type de Caml calcule un type o`u les noms A, B, C sont
remplac´es respectivement par les param`etres ’c, ’a et ’b (sch´ema de droite).
A B C
g f
f ◦ g
’c ’a ’b
g f
compose f g
Le contrˆoleur de type a donc retrouv´e tout seul les contraintes math´ematiques et les
v´erifiera automatiquement `a chaque composition de fonctions. Consid´erons l’exemple
d’´ecole du successeur de la longueur d’une chaˆıne de caract`eres, d’abord sous forme
graphique, puis en Caml.
string
int
int
×c
×
y = string_length (c)
×
z = successeur (y)
string_length successeur
longueur_plus_un
72 Fonctionnelles et polymorphisme
# let longueur_plus_un = compose successeur string_length;;
longueur_plus_un : string -> int =
# longueur_plus_un "OK";;
- : int = 3
La composition de ces deux fonctions dans l’ordre inverse n’a pas de sens, ce que le
contrˆoleur de types signale :
# compose string_length successeur;;
Entr´ee interactive:
>compose string_length successeur;;
> ^^^^^^^^^^
Cette expression est de type int -> int,
mais est utilis´ee avec le type int -> string.
La fonctionnelle de curryfication
Nous allons d´efinir une fonctionnelle, curry, pour obtenir automatiquement la version
curryfi´ee d’une fonction non curryfi´ee `a deux arguments. Notre fonctionnelle prendra
donc en argument une fonction f dont l’argument est une paire (x, y) et rendra
en r´esultat une fonction `a deux arguments (qui est donc de la forme function x ->
function y -> . . . ) rendant le mˆeme r´esultat que f. On obtient donc
let curry f =
(function x -> function y -> «mˆeme r´esultat que f pour x et y »);;
Puisque le «mˆeme r´esultat que f pour x et y » n’est autre que f (x, y), on a donc
simplement :
# let curry f = function x -> (function y -> f (x, y));;
curry : (’a * ’b -> ’c) -> ’a -> ’b -> ’c =
Le type de la fonction curry est plus clair si l’on r´etablit les parenth`eses omises par
l’imprimeur de types de Caml (une fois n’est pas coutume). En effet (’a * ’b -> ’c)
-> ’a -> ’b -> ’c se lit aussi (’a * ’b -> ’c) -> (’a -> ’b -> ’c).
La fonctionnelle de d´ecurryfication
La fonctionnelle r´eciproque, uncurry, n’est pas plus complexe. Elle prend en argument
une fonction curryfi´ee g et rend en r´esultat une fonction ayant un seul argument
qui est une paire. Ce r´esultat est donc une valeur de la forme function (x, y) -> . . .
let uncurry g =
(function (x, y) -> «mˆeme r´esultat que g pour x et y »);;
Or, puisque g est curryfi´ee `a deux arguments, le «mˆeme r´esultat que g pour x et y »
est g x y.
# let uncurry g = function (x, y) -> g x y;;
uncurry : (’a -> ’b -> ’c) -> ’a * ’b -> ’c =
De mˆeme que pour curry, le type de uncurry se lit plus facilement en r´etablissant les
parenth`eses autour de ’a * ’b -> ’c.
Composition de fonctions 73
Leurs compos´ees
Intuitivement, il est clair que les fonctionnelles curry et uncurry sont r´eciproques
l’une de l’autre : `a partir d’une fonction `a « un argument de type paire » curry renvoie
une fonction « `a deux arguments », tandis que uncurry fait l’inverse. D’ailleurs :
# let id_curry f = (compose curry uncurry) f;;
id_curry : (’a -> ’b -> ’c) -> ’a -> ’b -> ’c =
# let id_uncurry f = (compose uncurry curry) f;;
id_uncurry : (’a * ’b -> ’c) -> ’a * ’b -> ’c =
Une fonctionnelle inutile
Consid´erez la fonctionnelle suivante qui applique une fonction f donn´ee `a un argument
x donn´e :
# let applique f x = f x;;
applique : (’a -> ’b) -> ’a -> ’b =
Cette fonctionnelle ne sert `a rien ! D’abord, si vous examinez soigneusement son type,
vous vous rendrez compte que c’est une sp´ecialisation du type de l’identit´e : (’a ->
’b) -> ’a -> ’b est une abr´eviation pour (’a -> ’b) -> (’a -> ’b), c’est-`a-dire ’a
-> ’a avec ’a sp´ecialis´e en (’a -> ’b). Donc, applique pourrait bien ne rien faire,
comme la fonction identit´e. On le d´emontre facilement, en utilisant toujours la r`egle
avec l’argument x cette fois :
let applique f x = f x;; ´equivaut `a let applique f = f;;
ce qui d´emontre que applique est s´emantiquement ´equivalente `a l’identit´e, sp´ecialis´ee
aux fonctions. En effet, applique impose `a son argument f d’ˆetre fonctionnel puisqu’elle
l’applique `a l’argument x. Cela nous fournit un exemple o`u l’application de la r`egle
change le type de la fonction qu’on d´efinit, le rendant plus g´en´eral :
# let applique f = f;;
applique : ’a -> ’a =
... id id id id id id id = id id id id id id = id id id id id = id id id id = id id id =id id =id=functionx->x
5
Listes
La tˆete et la queue, sans les oreilles . . .
armi les structures de donn´ees pr´ed´efinies en Caml, les listes ont un
statut privil´egi´e : elles sont d’emploi fr´equent, car simples `a manipuler et tr`es
g´en´erales. Si vous savez que les listes peuvent `a peu pr`es tout coder, mais qu’il
ne faut pas pour autant les mettre `a toutes les sauces, en bref, si vous connaissez bien
it_list et que justement vous ´evitez de l’employer trop souvent, alors lisez directement
le chapitre suivant.
Nous verrons, dans celui-ci, une autre repr´esentation des polynˆomes par des listes
de paires d’entiers et nous animerons le jeu des tours de Hanoi en montrant l’´evolution
de l’´etat du jeu. Au passage, nous approfondirons le filtrage (appel explicite au filtrage,
synonymes dans les filtres, filtrage multiple) et nous verrons des exemples de
fonctionnelles sur les listes.
5.1 Pr´esentation
Syntaxe
Les listes sont des suites homog`enes de valeurs, entour´ees de crochets [ et ]. Comme
pour les tableaux, les ´el´ements des listes sont s´epar´es par un point-virgule « ; ».
# [1; 2; 3];;
- : int list = [1; 2; 3]
Au contraire des tableaux, on n’acc`ede pas directement `a un ´el´ement de liste : il faut
parcourir s´equentiellement la liste pour atteindre l’´el´ement recherch´e. En revanche, les
listes peuvent grossir dynamiquement alors que les tableaux ont une taille d´etermin´ee,
fix´ee lors de leur construction. Cependant on ajoute toujours les ´el´ements au d´ebut
d’une liste et non `a la fin. C’est contraire `a la pratique courante : quand on tient `a jour
une liste de courses, on ajoute g´en´eralement la prochaine course `a faire `a la fin de sa
liste . . .
Toutes les listes sont construites avec les deux constructeurs de listes, « [] » (qu’on
prononce « nil », d’apr`es l’anglais nil qui signifie n´eant et qui provient du latin nihil qui
veut dire rien) et « :: » (qu’on prononce « conse », par abr´eviation de « constructeur de
76 Listes
liste »). [] est la liste vide et :: est l’op´erateur infixe qui ajoute un ´el´ement en tˆete
d’une liste. Tout comme le tableau vide, la liste vide est polymorphe.
# [];;
- : ’a list = []
# 0 :: [1; 2; 3];;
- : int list = [0; 1; 2; 3]
# 3 :: [];;
- : int list = [3]
# 1 :: 2 :: 3 :: [];;
- : int list = [1; 2; 3]
Repr´esentation graphique des listes
Pour expliquer certaines fonctions qui manipulent des listes, nous repr´esentons
graphiquement les calculs qu’elles effectuent. Pour cela nous dessinons les listes comme
des peignes dont les dents contiennent les ´el´ements de la liste. Par exemple, la liste
trois_entiers d´efinie par :
# let trois_entiers = [1; 2; 3];;
trois_entiers : int list = [1; 2; 3]
est repr´esent´ee par le sch´ema ci-contre.
Cette repr´esentation en peigne a l’avantage de mettre
en ´evidence la construction de la liste `a partir de ses
´el´ements, de la liste vide, et d’applications successives du
constructeur « :: ». En effet, la liste trois_entiers vaut
1 :: 2 :: 3 :: [] et vous aurez sans doute remarqu´e
que la notation [e1; e2; . . . ; en] est une abr´eviation pour
e1 :: e2 :: . . . :: en :: []. Lorsque nous expliquerons des
fonctions sur les listes, la liste argument la plus g´en´erale
sera not´ee l et ses ´el´ements seront not´es e1, e2, . . . , en.
Cette liste la plus g´en´erale sera donc d´ecrite graphiquement
par le peigne en marge.
::
::
::
1
2
3 []
trois_entiers
::
::
. . .
::
e1
e2
en []
l
Filtrage des listes
Le filtrage est ´etendu aux listes, si bien qu’on teste si une liste est vide avec la
fonction suivante :
# let nulle = function
| [] -> true
| _ -> false;;
nulle : ’a list -> bool =
Ce texte Caml se lit comme suit : si l’argument de la fonction nulle est la liste vide,
alors retourner true ([] -> true) ; dans tous les autres cas (_), retourner false. Par
exemple :
# (nulle []), (nulle [1]);;
- : bool * bool = true, false
Programmation assist´ee par filtrage 77
De plus, il est possible de nommer la tˆete ou le reste d’une liste argument avec des
filtres utilisant « :: ».
# let t^ete = function
| t :: r -> t
| _ -> failwith "t^ete";;
t^ete : ’a list -> ’a =
# t^ete [1; 2; 3; 4];;
- : int = 1
La clause t :: r -> t signifie : si la liste argument n’est pas vide et qu’on appelle
sa tˆete t et son reste r (t :: r), alors retourner t. La clause | _ -> signifie comme
d’habitude « dans tous les autres cas ». La fonction failwith est une fonction pr´ed´efinie
qui signale une erreur : en anglais, failwith signifie « ´echouer avec ». Vous devinez donc
que failwith "t^ete" signale une erreur dans la fonction t^ete.
# t^ete [];;
Exception non rattrap´ee: Failure "t^ete"
Le syst`eme nous signale ainsi une exception non rattrap´ee («Uncaught exception »),
c’est-`a-dire un ´echec, avec pour message la chaˆıne t^ete (Failure "t^ete"). Nous reviendrons
sur ce m´ecanisme d’´echec et sur la notion d’exception au chapitre 7.
Comme d’habitude, il n’est pas obligatoire de nommer une partie de la valeur argument
qu’on n’utilise pas. Par exemple, il n’est pas n´ecessaire de nommer la tˆete d’une
liste pour retourner son reste (on dit aussi la queue de la liste) :
# let reste = function
| _ :: r -> r
| _ -> failwith "reste";;
reste : ’a list -> ’a list =
# reste [1; 2; 3; 4];;
- : int list = [2; 3; 4]
5.2 Programmation assist´ee par filtrage
Il est facile de d´efinir une fonction qui additionne tous les ´el´ements d’une liste
d’entiers : si la liste est vide, alors le r´esultat est 0 ; sinon, on ajoute le premier ´el´ement
de la liste `a la somme des ´el´ements du reste de la liste.
# let rec somme = function
| [] -> 0
| x :: l -> x + somme l;;
somme : int list -> int =
On calcule le produit des ´el´ements d’une liste de fa¸con similaire.
# let rec produit = function
| [] -> 1
| x :: l -> x * produit l;;
produit : int list -> int =
Ces deux derni`eres fonctions sont des exemples repr´esentatifs : les fonctions sur
les listes sont le plus souvent r´ecursives et op`erent un filtrage sur la liste argument.
78 Listes
G´en´eralement, la fonction s’arrˆete quand elle rencontre une liste vide et s’appelle
r´ecursivement quand la liste n’est pas vide. Le squelette g´en´eral d’une telle fonction est
donc :
let rec f = function
| [] -> « valeur de base »
| x :: l -> ... f(l) ...;;
Cela vous explique pourquoi les fonctions nulle, t^ete et reste ne sont gu`ere employ´ees
en Caml : `a quoi bon tester explicitement if nulle(l) then . . . else . . . , quand le
filtrage permet de le faire bien plus ´el´egamment. En effet, en n’employant pas le filtrage,
le squelette g´en´eral d’une fonction r´ecursive sur les listes s’´ecrirait bien plus lourdement :
let rec f l =
if nulle l
then « valeur de base »
else let x = t^ete l and l’ = reste l in ... f(l’) ...;;
Le mod`ele g´en´eral de fonction r´ecursive d´efinie par filtrage sur les listes est `a rapprocher
de celui qu’on a vu sur les entiers :
let rec f = function
| 0 -> « solution simple »
| n -> ... f (n - 1) ...;;
Sch´ematiquement, le squelette le plus g´en´eral de fonctions r´ecursives Caml est sugg´er´e
par le pseudo-programme suivant :
let rec f = function
| « cas simple » -> « solution simple »
| « autre cas simple » -> « autre solution simple »
...
| « cas g´en´eral » -> ... f (« cas plus simple ») ...;;
Il est donc tr`es fr´equent que le filtrage dirige l’´ecriture des fonctions. Par exemple, si
l’on d´efinit une fonction sur les listes, on ´ecrira (presque) sans r´efl´echir :
let rec f = function
| [] ->
| x :: l ->
`A
titre d’entraˆınement avant d’attaquer les fonctionnelles d’usage g´en´eral sur les listes,
nous allons mettre en pratique cette « programmation assist´ee par filtrage » dans un cas
simple : le tri des listes.
5.3 Tri par insertion
Nous impl´ementons le tri par insertion, qui est un algorithme naturellement r´ecursif.
On suppose qu’une sous-partie du tableau `a trier est d´ej`a tri´ee et on y ins`ere `a la bonne
place le prochain ´el´ement de la partie non tri´ee du tableau. Nous en donnons une version
fonctionnelle sur les listes.
Tri par insertion 79
Tri sur listes
L’id´ee est qu’il est facile de ranger un ´el´ement `a sa place dans une liste d’´el´ements
d´ej`a tri´ee. Nous supposons donc avoir d´ej`a ´ecrit une fonction ins`ere qui ins`ere un
´el´ement `a la bonne place dans une liste tri´ee. Nous ´ecrivons maintenant la fonction de
tri. Cette fonction travaille sur des listes ; elle doit donc envisager les deux cas possibles
de listes :
let tri_par_insertion = function
| [] -> ...
| x :: reste -> ... ;;
Le cas de la liste vide est simple : une liste vide est ´evidemment tri´ee ; on renvoie donc
la liste vide.
let tri_par_insertion = function
| [] -> []
| x :: reste -> ... ;;
Dans l’autre cas, on va commencer par trier le reste de la liste. C’est d´ej`a possible, bien
que nous n’ayons pas encore ´ecrit notre fonction de tri : il suffit d’appeler r´ecursivement
la fonction tri_par_insertion que nous sommes justement en train d’´ecrire . . .
let rec tri_par_insertion = function
| [] -> []
| x :: reste -> ... tri_par_insertion reste;;
Il nous suffit maintenant de mettre l’´el´ement x `a la bonne place dans le reste maintenant
tri´e de la liste. C’est facile : on se contente d’appeler la fonction ins`ere. Nous obtenons :
let rec tri_par_insertion = function
| [] -> []
| x :: reste -> ins`ere x (tri_par_insertion reste);;
La fonction de tri est termin´ee. Il nous reste `a ´ecrire la fonction ins`ere. Par le mˆeme
raisonnement que ci-dessus on commence par en ´ecrire le squelette :
let ins`ere ´el´ement = function
| [] -> ...
| x :: reste -> ...;;
Le cas de la liste vide est encore une fois simple : il suffit de retourner une liste r´eduite
`a l’´el´ement qu’on souhaite ins´erer.
let ins`ere ´el´ement = function
| [] -> [´el´ement]
| x :: reste -> ...;;
Dans l’autre cas, la liste o`u l’on veut ins´erer ´el´ement commence par x. Si ´el´ement est
plus petit que x alors c’est le plus petit de tous les ´el´ements de la liste x :: reste,
puisque celle-ci est tri´ee par hypoth`ese. On place donc ´el´ement au d´ebut de la liste x
:: reste.
let ins`ere ´el´ement = function
| [] -> [´el´ement]
| x :: reste -> if ´el´ement <= x then ´el´ement :: x :: reste else ...;;
Dans le cas contraire, c’est x le plus petit ´el´ement de la liste r´esultat ; ce r´esultat sera
donc x :: ... Il nous reste `a ins´erer ´el´ement dans la liste reste. Un petit appel
r´ecursif ins`ere ´el´ement reste et le tour est jou´e :
80 Listes
# let rec ins`ere ´el´ement = function
| [] -> [´el´ement]
| x :: reste ->
if ´el´ement <= x then ´el´ement :: x :: reste
else x :: (ins`ere ´el´ement reste);;
ins`ere : ’a -> ’a list -> ’a list =
Il nous reste `a d´efinir effectivement la fonction de tri et `a l’essayer :
# let rec tri_par_insertion = function
| [] -> []
| x :: reste -> ins`ere x (tri_par_insertion reste);;
tri_par_insertion : ’a list -> ’a list =
# tri_par_insertion [3; 2; 1];;
- : int list = [1; 2; 3]
Synonymes dans les filtres
Pour am´eliorer la lisibilit´e du code de la fonction ins`ere, nous introduisons une
facilit´e de nommage suppl´ementaire dans les filtres.
Il arrive que l’on veuille examiner la forme d’une valeur tout en nommant cette
valeur. Consid´erez la fonction qui rend la valeur absolue d’un monˆome, repr´esent´e
comme une paire d’entier (coefficient, degr´e) :
# let abs_mon^ome = function
(a, degr´e) -> if a < 0 then (-a, degr´e) else (a, degr´e);;
abs_mon^ome : int * ’a -> int * ’a =
Ce code est parfaitement correct, mais dans le cas o`u le coefficient est positif on aimerait
rendre directement le monˆome re¸cu en argument. Le code serait plus clair, puisqu’il
n’y aurait pas besoin d’une petite gymnastique mentale pour se rendre compte que
l’expression (a, degr´e) correspond exactement au filtre de la clause. Autrement dit,
nous voudrions nommer mon^ome le filtre (a, degr´e) et rendre mon^ome quand a est
positif. Dans ce cas, on introduit le nom choisi avec le mot-cl´e as (qui se prononce
« ase » et signifie « en tant que » en anglais).
Synonymes dans les filtres ::= filtre as nom
Nous obtenons :
# let abs_mon^ome = function
(a, degr´e) as mon^ome -> if a < 0 then (-a, degr´e) else mon^ome;;
abs_mon^ome : int * ’a -> int * ’a =
Maintenant le nommage indique `a l’´evidence qu’aucune transformation n’est faite sur le
monˆome, alors que l’expression (a, degr´e), bien qu’´equivalente, cache un peu qu’elle
n’est autre que l’argument de la fonction.
Pour la fonction ins`ere, l’usage d’un filtre synonyme pour nommer la liste argument
clarifie ´egalement un peu le code :
# let rec ins`ere ´el´ement = function
| [] -> [´el´ement]
| x :: reste as l ->
if ´el´ement <= x then ´el´ement :: l
else x :: (ins`ere ´el´ement reste);;
ins`ere : ’a -> ’a list -> ’a list =
Fonctionnelles simples sur les listes 81
G´en´eralisation du tri `a tout type d’ordre
Pour g´en´eraliser la fonction de tri `a toute sorte d’ordres, il suffit de passer la fonction
de comparaison en argument, comme on l’a vu au chapitre 4. Les fonctions ins`ere et
tri_par_insertion prennent alors un argument suppl´ementaire, ordre, qu’on utilise
pour comparer les ´el´ements, `a la place de la comparaison <=.
# let rec ins`ere ordre ´el´ement = function
| [] -> [´el´ement]
| x :: reste as l ->
if ordre ´el´ement x then ´el´ement :: l
else x :: (ins`ere ordre ´el´ement reste);;
ins`ere : (’a -> ’a -> bool) -> ’a -> ’a list -> ’a list =
# let rec tri_par_insertion ordre = function
| [] -> []
| x :: reste -> ins`ere ordre x (tri_par_insertion ordre reste);;
tri_par_insertion : (’a -> ’a -> bool) -> ’a list -> ’a list =
La mˆeme fonction nous permet maintenant de trier indiff´eremment des listes de chaˆınes
ou de nombres, `a l’endroit ou `a l’envers :
# tri_par_insertion (function x -> function y -> x <= y) [3; 1; 2];;
- : int list = [1; 2; 3]
# tri_par_insertion (function x -> function y -> x >= y) [3; 1; 2];;
- : int list = [3; 2; 1]
# tri_par_insertion (function x -> function y -> ge_string x y)
["Salut "; "les "; "copains!"];;
- : string list = ["les "; "copains!"; "Salut "]
# tri_par_insertion (function x -> function y -> le_string x y)
["Salut "; "les "; "copains!"];;
- : string list = ["Salut "; "copains!"; "les "]
Remarque de complexit´e : on d´emontre que ce tri est quadratique (O(n2)) en moyenne
(sur un jeu de donn´ees tir´ees au hasard). Dans le pire des cas, c’est-`a-dire quand le
jeu de donn´ees n´ecessite le plus d’op´erations (ce qui correspond pour ce tri `a une liste
tri´ee en ordre inverse), le tri par insertion est ´egalement quadratique. En revanche, il
est lin´eaire pour une liste d´ej`a tri´ee.
5.4 Fonctionnelles simples sur les listes
Les listes, comme toutes les structures de donn´ees polymorphes, se prˆetent naturellement
`a la d´efinition de fonctionnelles r´eutilisables dans de nombreuses situations. Nous
pr´esentons dans cette section quelques-unes de ces fonctionnelles, parmi les plus simples
; nous en verrons d’autres, plus complexes, `a la section 5.9.
Faire une action sur les ´el´ements d’une liste
´E
tant donn´ees une fonction f et une liste l, la fonctionnelle do_list applique f
tour `a tour `a tous les ´el´ements de l. Cela correspond donc `a effectuer des appels `a f
en s´equence sur les ´el´ements de l. Autrement dit, ´evaluer do_list f [e1; e2; . . . ; en]
signifie ex´ecuter la s´equence begin f e1; f e2; . . . ; f en; () end. Par exemple :
82 Listes
# do_list print_int [1; 2; 3];;
123- : unit = ()
# do_list (function i -> print_int i; print_char ‘ ‘) [1; 2; 3];;
1 2 3 - : unit = ()
´E
crivons do_list :
# let rec do_list f = function
| [] -> ()
| x :: l -> f x; do_list f l;;
do_list : (’a -> ’b) -> ’a list -> unit =
Le raisonnement est le suivant : si la liste argument est vide, il n’y a rien `a faire. Sinon,
la liste argument est de la forme x :: l, car elle n’est pas vide. En ce cas, il faut
´evaluer en s´equence f(x), puis l’action de f sur le reste de la liste, qu’on obtient par
un appel r´ecursif `a do_list.
Remarquons que le type de la fonction do_list indique clairement que la fonction
f doit accepter en argument les ´el´ements de la liste, puisque f a pour type ’a -> ’b et
que la liste a pour type ’a list. En revanche, les r´esultats des appels `a f sont ignor´es :
f peut rendre un r´esultat de n’importe quel type.
Appliquer `a tous les ´el´ements d’une liste
´E
tant donn´ees une fonction f et une liste l, la fonctionnelle map retourne la liste des
r´esultats obtenus en appliquant f `a chaque ´el´ement de l. Par exemple, map successeur
[1;2;3] retourne la liste [2;3;4], tandis que map carr´e [1;2;3] retourne [1;4;9].
L’expression map f [e1; e2; . . . ; en] retourne donc la liste [f e1; f e2; . . . ; f en].
Graphiquement, la fonction map « distribue » f sur les ´el´ements de la liste argument :
::
::
. . .
::
e1
e2
en []
l
::
::
. . .
::
f e1
f e2
f en []
map f l
map f
Le nom map provient du langage Lisp et signifie « application multiple ». La fonction
s’´ecrit tr`es simplement : si la liste argument est vide le r´esultat est la liste vide. Sinon,
la liste argument est de la forme x :: l et il suffit de mettre en tˆete du r´esultat
l’application de f `a x, le reste du r´esultat ´etant fourni par un appel r´ecursif `a map.
# let rec map f = function
| [] -> []
| x :: l -> f x :: map f l;;
map : (’a -> ’b) -> ’a list -> ’b list =
Cette fois-ci le type d’arriv´ee de la fonction f n’est plus ignor´e : il doit ˆetre identique
au type des ´el´ements de la liste des r´esultats.
# map succ [1; 2; 3];;
- : int list = [2; 3; 4]
Les polynˆomes creux 83
# map string_length ["Bonjour"; "tout"; "le "; "monde!"];;
- : int list = [7; 4; 3; 6]
Nous allons utiliser nos nouvelles connaissances sur les listes pour calculer des
polynˆomes qui nous ´etaient pr´ec´edemment inaccessibles.
5.5 Les polynˆomes creux
Une repr´esentation affin´ee
Notre premier programme de manipulation des polynˆomes (section 3.3) repr´esentait
les polynˆomes par des tableaux d’entiers. Cette repr´esentation est tr`es dispendieuse
quand les polynˆomes ont peu de monˆomes dont les degr´es sont tr`es diff´erents : il serait
insupportable de repr´esenter le polynˆome 1+x10000 par un tableau `a 10001 cases dont
9999 comporteraient des z´eros ! Les polynˆomes ayant cette propri´et´e d’avoir une forte
proportion de coefficients nuls sont appel´es polynˆomes creux. Par opposition nous avions
appel´e polynˆomes pleins les polynˆomes de la section 3.3, repr´esent´es par le tableau
des coefficients de leurs monˆomes. Une repr´esentation plus compacte des polynˆomes
creux utilise tout naturellement la liste ordonn´ee des coefficients non nuls, avec leurs
degr´es respectifs. Il s’agit donc de listes de paires d’entiers. Dans cette repr´esentation,
le polynˆome 1 + 2X3 serait :
# let p = [(1, 0); (2, 3)];;
p : (int * int) list = [1, 0; 2, 3]
Nous allons red´efinir les op´erations sur les polynˆomes, en travaillant sur des polynˆomes
creux.
Impression des polynˆomes creux
L’impression est tr`es simple : nous utilisons exactement la mˆeme fonction
d’impression des monˆomes que dans le cas des polynˆomes pleins, mais nous l’it´erons
sur la liste des coefficients `a l’aide de la fonctionnelle do_list.
# let imprime_polyn^ome_creux p =
do_list (function (a, degr´e) -> imprime_mon^ome a degr´e) p;;
imprime_polyn^ome_creux : (int * int) list -> unit =
# imprime_polyn^ome_creux p;;
1 + 2x^3- : unit = ()
(Les amateurs de casse-tˆete compareront la fonction imprime_polyn^ome_creux avec la
fonction do_list (uncurry imprime_mon^ome) ou mˆeme compose do_list uncurry
imprime_mon^ome.)
L’addition est un peu plus compliqu´ee. En effet, elle op`ere un filtrage en parall`ele sur
les deux polynˆomes arguments. Ce filtrage est complexe et utilise des traits nouveaux
pour nous. Nous les d´etaillons avant d’analyser le code de l’addition des polynˆomes
creux.
84 Listes
5.6 Filtrage explicite
La construction match ... with
Pour filtrer ses deux arguments en parall`ele, la fonction d’addition des polynˆomes
utilise un appel explicite au filtrage, m´ecanisme introduit par le mot-cl´e match :
Appel explicite au filtrage ::= match expression
with filtrage
Cette construction a la s´emantique d’une conditionnelle par cas, ou encore d’un if
g´en´eralis´e travaillant par filtrage. Red´efinissons la fonction nulle avec un appel explicite
au filtrage : on demande explicitement d’examiner la forme de la liste l argument de
nulle et l’on renvoie dans chaque cas l’expression ad´equate.
# let nulle l =
match l with
| [] -> true
| _ -> false;;
nulle : ’a list -> bool =
On lit ce filtrage comme la phrase : si la liste l est vide, renvoyer true ; dans tous les
autres cas, renvoyer false.
En utilisant le filtrage explicite, nous pouvons tr`es facilement ´ecrire la fonction qui
concat`ene deux listes : si la premi`ere liste est vide, le r´esultat est la deuxi`eme ; sinon, il
faut mettre la tˆete de la premi`ere liste devant la concat´enation du reste de cette liste
avec la deuxi`eme liste. Ce qui, parce que bien con¸cu, s’´enonce clairement ainsi :
# let rec concat`ene l1 l2 =
match l1 with
| [] -> l2
| x :: reste -> x :: concat`ene reste l2;;
concat`ene : ’a list -> ’a list -> ’a list =
# concat`ene [1; 2; 3] [4; 5; 6];;
- : int list = [1; 2; 3; 4; 5; 6]
Filtrage simultan´e de deux valeurs
Pour envisager tous les cas concernant la forme de deux listes, il suffit de filtrer
explicitement la paire des deux listes. Ainsi, la fonction suivante d´etermine si deux
listes ont mˆeme longueur :
# let rec m^eme_longueur l1 l2 =
match (l1, l2) with
| ([], []) -> true
| (_ :: reste1, _ :: reste2) -> m^eme_longueur reste1 reste2
| (_, _) -> false;;
m^eme_longueur : ’a list -> ’b list -> bool =
# m^eme_longueur [1] [2];;
- : bool = true
# m^eme_longueur [1] [1; 2];;
- : bool = false
Op´erations sur les polynˆomes creux 85
Le filtre (_ :: reste1, _ :: reste2) signifie : si la premi`ere liste l1 n’est pas vide
et donc de la forme _ :: reste1 et si simultan´ement la seconde liste l2 est non vide
et de la forme _ :: reste2, alors . . . En particulier, les soulign´es « _ » mettent bien en
´evidence qu’on ne s’int´eresse pas `a la tˆete des listes, mais qu’on a nomm´e leurs restes
respectifs reste1 et reste2. Remarquez que le dernier cas du filtrage correspond `a des
listes d’in´egales longueurs : l’une est ´epuis´ee mais l’autre ne l’est pas. En effet, si les
deux ´etaient ´epuis´ees le premier cas s’appliquerait, tandis que si aucune n’´etait ´epuis´ee,
c’est le second qui s’appliquerait. Autrement dit : le cas (_, _) regroupe en une seule
clause les deux cas ([], _ :: _) -> false et (_ :: _, []) -> false.
Remarquons ´egalement que le filtrage simultan´e ne n´ecessite pas les parenth`eses des
couples ; la construction permet de filtrer des expressions s´epar´ees par des virgules avec
leurs filtres respectifs, eux aussi s´epar´es par des virgules :
match l1, l2 with
| [], [] -> true
| _ :: reste1, _ :: reste2 -> ...
5.7 Op´erations sur les polynˆomes creux
Addition des polynˆomes creux
L’addition des polynˆomes creux va analyser r´ecursivement ses deux arguments pour
en construire la somme. Comme nous l’avons vu dans le cas des polynˆomes pleins, il
arrive que certains termes d’un des deux polynˆomes arguments n’aient pas de correspondants
dans l’autre, parce que les polynˆomes n’ont pas le mˆeme degr´e. Dans le cas
des polynˆomes creux, l’une des listes de monˆomes sera ´epuis´ee avant l’autre. Si nous
atteignons ainsi la fin de l’un des polynˆomes, l’autre constitue le r´esultat cherch´e : par
exemple, si l’on ajoute un polynˆome P0 r´eduit `a une constante `a un autre polynˆome P,
il faut ajouter les deux monˆomes de degr´e 0 de P et P0, mais le r´esultat comprend aussi
la liste des monˆomes restants de P. En effet, les coefficients manquants du polynˆome de
plus bas degr´e correspondent `a des z´eros implicites. Dans le cas g´en´eral, nous ajoutons
les termes de mˆeme degr´e ou recopions dans le r´esultat final les termes qui n’ont pas
d’analogue dans l’autre polynˆome.
# let rec ajoute_polyn^omes_creux p1 p2 =
match p1, p2 with
| _, [] -> p1
| [], _ -> p2
| (a1, degr´e1 as m1) :: reste1, (a2, degr´e2 as m2) :: reste2 ->
if degr´e1 = degr´e2
then ((a1 + a2), degr´e1) :: ajoute_polyn^omes_creux reste1 reste2
else if degr´e1 < degr´e2
then m1 :: ajoute_polyn^omes_creux reste1 p2
else m2 :: ajoute_polyn^omes_creux p1 reste2;;
ajoute_polyn^omes_creux :
(int * ’a) list -> (int * ’a) list -> (int * ’a) list =
Le filtre (a1,degr´e1 as m1) :: reste1, (a2,degr´e2 as m2) :: reste2 est complexe
et n´ecessite une explication. Il est clairement constitu´e de deux filtres analogues
86 Listes
s´epar´es par une virgule, l’un pour filtrer p1 et l’autre pour filtrer p2. Examinons celui
qui concerne p1. Le filtre (a1,degr´e1 as m1) :: reste1 signifie que :
• p1 est une liste non vide dont la tˆete est filtr´ee par (a1, degr´e1 as m1) et le
reste est nomm´e reste1,
• la tˆete de p1 est donc un couple dont les composantes sont nomm´ees a1 et degr´e1,
• le couple lui-mˆeme, (a1, degr´e1), est nomm´e m1 grˆace au filtre synonyme as
m1.
Admirons au passage la puissance et l’´el´egance du m´ecanisme de filtrage. Remarquez
´egalement que les filtres sont essay´es dans l’ordre de pr´esentation dans le filtrage. Par
exemple, la valeur ([], []) sera filtr´ee par le premier filtre, bien qu’elle soit aussi
filtrable par le second. `A titre d’exemple, nous calculons la somme des polynˆomes
X2 + 3X4 et 3 + 2X2 + 5X10.
# imprime_polyn^ome_creux
(ajoute_polyn^omes_creux [(1,2); (3,4)] [(3,0); (2,2); (5,10)]);;
3 + 3x^2 + 3x^4 + 5x^10- : unit = ()
Multiplication des polynˆomes creux
La multiplication op`ere ´egalement par filtrage simultan´e de ses deux arguments.
Dans le cas o`u l’un des polynˆomes est ´epuis´e, il n’y a plus de multiplication `a faire. En effet,
les monˆomes manquants ont implicitement des coefficients nuls, donc les multiplications
produiront toujours des coefficients nuls. En ce cas, le r´esultat est donc la liste vide.
Sinon, on applique simplement la r`egle habituelle de distributivit´e de la multiplication
par rapport `a l’addition. Voyons : soit m1 le premier monˆome de P1 et reste1 les autres
monˆomes de P1. On a P1 = m1+reste1, donc P1×P2 = m1×P2+ reste1×P2. Si l’on appelle
notre fonction multiplie_polyn^omes_creux, alors reste1×P2 correspond `a l’appel
r´ecursif multiplie_polyn^omes_creux reste1 p2. Quant `a l’expression m1 ×P2, c’est
un cas plus simple o`u l’on multiplie un polynˆome par un monˆome. Nous le traiterons par
la fonction auxiliaire multiplie_par_mon^ome_creux. L’expression m1×P2+reste1×P2
s’´ecrit donc :
ajoute_polyn^omes_creux
(multiplie_par_mon^ome_creux m1 p2)
(multiplie_polyn^omes_creux reste1 p2)
Il reste `a d´efinir multiplie_par_mon^ome_creux. Si m1 est le monˆome et P le polynˆome,
il suffit de multiplier chaque monˆome de P par le monˆome m1, ce qui se fait simplement
en multipliant les coefficients et en ajoutant les degr´es. En r´esum´e :
# let multiplie_par_mon^ome_creux (a1, degr´e1) p =
map (function (a, degr´e) -> (a * a1, degr´e1 + degr´e)) p;;
multiplie_par_mon^ome_creux :
int * int -> (int * int) list -> (int * int) list =
# let rec multiplie_polyn^omes_creux p1 p2 =
match p1, p2 with
| (_, []) -> []
| ([], _) -> []
| (m1 :: reste1, _) ->
Op´erations sur les polynˆomes creux 87
ajoute_polyn^omes_creux
(multiplie_par_mon^ome_creux m1 p2)
(multiplie_polyn^omes_creux reste1 p2);;
multiplie_polyn^omes_creux :
(int * int) list -> (int * int) list -> (int * int) list =
Nous calculons (1 + X10000)2 `a titre d’exemple :
# let p = [(1, 0); (1, 10000)] in
imprime_polyn^ome_creux (multiplie_polyn^omes_creux p p);;
1 + 2x^10000 + x^20000- : unit = ()
En premi`ere lecture, vous en savez largement assez pour passer d`es maintenant au
chapitre suivant.
Polymorphisme et r`egle
Nous devons signaler ici une petite difficult´e qui apparaˆıt lorsqu’on utilise la r`egle
pour simplifier une d´efinition, lorsque le r´esultat doit ˆetre polymorphe. Supposons que
nous d´efinissions le tri par ordre croissant ainsi :
# let tri_croissant l =
tri_par_insertion (function x -> function y -> x <= y) l;;
tri_croissant : ’a list -> ’a list =
On peut esp´erer simplifier cette d´efinition `a l’aide de la r`egle , en supprimant
l’argument l :
# let tri_croissant =
tri_par_insertion (function x -> function y -> x <= y);;
tri_croissant : ’_a list -> ’_a list =
On constate alors que la fonction tri_croissant n’a plus le mˆeme type, et qu’il appara
ˆıt dans ce type d’´etranges param`etres de type ’_a.Au contraire des param`etres ’a
qui signifient pour tout type a, et d´enotent donc des types polymorphes, les param`etres
’_a signifient pour un certain type a qui sera d´etermin´e par les utilisations ult´erieures
de la fonction. La fonction tri_croissant est donc monomorphe :
# tri_croissant [3; 2; 1];;
- : int list = [1; 2; 3]
# tri_croissant;;
- : int list -> int list =
# tri_croissant ["Bonjour"];;
Entr´ee interactive:
>tri_croissant ["Bonjour"];;
> ^^^^^^^^^^^
Cette expression est de type string list,
mais est utilis´ee avec le type int list.
Le type inconnu ’_a est devenu le type int et la fonction tri_croissant est dor´enavant
de type int -> int.
Ce ph´enom`ene est dˆu `a la coexistence en Caml du polymorphisme et des structures
mutables. Il est expliqu´e en d´etails `a la fin de ce livre, page 363, lorsque nous aurons
vu les m´ecanismes qui permettent de le comprendre. Retenons pour l’instant que seule
les fonctions (et les constantes) sont susceptibles d’ˆetre polymorphes, les d´efinitions de
88 Listes
fonctions obtenues par application partielle d’une fonction plus g´en´erale sont monomorphes.
Nous avons d´ej`a constat´e (page 73) que l’application de la r`egle peut modifier
le type d’une fonction, le rendant plus g´en´eral ; ici, c’est l’inverse : on passe d’un type
polymorphe `a un type monomorphe moins g´en´eral.
5.8 Animation des tours de Hanoi
En guise d’exercice sur les listes, nous d´efinissons un ensemble de fonctions qui manipulent
des listes de chaˆınes pour animer visuellement le jeu des tours de Hanoi. C’est
un vrai programme qui utilise des r´ef´erences et la r´ecursivit´e. Cela reste cependant un
exercice : nous n’avons aucun souci d’efficacit´e ici. Ce genre de programme d’impression
´elabor´ee (le formatage) est plus du ressort de la modification physique de chaˆınes de
caract`eres que de la manipulation de listes.
# let blancs n = make_string n ‘ ‘;;
blancs : int -> string =
# let disque taille =
let moiti´e_droite = make_string taille ‘>‘
and moiti´e_gauche = make_string taille ‘<‘
in moiti´e_gauche ^ "|" ^ moiti´e_droite;;
disque : int -> string =
Ces deux fonctions construisent respectivement la repr´esentation sous forme d’une
chaˆıne d’une ligne vide de longueur n et d’un disque de largeur taille. Par exemple,
le disque de largeur 3 est repr´esent´e par la chaˆıne "<<<|>>>" : la chaˆıne "|" repr´esente
un morceau de tige et "<<<" et ">>>" les parties gauche et droite du disque.
La fonction suivante construit un disque, pos´e sur une tige, c’est-`a-dire entour´e d’un
certain nombre d’espaces, de fa¸con `a ce que le disque occupe la mˆeme largeur que la
tige sur laquelle il est pos´e :
# let disque_num´ero n taille_grand_disque =
let partie_blanche = blancs (taille_grand_disque + 1 - n) in
partie_blanche ^ (disque n) ^ partie_blanche;;
disque_num´ero : int -> int -> string =
La derni`ere fonction dessine la base d’une tige sous la forme " ___|___ ".
# let base_de_tige taille_grand_disque =
let moiti´e = make_string taille_grand_disque ‘_‘ in
" " ^ moiti´e ^ "|" ^ moiti´e ^ " ";;
base_de_tige : int -> string =
Un disque est repr´esent´e par un simple num´ero : sa largeur. Une tige est repr´esent´ee
par un couple (entier, liste d’entiers). La premi`ere composante est le nombre de cases
libres en haut de la tige, la seconde la liste des disques pos´es sur la tige. La fonction
tige suivante construit la liste des chaˆınes de caract`eres repr´esentant les disques pos´es
sur une tige.
# let rec tige taille_grand_disque = function
| (0, []) -> []
| (0, t^ete :: reste) ->
disque_num´ero t^ete taille_grand_disque ::
Animation des tours de Hanoi 89
tige taille_grand_disque (0, reste)
| (d´ecalage, liste) ->
disque_num´ero 0 taille_grand_disque ::
tige taille_grand_disque (d´ecalage-1, liste);;
tige : int -> int * int list -> string list =
Par exemple, voici ce qu’on obtient pour la tige (1, [2; 3; 5]), c’est-`a-dire une case
libre, puis trois disques de largeur 2, 3 et 5 :
# let imprime ligne = print_string ligne; print_newline ();;
imprime : string -> unit =
# do_list imprime (tige 5 (1, [2; 3; 5]));;
|
<<|>>
<<<|>>>
<<<<<|>>>>>
- : unit = ()
Par la suite, nous allons avoir besoin d’afficher non pas une tige, mais trois tiges cˆote
`a cˆote. La fonction recolle cr´ee la liste des lignes `a afficher `a partir des trois listes de
lignes correspondant aux trois tiges.
# let rec recolle l1 l2 l3 =
match l1, l2, l3 with
| [], [], [] -> []
| t1 :: r1, t2 :: r2, t3 :: r3 ->
(t1 ^ t2 ^ t3) :: recolle r1 r2 r3
| _ -> failwith "recolle";;
recolle : string list -> string list -> string list -> string list =
L’affichage d’une configuration consiste simplement `a imprimer les lignes qui
repr´esentent les disques, puis `a imprimer les trois bases des tiges.
# let imprime_jeu nombre_de_disques d´epart milieu arriv´ee =
let dessin =
recolle (tige nombre_de_disques d´epart)
(tige nombre_de_disques milieu)
(tige nombre_de_disques arriv´ee) in
do_list imprime dessin;
let b = base_de_tige nombre_de_disques in imprime (b ^ b ^ b);;
imprime_jeu :
int -> int * int list -> int * int list -> int * int list -> unit =
Nous impl´ementons maintenant les d´eplacements de disques d’une tige `a l’autre. Voyons
tout d’abord la fonction qui ajoute un disque au sommet d’une tige. Par exemple, dans
un jeu `a quatre disques, ajouter le troisi`eme disque `a une tige qui ne comprend que le
disque num´ero 4 correspond `a l’´evaluation de ajoute_disque 3 (2, [4]), qui retourne
(1, [3; 4]).
# let ajoute_disque disque (d´ecalage, disques as tige) =
(d´ecalage - 1, disque :: disques);;
ajoute_disque : ’a -> int * ’a list -> int * ’a list =
On d´efinit la fonction sommet pour consulter le disque qui se trouve au sommet d’une
tige et la fonction enl`eve_sommet pour ˆoter le sommet d’une tige (plus exactement,
pour renvoyer la tige priv´ee de son sommet).
90 Listes
# let sommet = function
| (d´ecalage, sommet :: reste) -> sommet
| (d´ecalage, []) -> failwith "sommet: tige vide";;
sommet : ’a * ’b list -> ’b =
# let enl`eve_sommet = function
| (d´ecalage, sommet :: reste) -> (d´ecalage + 1, reste)
| (d´ecalage, []) -> failwith "enl`eve_sommet: tige vide";;
enl`eve_sommet : int * ’a list -> int * ’a list =
Nous pouvons maintenant simuler un mouvement en d´epla¸cant un disque d’une tige `a
l’autre. La proc´edure prend en argument des r´ef´erences sur les tiges concern´ees et les
modifie physiquement au passage.
# let d´eplace (nom_d´epart, tige_d´epart) (nom_arriv´ee, tige_arriv´ee) =
imprime("Je d´eplace un disque de " ^
nom_d´epart ^ " `a " ^ nom_arriv´ee);
let disque_d´eplac´e = sommet !tige_d´epart in
tige_d´epart := enl`eve_sommet !tige_d´epart;
tige_arriv´ee := ajoute_disque disque_d´eplac´e !tige_arriv´ee;;
d´eplace :
string * (int * ’a list) ref -> string * (int * ’a list) ref -> unit =
La mod´elisation de l’´etat initial du jeu n´ecessite la d´efinition d’une tige vide et d’une
tige pleine, en fonction du nombre de disques utilis´es.
# let tige_vide nombre_de_disques = (nombre_de_disques, []);;
tige_vide : ’a -> ’a * ’b list =
# let tige_pleine nombre_de_disques =
let rec liste_des_disques i =
if i <= nombre_de_disques
then i :: liste_des_disques (i + 1)
else [] in
(0, liste_des_disques 1);;
tige_pleine : int -> int * int list =
Nous d´efinissons maintenant une proc´edure de r´esolution compl`ete incluant les fonctions
d’impression. Nous maintenons l’´etat des trois tiges `a l’aide de trois r´ef´erences,
gauche, milieu et droite. Remarquez que la proc´edure r´ecursive locale hanoi
prend ces trois r´ef´erences en argument et qu’elles sont modifi´ees physiquement par la
proc´edure d´eplace.
# let jeu nombre_de_disques =
let gauche = ref (tige_pleine nombre_de_disques)
and milieu = ref (tige_vide nombre_de_disques)
and droite = ref (tige_vide nombre_de_disques) in
let rec hanoi hauteur d´epart interm´ediaire destination =
if hauteur > 0 then
begin
hanoi (hauteur - 1) d´epart destination interm´ediaire;
d´eplace d´epart destination;
imprime_jeu nombre_de_disques !gauche !milieu !droite;
hanoi (hauteur - 1) interm´ediaire d´epart destination
end in
Fonctionnelles complexes sur les listes 91
# jeu 3;;
J’appelle les tiges A, B et C.
Position de d´epart: Je d´eplace un disque de A `a C
<|> | | | | |
<<|>> | | | <|> |
<<<|>>> | | | <<|>> <<<|>>>
___|___ ___|___ ___|___ ___|___ ___|___ ___|___
Je d´eplace un disque de A `a C Je d´eplace un disque de B `a A
| | | | | |
<<|>> | | | | |
<<<|>>> | <|> <|> <<|>> <<<|>>>
___|___ ___|___ ___|___ ___|___ ___|___ ___|___
Je d´eplace un disque de A `a B Je d´eplace un disque de B `a C
| | | | | |
| | | | | <<|>>
<<<|>>> <<|>> <|> <|> | <<<|>>>
___|___ ___|___ ___|___ ___|___ ___|___ ___|___
Je d´eplace un disque de C `a B Je d´eplace un disque de A `a C
| | | | | <|>
| <|> | | | <<|>>
<<<|>>> <<|>> | | | <<<|>>>
___|___ ___|___ ___|___ ___|___ ___|___ ___|___
- : unit = ()
Figure 5.1: R´esolution des tours de Hanoi `a 3 disques
imprime "J’appelle les tiges A, B et C.";
imprime "Position de d´epart:";
imprime_jeu nombre_de_disques !gauche !milieu !droite;
hanoi nombre_de_disques
("A", gauche) ("B", milieu) ("C", droite);;
jeu : int -> unit =
La figure 5.1 montre le d´eroulement de jeu 3.
5.9 Fonctionnelles complexes sur les listes
Nous allons maintenant passer en revue un certain nombre de fonctionnelles classiques
sur les listes. Elles sont d’un emploi plus rare que celles que nous avons d´ej`a
vues. Nous les utiliserons dans les exemples les plus difficiles. Vous pourrez alors vous
reporter aux explications qui suivent.
Notion d’abstraction de sch´emas de programmes
Vous vous souvenez sans doute que pour g´en´eraliser les fonctions de tri du chapitre 4
et du pr´esent chapitre, il nous avait suffi de passer la comparaison en param`etre. Nous
avions dit que nous avions « abstrait » l’ordre. Les fonctionnelles que nous allons d´ecrire
sont ´egalement bas´ees sur la notion d’abstraction. Cependant, dans ce cas il ne s’agit
pas d’abstraire une fonction qui intervient dans le programme pour le g´en´eraliser, mais
92 Listes
d’abstraire un sch´ema de programme, c’est-`a-dire une m´ethode de calcul commune
`a plusieurs algorithmes. Pour d´egager cette m´ethode de calcul, nous allons montrer
plusieurs fonctions qui l’utilisent. Nous rappelons d’abord le code des fonctions somme
et produit, d´efinies ci-dessus ; puis nous ´ecrivons la fonction implose, qui renvoie la
concat´enation de toutes les chaˆınes d’une liste et enfin la fonction concat`ene_listes
qui concat`ene toutes les listes d’une liste de listes (ce dernier exemple utilise la fonction
pr´ed´efinie @ qui concat`ene deux listes).
# let rec somme = function
| [] -> 0
| x :: l -> x + somme l;;
somme : int list -> int =
# let rec produit = function
| [] -> 1
| x :: l -> x * produit l;;
produit : int list -> int =
# let rec implose = function
| [] -> ""
| x :: l -> x ^ implose l;;
implose : string list -> string =
# implose ["Bonjour"; "tout"; "le "; "monde!"];;
- : string = "Bonjourtoutle monde!"
# let rec concat`ene_listes = function
| [] -> []
| x :: l -> x @ concat`ene_listes l;;
concat`ene_listes : ’a list list -> ’a list =
# concat`ene_listes [[1]; [2; 3]; [4; 5; 6]];;
- : int list = [1; 2; 3; 4; 5; 6]
On constate que toutes ces fonctions utilisent le mˆeme sch´ema r´ecursif : en cas de liste
vide, on rend un certain ´el´ement de base ; en cas de liste non vide, on appelle une
fonction `a deux arguments, avec pour premier argument la tˆete de la liste et pour
second argument un appel r´ecursif sur la fin de la liste. Pour somme l’´el´ement de base
est 0 et l’op´eration est +, pour produit c’est 1 et *, pour implose c’est "" et ^,
enfin pour concat`ene_listes c’est [] et @. Pour obtenir notre fonctionnelle g´en´erale
qui impl´emente ce sch´ema de programme, il nous suffit donc d’abstraire la fonction et
l’´el´ement de base.
Une petite remarque syntaxique au pr´ealable : toutes les op´erations utilis´ees ici sont
infixes. Pour ´ecrire la fonctionnelle, nous utilisons un argument fonctionnel normal
(donc pr´efixe). Il faut donc relire le code des exemples avec des op´erations pr´efixes : par
exemple pour somme, l’op´eration pr´efixe correspondant `a + est la fonction pr´ed´efinie
add_int, c’est-`a-dire function x -> function y -> x + y. Notre fonctionnelle
s’´ecrit maintenant tr`es facilement :
# let rec it´erateur_sur_listes f b = function
| [] -> b
| x :: l -> f x (it´erateur_sur_listes f b l);;
it´erateur_sur_listes : (’a -> ’b -> ’b) -> ’b -> ’a list -> ’b =
Pour d´efinir somme en utilisant l’it´erateur, on ´ecrira simplement :
# let somme l = it´erateur_sur_listes add_int 0 l;;
somme : int list -> int =
Fonctionnelles complexes sur les listes 93
# somme [1; 2; 3];;
- : int = 6
D’autres programmes ressortissent du mˆeme sch´ema. Consid´erons par exemple la fonction
qui calcule la longueur d’une liste, qui est pr´ed´efinie en Caml sous le nom de
list_length. Elle s’´ecrit sans difficult´e :
# let rec list_length = function
| [] -> 0
| x :: l -> 1 + list_length l;;
list_length : ’a list -> int =
C’est encore le mˆeme sch´ema : l’´el´ement de base est 0, l’op´eration est l’addition de 1.
On peut donc ´ecrire
# let list_length l =
it´erateur_sur_listes (function x -> function y -> 1 + y) 0 l;;
list_length : ’a list -> int =
# list_length [0; 3; 5; 7];;
- : int = 4
On ´ecrit de mˆeme la concat´enation des listes, `a l’aide d’une fonction auxiliaire devant
qui recopie une liste devant une autre.
# let rec devant l2 = function
| [] -> l2
| x :: l -> x :: devant l2 l;;
devant : ’a list -> ’a list -> ’a list =
# devant [4; 5; 6] [1; 2; 3];;
- : int list = [1; 2; 3; 4; 5; 6]
# let concat`ene l1 l2 = devant l2 l1;;
concat`ene : ’a list -> ’a list -> ’a list =
La fonction devant suit ´egalement le mˆeme sch´ema, avec ´el´ement de base l2 et
op´eration « :: ».
# let devant l2 =
it´erateur_sur_listes (function x -> function y -> x :: y) l2;;
devant : ’a list -> ’a list -> ’a list =
# devant [4; 5; 6] [1; 2; 3];;
- : int list = [1; 2; 3; 4; 5; 6]
Notion d’accumulation r´ecursive
Un autre sch´ema r´ecursif qui revient souvent est l’accumulation. Par exemple, pour
´ecrire la fonction somme, il est naturel d’ajouter les ´el´ements de la liste `a un accumulateur,
qu’on rendra en r´esultat quand on arrivera `a la fin de la liste. Nous sommes donc
amen´es `a ´ecrire la fonction somme_accu suivante, qui accumule les ´el´ements d’une liste
dans son accumulateur argument accu :
# let rec somme_accu accu = function
| [] -> accu
| x :: l -> somme_accu (x + accu) l;;
somme_accu : int -> int list -> int =
94 Listes
Il est clair qu’on obtient la somme des ´el´ements d’une liste en appelant somme_accu
avec un accumulateur valant initialement 0.
# let somme l = somme_accu 0 l;;
somme : int list -> int =
# somme [1; 2; 3];;
- : int = 6
La fonctionnelle g´en´erale correspondant au code de somme_accu est simplement :
# let rec accumulateur_sur_listes f accu = function
| [] -> accu
| x :: l -> accumulateur_sur_listes f (f x accu) l;;
accumulateur_sur_listes : (’a -> ’b -> ’b) -> ’b -> ’a list -> ’b =
La fonction somme_accu s’obtient maintenant en utilisant accumulateur_sur_listes
avec l’addition :
# let somme_accu l =
accumulateur_sur_listes
(function x -> function accu -> x + accu) l;;
somme_accu : int -> int list -> int =
# let somme l = somme_accu 0 l;;
somme : int list -> int =
# somme [1; 2; 3];;
- : int = 6
Les fonctionnelles pr´ed´efinies en Caml sont analogues `a celles que nous venons de
d´egager, avec cependant des diff´erences minimes. La fonctionnelle it´erateur_sur_listes
correspond `a list_it et accumulateur_sur_listes est ´equivalente `a it_list. Nous
d´ecrivons maintenant ces fonctionnelles pr´ed´efinies en leur donnant une interpr´etation
graphique.
Accumuler avec les ´el´ements d’une liste
´E
tant donn´es trois arguments f, b et l, la fonctionnelle it_list effectue de multiples
compositions de la fonction `a deux arguments f, en utilisant les ´el´ements de la liste
l comme seconds arguments de f. La valeur de base b est utilis´ee pour le premier
argument du premier appel `a f, puis le r´esultat de chaque appel `a f est pass´e en
premier argument de l’appel suivant. it_list est caract´eris´ee par :
it_list f b [e1; e2; . . . ; en] = (f (. . . (f (f b e1) e2) . . .) en).
Le code de it_list est :
# let rec it_list f b = function
| [] -> b
| x :: l -> it_list f (f b x) l;;
it_list : (’a -> ’b -> ’a) -> ’a -> ’b list -> ’a =
Intuitivement, si l’on peut dire, it_list fait de la « r´e´ecriture de liste » : elle remplace
tous les ; de la liste par f (consid´er´ee comme un op´erateur binaire infixe) et ajoute la
valeur initiale b au premier appel `a f. Graphiquement, l’effet calculatoire de it_list
se repr´esente par la transformation :
Fonctionnelles complexes sur les listes 95
::
::
. . .
::
e1
e2
en []
l
f
f
. . .
f
en
en−1
b e1
it_list f l b
it_list
Par exemple, supposons que f soit l’addition +. Nous obtenons
it_list f b [e1; e2; . . . ; en] = b + e1 + e2 + · · · + en.
Maintenant nous pouvons ´ecrire la fonction somme en utilisant it_list :
# let ajoute x y = x + y;;
ajoute : int -> int -> int =
# let somme l = it_list ajoute 0 l;;
somme : int list -> int =
# somme [1; 2; 3];;
- : int = 6
Allons encore un peu plus loin : il est inutile de d´efinir la fonction ajoute qui est
´equivalente `a l’op´erateur infixe +. En effet, en Caml on fait r´ef´erence `a la forme pr´efixe
d’un op´erateur infixe (comme +) en le faisant simplement pr´ec´eder du mot-cl´e prefix :
# (prefix +);;
- : int -> int -> int =
# (prefix +) 1 2;;
- : int = 3
Cette facilit´e conduit `a des d´efinitions de somme et produit en une ligne (apr`es une
´etape de -contraction) :
# let somme = it_list (prefix +) 0
and produit = it_list (prefix *) 1;;
somme : int list -> int =
produit : int list -> int =
Graphiquement, cela s’exprime par les deux r´e´ecritures suivantes :
::
::
. . .
::
e1
e2
en []
l
+
+
. . .
+
en
en−1
0 e1
it_list (prefix +) 0 l
somme
::
::
. . .
::
e1
e2
en []
l
*
*
. . .
*
en
en−1
1 e1
it_list (prefix *) 1 l
produit
96 Listes
Est-ce plus clair que notre premi`ere version de somme d´efinie par filtrage sur les listes ?
Pas pour les auteurs de ce livre en tout cas : nous pensons que cette ´ecriture semblera
souvent obscure `a d’autres programmeurs, y compris vous-mˆeme trois mois apr`es avoir
´ecrit ce code ! Si vous voulez ˆetre lisible, ´evitez ce style de « programmation sans variables
», particuli`erement si vous ˆetes capable d’´ecrire du code qui utilise encore plus
de fonctionnelles que celui de somme : ce code peut devenir trop « ´el´egant » pour ˆetre
maintenu . . .
Accumuler encore
´E
tant donn´es trois arguments f, b et l, la fonctionnelle list_it effectue de multiples
compositions de la fonction `a deux arguments f, en utilisant les ´el´ements de la liste l
comme premiers arguments de f ; l’´el´ement de base b est utilis´e pour le second argument
du premier appel `a f, puis le r´esultat de chaque appel `a f est pass´e en second argument
de l’appel suivant. list_it est caract´eris´ee par :
list_it f [e1; e2; . . . ; en] b = f e1 (f e2( . . . (f en b) . . . )).
En termes encore plus savants et en utilisant l’op´erateur math´ematique de composition
des fonctions ◦, on ´ecrirait :
list_it f [e1; e2; . . . ; en] b = ((f e1) ◦ (f e2) ◦ · · · ◦ (f en)) (b)
# let rec list_it f l b =
match l with
| [] -> b
| x :: reste -> f x (list_it f reste b);;
list_it : (’a -> ’b -> ’b) -> ’a list -> ’b -> ’b =
Intuitivement, list_it fait aussi de la « r´e´ecriture de liste » : elle remplace toutes les
occurrences de « :: » par f et le « [] » final par la valeur initiale b.
::
::
. . .
::
e1
e2
en []
l
f
f
. . .
f
e1
e2
en b
list_it f l b
list_it
Par exemple, la fonction qui copie une liste est facile `a d´efinir : elle doit remplacer tous
les ::de la liste par d’autres :: et le [] final par []. La fonction f qui fait ce travail de
ne rien modifier et donc de remplacer ::par :: , est simplement la fonction function
x -> function l -> x :: l. Nous l’appelons cons et la d´efinissons ainsi :
# let cons x l = x :: l;;
cons : ’a -> ’a list -> ’a list =
Avec list_it, nous ´ecrivons facilement la fonction de copie :
Fonctionnelles complexes sur les listes 97
::
::
. . .
::
e1
e2
en []
l
cons
cons
. . .
cons
e1
e2
en []
list_it cons l []
list_it
# let copie_liste l = list_it cons l [];;
copie_liste : ’a list -> ’a list =
# copie_liste [1;2;3];;
- : int list = [1; 2; 3]
Cette fonction n’est pas vraiment utile, sauf pour copier une liste devant une autre. En
effet, si nous voulons maintenant concat´ener deux listes l1 et l2 (mettre les deux listes
bout `a bout), il suffit de mettre l2 `a la fin de l1, donc de remplacer le [] final de l1 par
toute la liste l2.
::
::
. . .
::
e1
e2
en []
l1
::
::
. . .
::
e1
e2
en l2
concat`ene l1 l2
Il suffit donc d’appeler list_it sur l1 avec la fonction cons et l’´el´ement final l2.
# let concat`ene l1 l2 = list_it cons l1 l2;;
concat`ene : ’a list -> ’a list -> ’a list =
# concat`ene [1; 2; 3] [4; 5; 6];;
- : int list = [1; 2; 3; 4; 5; 6]
::
::
. . .
::
e1
e2
en []
l1
::
::
. . .
::
e1
e2
en l2
list_it cons l1 l2
concat`ene
D´efinitions r´ecursives locales
Nous revenons sur le code de la fonction map pour faire la remarque suivante : ´etant
donn´ee une fonction f, map se contente de boucler sur une liste, en appliquant f. C’est
pourquoi il nous suffit de d´efinir une fonction r´ecursive `a l’int´erieur de map, qui saura
appliquer f sur les ´el´ements d’une liste quelconque :
# let map f =
let rec map_fonction_f = function
| [] -> []
| x :: l -> f x :: map_fonction_f l in
(function liste -> map_fonction_f liste);;
map : (’a -> ’b) -> ’a list -> ’b list =
98 Listes
Ainsi, map n’est plus r´ecursive, mais comporte une d´efinition locale de fonction r´ecursive.
On simplifie encore ce code en utilisant la r`egle , qui stipule que
(function liste -> map_fonction_f liste)
est ´equivalent `a la forme plus simple map_fonction_f. On obtient alors le code suivant :
# let map f =
let rec map_fonction_f = function
| [] -> []
| x :: l -> f x :: map_fonction_f l in
map_fonction_f;;
map : (’a -> ’b) -> ’a list -> ’b list =
Cette vision de map correspond `a celle d’une fonctionnelle qui, appliqu´ee `a une fonction
f, retourne la fonction qui it`ere f sur une liste. Avec cette vision nous pourrions ´ecrire :
# let successeur x = x + 1;;
successeur : int -> int =
# let liste_des_successeurs = map successeur;;
liste_des_successeurs : int list -> int list =
# liste_des_successeurs [0; 1; 2];;
- : int list = [1; 2; 3]
Ce style de programmation n’est pas `a encourager : la d´efinition na¨ıve de map nous
paraˆıt plus claire. D’autre part, la d´efinition de map avec une fonction locale ne se
justifie pas non plus par un gain majeur en efficacit´e : suivant les compilateurs, elle sera
un peu plus ou un peu moins efficace que la d´efinition na¨ıve.
En revanche, dans le cas o`u une fonction r´ecursive prend beaucoup de param`etres en
argument et o`u ces param`etres sont inchang´es dans les appels r´ecursifs, on peut admettre
de d´efinir localement une fonction r´ecursive qui s’appelle avec les seuls param`etres
modifi´es. En ce cas, on remplacerait la d´efinition d’une fonction f `a plusieurs param`etres
x1, x2, . . . , xn, dont les appels r´ecursifs ne font varier que xn, par une d´efinition comportant
une fonction locale ayant xn pour seul param`etre. Ainsi
let rec f x1 x2 x3 ... xn =
... f x1 x2 x3...(xn + 1) ... f x1 x2 x3...(xn - 1) ...;;
deviendrait
let f x1 x2 x3 ... =
let rec f_locale xn =
... f_locale (xn + 1) ... f_locale (xn - 1) ... in
f_locale;;
Ce style ne se justifie que pour des raisons de concision ; il ne doit pas ˆetre ´erig´e en
syst`eme.
5.10 Efficacit´e des fonctions sur les listes : ´etude de cas
Dans cette section, nous analysons la complexit´e de deux fonctions, implose et rev.
L’´etude de complexit´e nous am`ene `a ´ecrire des versions plus efficaces, en style imp´eratif
pour implose et en style purement fonctionnel pour rev. L’am´elioration obtenue est
bas´ee dans les deux cas sur l’emploi d’un accumulateur qui maintient les r´esultats
Efficacit´e des fonctions sur les listes : ´etude de cas 99
interm´ediaires de la fonction. L’optimisation ne d´epend donc pas obligatoirement du
style de programmation utilis´e, puisqu’une mˆeme id´ee sert dans les deux styles et pour
des programmes diff´erents.
La fonction implose, version fonctionnelle
La fonction implose concat`ene toutes les chaˆınes d’une liste de chaˆınes. Nous en
avons d´ej`a ´ecrit la version la plus na¨ıve dans la section 5.9. Raisonnons graphiquement :
pour obtenir la concat´enation de toutes les chaˆınes d’une liste il faut « r´e´ecrire » la
liste en rempla¸cant les « :: » par des « ^ » et le symbole [] final par la chaˆıne vide.
Alg´ebriquement, si l’on note lc la liste argument, [c1; c2; . . . ; cn], on a
implose [c1; c2; . . . ; cn] = c1 ^ c2^ . . . ^ cn ^ ""
= list_it (prefix ^) lc ""
::
::
. . .
::
c1
c2
cn []
lc
^
^
. . .
^
c1
c2
cn ""
list_it (prefix ^) lc ""
implose
De la mˆeme fa¸con, mais en utilisant it_list au lieu de list_it :
implose [c1; c2; . . . ; cn] = "" ^ c1^ . . . ^ cn
= it_list (prefix ^) "" lc
On obtient donc :
# let implose lc = list_it (prefix ^) lc "";;
implose : string list -> string =
# let implose2 lc = it_list (prefix ^) "" lc;;
implose2 : string list -> string =
implose2 se simplifie par la r`egle , pour donner un code extrˆemement similaire `a celui
de somme (op´eration binaire prefix ^ au lieu de prefix + et ´el´ement neutre "" au lieu
de 0) :
# let implose2 = it_list (prefix ^) "";;
implose2 : string list -> string =
Cette ´ecriture est extrˆemement compacte ; on peut mˆeme la consid´erer comme ´el´egante.
Cependant l’emploi des it´erateurs, en produisant un code compact, a tendance `a cacher
la complexit´e des algorithmes. Nous allons voir que notre fonction implose a une complexit
´e ´elev´ee (quadratique en le nombre de chaˆınes concat´en´ees), `a cause de la cr´eation
de nombreuses chaˆınes interm´ediaires.
100 Listes
L’op´erateur de concat´enation de chaˆınes
Pour calculer la complexit´e de la fonction implose, il nous faut r´efl´echir sur le fonctionnement
de l’op´erateur ^ de concat´enation de chaˆınes. ´Etant donn´ees deux chaˆınes
de caract`eres c1 et c2 en arguments, ^ alloue une nouvelle chaˆıne de caract`eres pour y
loger la concat´enation des deux chaˆınes, puis y recopie c1 et c2 correctement d´ecal´ees.
c1
r r r r r r r r r r r r r r r
c2
b b b b b b b b b b
r r r r r r r r r r r r r r r b b b b b b b b b b
c1 ^ c2
A
AAU
Nous ´ecrivons l’op´erateur ^ sous la forme d’une fonction pr´efixe concat :
# let concat c1 c2 =
let r´esultat =
create_string (string_length c1 + string_length c2) in
blit_string c1 0 r´esultat 0 (string_length c1);
blit_string c2 0 r´esultat (string_length c1) (string_length c2);
r´esultat;;
concat : string -> string -> string =
On rappelle que l’appel de la proc´edure
blit_string source indice_source destination indice_destination
nombre_de_caract`eres_`a_transf´erer
transf`ere nombre_de_caract`eres_`a_transf´erer dans la chaˆıne destination `a partir
de l’indice indice_destination. Ces caract`eres sont ceux de la chaˆıne source `a partir
de l’indice indice_source.
source
nombre_de_caract`eres_`a_transf´erer
-
r r r r r r r r r
6
indice_source
J
J
JJ^
destination r r r r r r r r r
6
indice_destination
Pour calculer la complexit´e de la fonction implose, nous consid´ererons que le coˆut d’une
concat´enation est ind´ependant de la longueur des deux chaˆınes concat´en´ees, ou encore
que toutes les chaˆınes sont d’´egale longueur et mˆeme de longueur 1 pour simplifier
encore. Nous supposons que la liste argument lc comprend n chaˆınes c1, c2, . . . cn. `A
chaque chaˆıne ci de la liste de chaˆınes argument, on recopie le pr´ec´edent r´esultat dans
une nouvelle chaˆıne f, puis on recopie la chaˆıne ci dans f. On alloue donc autant de
chaˆınes que de r´esultats interm´ediaires, soit n. De plus, c1 est recopi´ee une fois, c2
deux fois, et cn est recopi´ee n fois. Ce qui donne donc 1 + 2 + 3 + · · · + n caract`eres
copi´es. Or, un calcul facile (il suffit d’ajouter les termes de la somme en les groupant
astucieusement, premier avec dernier, deuxi`eme avec avant-dernier, etc.) montre que
1 + 2 + 3 + · · · + n =
n × (n + 1)
2
Efficacit´e des fonctions sur les listes : ´etude de cas 101
Quand n est grand, (n × (n + 1))/2 est proche de n2/2. Notre fonction a donc une
complexit´e de l’ordre de n2 : elle est quadratique. Nous avons d´ej`a vu que c’est une
complexit´e importante. Nous allons tenter de l’am´eliorer.
La fonction implose, version imp´erative
L’id´ee, tr`es simple, est de calculer d’abord la longueur de la chaˆıne n´ecessaire au
r´esultat final, de l’allouer, puis d’y copier toutes les chaˆınes de la liste.
# let implose cha^ınes =
let longueur = ref 0 in
do_list
(function ch ->
longueur := string_length ch + !longueur)
cha^ınes;
let r´esultat = create_string !longueur
and position = ref 0 in
do_list
(function ch ->
blit_string ch 0 r´esultat !position (string_length ch);
position := !position + string_length ch)
cha^ınes;
r´esultat;;
implose : string list -> string =
La complexit´e de cette version est alors d’une seule allocation de chaˆıne et de n copies
de caract`eres : cette version est donc lin´eaire. La diff´erence d’efficacit´e est ´enorme : pour
104 chaˆınes de caract`eres, la premi`ere version n´ecessite 108/2 copies, soit 5000 fois plus
que l’algorithme lin´eaire. En d’autres termes, si la version lin´eaire demande 1 seconde
pour r´ealiser la concat´enation des 104 chaˆınes, alors la version quadratique n´ecessite
plus de 1 heure de calcul !
Nous avons ainsi optimis´e la fonction implose en passant dans le monde imp´eratif.
Cette d´emarche n’est pas obligatoire ; l’optimisation consiste aussi `a remplacer un algorithme
du monde fonctionnel par un autre plus efficace mais sans quitter le monde
fonctionnel. C’est ce que nous allons voir maintenant.
Retournement d’une liste
La fonction rev est un exemple embl´ematique de fonction simple qui a pourtant
un comportement catastrophique si l’on n’a pas le souci de r´efl´echir `a la complexit´e de
ses programmes. La fonction rev renvoie sa liste argument `a l’envers. Ici, l’analyse de
complexit´e nous sugg`ere un programme fonctionnel bien meilleur.
On ´ecrit une version tr`es na¨ıve de rev en se basant sur le raisonnement suivant :
• Si la liste est vide, son « envers » est aussi vide.
• Si la liste n’est pas vide, il suffit d’ajouter son premier ´el´ement `a la fin du reste
de la liste `a l’envers.
Cela se traduit imm´ediatement par la d´efinition :
102 Listes
# let rec rev = function
| [] -> []
| x :: l -> concat`ene (rev l) [x];;
rev : ’a list -> ’a list =
# rev [1; 2; 3];;
- : int list = [3; 2; 1]
Cette version est encore plus jolie avec la version infixe pr´ed´efinie de concat`ene,
l’op´erateur @.
# let rec rev = function
| [] -> []
| x :: l -> rev l @ [x];;
rev : ’a list -> ’a list =
Cet algorithme est simple, le programme extrˆemement concis, mais malheureusement
inefficace, car on ne cesse de recopier des listes en utilisant la fonction concat`ene.
Suivons le d´eroulement de l’´evaluation du renversement de la liste [1; 2; 3] :
rev [1 ; 2 ; 3]
→ concat`ene (rev [2 ; 3]) [1]
→ concat`ene (concat`ene (rev [3]) [2]) [1]
→ concat`ene (concat`ene (concat`ene (rev []) [3]) [2]) [1]
→ concat`ene (concat`ene (concat`ene [] [3]) [2]) [1]
→ concat`ene (concat`ene [3] [2]) [1]
→ concat`ene (3 : : [2]) [1]
→ concat`ene [3 ; 2] [1]
→ 3 : : 2 : : [1]
→ [3 ; 2 ; 1]
Il apparaˆıt que le premier ´el´ement de la liste argument, 1, a ´et´e « cons´e » une fois (pour
fabriquer la liste [1]). Le second, 2, a ´et´e « cons´e » deux fois (une fois pour fabriquer la
liste [2] et une fois pour obtenir la liste interm´ediaire [2; 1]). Le troisi`eme, 3, a ´et´e
« cons´e » trois fois. On montre facilement que si la liste l a n ´el´ements, cet algorithme
cr´ee une cellule de liste pour le premier ´el´ement, deux pour le second, . . . , et finalement
n cellules pour le dernier ´el´ement. Le nombre total de cellules cr´ees est donc encore la
somme 1 + 2 + 3 + · · · + n, qui vaut n × (n + 1)/2 : l’algorithme est quadratique. Le
ph´enom`ene de copie r´ecursive des r´esultats partiels conduisant `a un algorithme en n2
est le mˆeme que pour la fonction implose.
Pour am´eliorer cet algorithme, il faut utiliser une m´ethode tr`es g´en´erale : pour
construire directement le r´esultat, on ajoute un argument suppl´ementaire `a la fonction.
Cet argument joue le rˆole d’un accumulateur, car on y m´emorise les r´esultats partiels
de la fonction lors des appels r´ecursifs. Cela conduit `a ´ecrire une fonction elle aussi plus
g´en´erale, dans la mesure o`u il est possible maintenant de l’appeler avec un accumulateur
non vide au d´epart. Prenant un peu de recul, on d´efinit donc une fonction auxiliaire
concat`ene_`a_l’envers, qui ´etant donn´es une liste et un accumulateur, recopie la liste
en tˆete de l’accumulateur :
# let rec concat`ene_`a_l’envers accu = function
| [] -> accu
| x :: l -> concat`ene_`a_l’envers (x :: accu) l;;
concat`ene_`a_l’envers : ’a list -> ’a list -> ’a list =
Listes et r´ecurrence 103
# concat`ene_`a_l’envers [0] [1; 2; 3];;
- : int list = [3; 2; 1; 0]
Illustrons graphiquement le comportement de cette fonction. On part d’une liste l et
d’un accumulateur accu qui contient ´eventuellement d´ej`a des ´el´ements :
::
::
::
1
2
3 []
l
::
x1 . . .
. . . []
accu
Puis on recopie la tˆete de la liste l dans l’accumulateur, obtenant :
::
2 ::
3 []
reste l
::
::
. . .
1
x1
. . . []
accu
`A
l’´etape suivante on aura :
::
3 []
reste(reste l)
::
::
::
. . .
2
1
x1
. . . []
accu
Il est clair maintenant que l’accumulateur engrange les ´el´ements de la liste l `a l’envers.
La fonction rev s’en d´eduit simplement, en appelant concat`ene_`a_l’envers avec un
accumulateur vide :
# let rev l = concat`ene_`a_l’envers [] l;;
rev : ’a list -> ’a list =
# rev [1; 2; 3];;
- : int list = [3; 2; 1]
Notre algorithme est maintenant lin´eaire. Cette m´ethode d’accumulation des r´esultats
interm´ediaires dans un argument suppl´ementaire de la fonction est souvent une bonne
piste `a suivre pour optimiser une fonction, quand cette fonction pose des probl`emes
d’efficacit´e. Encore faut-il prouver que la fonction sujette `a optimisation est r´eellement
le goulet d’´etranglement du programme, puis d´emontrer par une ´etude de complexit´e
que l’optimisation va vraiment am´eliorer les performances. C’est ´evidemment tr`es difficile.
En r`egle g´en´erale, on se contentera d’´ecrire des programmes corrects et lisibles.
5.11 Listes et r´ecurrence
Nous montrons dans cette section comment prouver des propri´et´es sur les listes.
Bien qu’un peu th´eorique, ce n’est pas tr`es complexe, puisqu’il s’agit d’une extension
simple du principe de r´ecurrence.
104 Listes
Lorsque nous avons ´ecrit des fonctions r´ecursives sur les entiers, nous apportions
la preuve de leurs propri´et´es en utilisant le principe de r´ecurrence. Mais ce principe
ne s’applique plus dans le cas des listes, puisqu’il concerne uniquement les propri´et´es
d´efinies sur les nombres entiers. Comment prouver des propri´et´es des listes ? Il suffit de
se ramener au cas des entiers en raisonnant sur le nombre entier qui mesure la longueur
de la liste. Le principe de r´ecurrence nous permet alors de d´emontrer qu’une propri´et´e
est vraie pour des listes de n’importe quelle longueur, donc pour toutes les listes. Une
application directe du principe de r´ecurrence nous permet ainsi d’´etablir que :
Si une propri´et´e P est vraie pour une liste de longueur 0, et si d`es qu’elle est
vraie pour une liste de longueur n elle est vraie pour une liste de longueur
n + 1, alors P est vraie pour des listes de n’importe quelle longueur.
Si l’on remarque qu’il n’existe qu’une seule liste de longueur 0, la liste vide, et qu’une
liste de longueur n + 1 s’obtient forc´ement en rajoutant un ´el´ement `a une liste de
longueur n, on obtient maintenant l’´enonc´e :
Si une propri´et´e P est vraie pour [] et si d`es que P est vraie pour l alors
P est vraie pour x:: l, alors P est vraie pour toutes les listes.
C’est ce qu’on appelle le principe de r´ecurrence structurelle sur les listes. Remarquons
que ces deux cas, [] et x:: l, sont justement les deux cas du filtrage d’une fonction
r´ecursive sur les listes. Cela justifie nos raisonnements informels pr´ec´edents, quand
nous disions « un petit appel r´ecursif et le tour est jou´e », ou bien que nous appelions
r´ecursivement une fonction pas encore ´ecrite en pensant « qu’elle saurait bien faire toute
seule ». Cela justifie aussi le qualificatif « structurelle » de ce principe de r´ecurrence,
puisqu’on raisonne en fait sur la structure des listes.
Prouvons par exemple que la fonction ins`ere, qui nous a servi de fonction auxiliaire
pour le tri par insertion, ins`ere correctement un ´el´ement dans une liste. Nous consid´erons
donc la propri´et´e P(l) suivante : sous l’hypoth`ese que l est une liste bien tri´ee, ins`ere
´el´ement l est une liste, elle aussi bien tri´ee, qui comprend ´el´ement et tous les ´el´ements
de la liste l.
1. P est vraie pour []. En effet, ins`ere ´el´ement []vaut [´el´ement], qui est forc´ement
bien tri´ee, comprend ´el´ement et tous les ´el´ements de la liste vide.
2. Supposons P(l) vraie. Alors P(x:: l) est vraie aussi. En effet, d’apr`es la
d´efinition de la fonction ins`ere, si ´el´ement ≤ x alors ins`ere ´el´ement (x:: l) vaut
´el´ement::x:: l, qui contient ´el´ement et tous les ´el´ements de la liste argument
x:: l, et ce r´esultat est bien tri´e puisque x:: l est bien tri´ee par hypoth`ese et
que ´el´ement ≤ x. Dans le cas o`u ´el´ement > x, alors ins`ere ´el´ement (x:: l)
vaut x:: (ins`ere ´el´ement l). Cette liste est bien tri´ee car, d’apr`es l’hypoth`ese
de r´ecurrence, P(l) est vraie, donc (ins`ere ´el´ement l) est bien tri´ee ; mais x
est le plus petit ´el´ement de x:: (ins`ere ´el´ement l), puisque c’´etait d´ej`a le plus
petit ´el´ement de (x:: l) et qu’il est plus petit que ´el´ement. De plus la liste
x:: (ins`ere ´el´ement l) contient ´el´ement et tous les ´el´ements de (x:: l) car
elle contient ´evidemment x et par hypoth`ese de r´ecurrence (ins`ere ´el´ement l)
contient tous les ´el´ements de l et l’´el´ement `a ins´erer ´el´ement.
En conclusion, notre fonction ins`ere fonctionne : P est vraie pour toute liste. Donc, si
l est une liste bien tri´ee, ins`ere ´el´ement l est bien tri´ee et comprend ´el´ement en plus
`A
la recherche de l’it´erateur unique 105
de tous les ´el´ements de la liste l.
Les propri´et´es des fonctions d´efinies sur les listes se d´emontreront toujours de fa¸con
analogue, en suivant le filtrage utilis´e par la fonction pour diriger la preuve par induction
structurelle (induction signifie d´emonstration par r´ecurrence).
5.12 `A la recherche de l’it´erateur unique
Nous avons r´eussi `a exprimer la fonction implose en fonction de it_list et de
list_it. La question se pose donc du choix de l’it´erateur le plus efficace et de l’utilit´e
d’en avoir deux.
R´ecursivit´e terminale
En ce qui concerne l’efficacit´e, it_list est l´eg`erement plus efficace que list_it,
car il est r´ecursif terminal, ce qui signifie qu’il peut s’impl´ementer en machine par un
simple saut : il ne laisse pas de calculs en suspens. Par exemple, la fonctionnelle do_list
est r´ecursive terminale :
# let rec do_list f = function
| [] -> ()
| x :: l -> f x; do_list f l;;
do_list : (’a -> ’b) -> ’a list -> unit =
En effet, apr`es avoir ex´ecut´e f x on rappelle directement do_list en oubliant le calcul
pr´ec´edent. En revanche, map n’est pas r´ecursive terminale :
# let rec map f = function
| [] -> []
| x :: l -> f x :: map f l;;
map : (’a -> ’b) -> ’a list -> ’b list =
Lors de l’appel r´ecursif map f l, il faut sauvegarder quelque part la valeur de f x
pour l’ajouter en tˆete du r´esultat de map f l. G´en´eralement, ce r´esultat interm´ediaire
est sauvegard´e dans un tableau en attendant le retour de l’appel r´ecursif. Ce tableau
est appel´e pile d’ex´ecution du programme. Comme toutes les ressources m´emoire, la
pile est de taille finie et une fonction qui travaille en espace de pile constant comme
do_list est pr´ef´erable `a une fonction qui consomme de la pile comme map. Lorsqu’on a
le choix entre une fonction r´ecursive terminale et une autre qui ne l’est pas, on pr´ef`ere
g´en´eralement celle qui est r´ecursive terminale, pourvu qu’elle reste simple : rendre une
r´ecursion terminale ne justifie g´en´eralement pas qu’on complique le programme.
It´erateurs et effets
L’it´erateur list_it est tr`es puissant : en ce qui concerne les calculs proprement
dits, il n’est pas n´ecessaire d’en avoir d’autre. Par exemple, map s’´ecrit tr`es facilement
avec list_it.
# let map f l =
list_it (function x -> function res -> f x :: res) l [];;
map : (’a -> ’b) -> ’a list -> ’b list =
106 Listes
# map successeur [1; 2; 3];;
- : int list = [2; 3; 4]
Dans le mˆeme esprit il serait tentant d’´ecrire do_list en fonction de list_it.
# let do_list f l =
list_it (function x -> function y -> f x; y) l ();;
do_list : (’a -> ’b) -> ’a list -> unit =
# do_list print_int [1; 2; 3];;
321- : unit = ()
La fonction est bien appliqu´ee sur tous les ´el´ements de la liste, mais `a l’envers. Les
effets se produisent donc dans l’ordre inverse de la vraie fonction do_list. Cependant,
il suffit d’exprimer do_list en fonction de it_list pour que tout rentre dans l’ordre.
# let do_list f l =
it_list (function y -> function x -> f x; y) () l;;
do_list : (’a -> ’b) -> ’a list -> unit =
# do_list print_int [1; 2; 3];;
123- : unit = ()
Tentons alors d’exprimer ´egalement map en fonction de it_list.
# let map f l =
it_list (function res -> function x -> f x :: res) [] l;;
map : (’a -> ’b) -> ’a list -> ’b list =
Malheureusement, la liste r´esultat n’est pas dans le bon ordre.
# map successeur [1; 2; 3];;
- : int list = [4; 3; 2]
# map (function x -> print_int x; successeur x) [1; 2; 3];;
123- : int list = [4; 3; 2]
En effet, it_list accumule les r´esultats dans la liste res en les ajoutant en tˆete de liste.
Comme dans le cas de rev, on obtient ainsi la liste des r´esultats `a l’envers. D’ailleurs,
si l’on ne fait qu’accumuler les ´el´ements sur la liste des r´esultats pr´ec´edents, on obtient
effectivement une autre version de rev :
# let rev l = it_list (function res -> function x -> x :: res) [] l;;
rev : ’a list -> ’a list =
# rev [1; 2; 3];;
- : int list = [3; 2; 1]
Cette version peu commune de rev est ´egalement lin´eaire et r´ecursive terminale.
En conclusion, on constate que map et do_list sont des versions sp´ecialis´ees
d’it´erateurs plus g´en´eraux. Ces fonctions gardent cependant leur int´erˆet, car elles
sont simples `a employer et `a comprendre. Du point de vue purement calculatoire,
it_list et list_it sont un tant soit peu redondants, mais ils se distinguent lorsque
les fonctions qu’ont leur applique produisent des effets. On constate une fois de plus
que les effets compliquent les choses, car ils permettent de distinguer plus finement le
comportement d’algorithmes math´ematiquement ´equivalents. On peut s’en r´ejouir ou
en avoir peur . . .
`A
la recherche de l’it´erateur unique 107
l
6
Les structures de donn´ees
O`u l’on apprend `a m´elanger les torchons et les serviettes
pour d´efinir le linge de maison.
n Caml, les types de donn´ees comprennent principalement les types somme et
les types produit, c’est-`a-dire les types « ou » et les types « et », encore appel´es
les ´enum´erations g´en´eralis´ees et les enregistrements, ou plus techniquement
encore l’union disjointe et les produits `a champs nomm´es. Dans ce chapitre, nous introduisons
ces diff´erents types de donn´ees et les montrons `a l’oeuvre sur le probl`eme de
la repr´esentation efficace des polynˆomes.
6.1 Polynˆomes pleins et polynˆomes creux
Nous avons vu par deux fois des calculs sur les polynˆomes, d’abord repr´esent´es
par des tableaux dans le chapitre 3 (section 3.3), puis comme des listes dans le
chapitre 5 (section 5.5). Nous avons appel´e les seconds polynˆomes creux, les premiers
polynˆomes pleins. Maintenant se pose ´evidemment le probl`eme de travailler avec ces
deux repr´esentations en mˆeme temps, pour b´en´eficier des avantages de chacune d’elles :
lorsqu’un polynˆome est plein, la repr´esentation `a l’aide d’un tableau est ´economique,
car les degr´es sont implicites ; en revanche, lorsqu’un polynˆome est creux (comporte
beaucoup de coefficients nuls), la repr´esentation en liste est pr´ef´erable — quand elle
n’est pas tout simplement la seule envisageable, comme pour le polynˆome 1+x1000000.
Nous aimerions donc repr´esenter les polynˆomes par un tableau ou une liste selon le
cas, mais d´efinir des op´erations qui travaillent indiff´eremment sur l’une ou l’autre des
repr´esentations. Or, ces deux types de repr´esentations sont incompatibles au point de
vue du typage. Consid´erons la proc´edure d’impression des polynˆomes : nous avons d´efini
deux fonctions, sp´ecifiques `a chacune des repr´esentations, imprime_polyn^ome_plein
: int vect -> unit, qui imprime les polynˆomes pleins, et imprime_polyn^ome_creux
: (int * int) list -> unit, qui imprime les polynˆomes creux. Pour avoir une
primitive d’impression travaillant sur tous les polynˆomes, on aurait donc envie d’´ecrire :
let imprime_polyn^ome p =
if p « est un polynˆome plein »
then imprime_polyn^ome_plein p
110 Les structures de donn´ees
else imprime_polyn^ome_creux p;;
C’est effectivement la bonne id´ee, mais il faut la raffiner un peu : outre qu’on ne voit
pas comment impl´ementer le pr´edicat « est un polynˆome plein », il se pose ´egalement un
probl`eme de typage pour l’argument p de imprime_polyn^ome : est-ce une liste comme le
sugg`ere l’appel de fonction imprime_polyn^ome_creux p, ou un tableau pour pouvoir
ˆetre pass´e en argument `a imprime_polyn^ome_plein ? On obtiendrait forc´ement une
erreur de typage. Par exemple, en supposant que « est un polynˆome plein » renvoie
toujours la valeur true :
# let imprime_polyn^ome p =
if true then imprime_polyn^ome_plein p
else imprime_polyn^ome_creux p;;
Entr´ee interactive:
> else imprime_polyn^ome_creux p;;
> ^
Cette expression est de type int vect,
mais est utilis´ee avec le type (int * int) list.
Il faut donc m´elanger les polynˆomes creux et pleins au sein d’un mˆeme type qui les
comprenne tous les deux.
Le type polyn^ome
On d´efinit donc un nouveau type, polyn^ome, qui ´etablit explicitement le m´elange :
il indique qu’il comprend deux cas possibles, le cas des polynˆomes pleins qui seront des
tableaux d’entiers et le cas des polynˆomes creux qui seront des listes de paires d’entiers.
# type polyn^ome =
| Plein of int vect
| Creux of (int * int) list;;
Le type polyn^ome est d´efini.
Le mot-cl´e type introduit la d´efinition du nouveau type polyn^ome. Apr`es le signe =,
on ´ecrit la liste des possibilit´es du type en cours de d´efinition. Les noms Plein et
Creux sont appel´es les constructeurs de valeurs du type (s’il n’y a pas d’ambigu¨ıt´e
on dit simplement « constructeurs »). Comme d’habitude, la barre verticale | indique
l’alternative et se lit « ou ». Le mot-cl´e of indique le type de l’argument du constructeur.
Le type polyn^ome comprenant les valeurs d’un type plus les valeurs d’un autre type, on
dit que c’est un type somme. On peut maintenant cr´eer des valeurs de type polyn^ome
en appliquant l’un des deux constructeurs du type polyn^ome `a une valeur du type
correspondant. Par exemple :
# let p1 = Plein [|1; 2; 3|];;
p1 : polyn^ome = Plein [|1; 2; 3|]
# let p2 = Creux [(1, 0); (1, 100)];;
p2 : polyn^ome = Creux [1, 0; 1, 100]
Maintenant p1 et p2 sont du mˆeme type et pourront ˆetre arguments d’une mˆeme
fonction.
Polynˆomes pleins et polynˆomes creux 111
Le filtrage est ´etendu `a tous les types somme et permet, ´etant donn´ee une valeur du
type somme, de d´eterminer dans quel cas se trouve cette valeur. Pour le type polyn^ome,
le filtrage va donc nous permettre d’impl´ementer la fonction « est un polynˆome plein » :
# let est_un_polyn^ome_plein = function
| Plein _ -> true
| Creux _ -> false;;
est_un_polyn^ome_plein : polyn^ome -> bool =
Une fonction travaillant sur des valeurs de type polyn^ome fera typiquement une discrimination
sur les valeurs du type par un filtrage du genre :
let f = function
| Plein v -> ...
| Creux l -> ...;;
Remarquez que le filtrage permet `a la fois de d´eterminer le type du polynˆome et de
r´ecup´erer son tableau ou sa liste de monˆomes. C’est strictement analogue au cas des
listes o`u nous ´ecrivions :
let f = function
| [] -> ...
| x :: reste -> ...;;
C’est maintenant un jeu d’enfant que d’´ecrire la fonction d’impression des valeurs de
type polyn^ome :
# let imprime_polyn^ome = function
| Plein v -> imprime_polyn^ome_plein v
| Creux l -> imprime_polyn^ome_creux l;;
imprime_polyn^ome : polyn^ome -> unit =
# imprime_polyn^ome p1;;
1 + 2x + 3x^2- : unit = ()
# imprime_polyn^ome p2;;
1 + x^100- : unit = ()
Op´erations sur les valeurs de type polyn^ome
Nous d´efinissons l’addition et la multiplication des polynˆomes creux ou pleins.
Puisque les polynˆomes se pr´esentent sous deux formes, nous avons quatre cas `a envisager.
L’id´ee est simple :
• la somme de deux polynˆomes creux est un polynˆome creux : on appelle l’addition
des polynˆomes creux ;
• la somme de deux polynˆomes pleins est un polynˆome plein : on appelle l’addition
des polynˆomes pleins ;
• la somme de deux polynˆomes d’esp`eces diff´erentes est un polynˆome creux.
En effet, si l’un des polynˆomes est creux il comprend beaucoup de z´eros et sa somme
avec un autre polynˆome comprendra aussi beaucoup de z´eros en g´en´eral (consid´erez
par exemple (1+x+3x2)+(1+x100)). Donc, dans le cas mixte, nous appelons encore
l’addition des polynˆomes creux. Puisque l’un des polynˆomes est plein, nous avons besoin
d’une fonction qui transforme un polynˆome plein en polynˆome creux. C’est sans
112 Les structures de donn´ees
difficult´e : nous parcourons le tableau des coefficients en accumulant dans une liste les
monˆomes rencontr´es. La seule subtilit´e est de parcourir le tableau `a l’envers pour que
le dernier monˆome ajout´e `a la liste soit bien celui de degr´e 0.
# let plein_vers_creux v =
let l = ref [] in
for i = vect_length v - 1 downto 0 do
if v.(i) <> 0 then l := (v.(i), i) :: !l
done;
!l;;
plein_vers_creux : int vect -> (int * int) list =
L’addition des polynˆomes se d´efinit alors tr`es simplement :
# let ajoute_polyn^omes p1 p2 =
match p1, p2 with
| Plein v, Plein v’ -> Plein (ajoute_polyn^omes_pleins v v’)
| Creux l, Creux l’ -> Creux (ajoute_polyn^omes_creux l l’)
| Plein v, Creux l ->
Creux (ajoute_polyn^omes_creux (plein_vers_creux v) l)
| Creux l, Plein v ->
Creux (ajoute_polyn^omes_creux (plein_vers_creux v) l);;
ajoute_polyn^omes : polyn^ome -> polyn^ome -> polyn^ome =
Ce code peut ˆetre l´eg`erement simplifi´e en remarquant que les deux derniers cas du
filtrage sont presque identiques (ces deux cas se traduisent par deux clauses du filtrage
dont la partie expression est la mˆeme). Pour ´eviter cette redite, on joue sur le fait
que l’addition des polynˆomes est commutative pour traiter le dernier cas par un appel
r´ecursif `a la fonction ajoute_polyn^ome qui inverse les arguments p1 et p2.
# let rec ajoute_polyn^omes p1 p2 =
match p1, p2 with
| Plein v, Plein v’ -> Plein (ajoute_polyn^omes_pleins v v’)
| Creux l, Creux l’ -> Creux (ajoute_polyn^omes_creux l l’)
| Plein v, Creux l ->
Creux (ajoute_polyn^omes_creux (plein_vers_creux v) l)
| Creux l, Plein v ->
ajoute_polyn^omes p2 p1;;
ajoute_polyn^omes : polyn^ome -> polyn^ome -> polyn^ome =
Cette derni`ere solution permet de ne pas dupliquer de code, ce qui raccourcit l´eg`erement
le texte de la fonction et diminue la probabilit´e d’introduire une erreur en ne modifiant
qu’une des clauses lors de corrections ult´erieures du programme. En fait, lorsque
l’expression `a renvoyer est compliqu´ee, l’appel r´ecursif s’impose sans contestation possible.
Cependant, cette solution pr´esente l’inconv´enient de sugg´erer que la fonction
ajoute_polyn^ome est vraiment r´ecursive, alors qu’elle ne l’est que pour des raisons
« administratives ».
La multiplication n’est pas plus compliqu´ee :
# let rec multiplie_polyn^omes p1 p2 =
match p1, p2 with
| Plein v, Plein v’ -> Plein (multiplie_polyn^omes_pleins v v’)
| Creux l, Creux l’ -> Creux (multiplie_polyn^omes_creux l l’)
| Plein v, Creux l ->
Types sommes ´elabor´es 113
Creux (multiplie_polyn^omes_creux (plein_vers_creux v) l)
| Creux l, Plein v ->
multiplie_polyn^omes p2 p1;;
multiplie_polyn^omes : polyn^ome -> polyn^ome -> polyn^ome =
# imprime_polyn^ome (multiplie_polyn^omes p1 p2);;
1 + 2x + 3x^2 + x^100 + 2x^101 + 3x^102- : unit = ()
# let p10000 = Creux [(1, 0); (1, 10000)];;
p10000 : polyn^ome = Creux [1, 0; 1, 10000]
# imprime_polyn^ome (multiplie_polyn^omes p10000 p10000);;
1 + 2x^10000 + x^20000- : unit = ()
6.2 Types sommes ´elabor´es
Un autre exemple classique de type somme est la mod´elisation des peintures. On
suppose que les peintures sont d´ecrites soit par un nom explicite, soit par un simple
num´ero de r´ef´erence, soit par un m´elange d’autres peintures. Nous envisagerons successivement
ces trois cas et construirons donc le type peinture par raffinements successifs,
en trois ´etapes.
´E
num´erations
On consid`ere d’abord les peintures explicitement nomm´ees, en supposant qu’il en
existe trois : le Bleu, le Blanc et le Rouge. Le type peinture comporte donc trois cas :
c’est un type somme. Ces cas ne sont plus des valeurs de types diff´erents comme pour les
polynˆomes, mais simplement trois constantes. On les mod´elise par trois constructeurs
sans arguments, donc sans partie of dans la d´efinition :
# type peinture =
| Bleu
| Blanc
| Rouge;;
Le type peinture est d´efini.
Les trois constructeurs sont maintenant trois nouvelles constantes du langage Caml, de
type peinture.
# let p = Bleu;;
p : peinture = Bleu
Tout naturellement, le filtrage s’applique aussi `a ce nouveau type :
# let est_blanche = function
| Blanc -> true
| _ -> false;;
est_blanche : peinture -> bool =
# est_blanche p;;
- : bool = false
Ces types somme ne comportant que des constantes sont appel´es types ´enum´er´es. Vous
en connaissez d´ej`a : par exemple, le type bool est un type somme ´enum´er´e `a deux
constantes, true et false.
114 Les structures de donn´ees
Types `a constructeurs non constants
Nous supposons maintenant qu’il existe dans l’ensemble de toutes les peintures des
teintes qui n’ont pas de nom, mais seulement un num´ero de r´ef´erence. Nous ´etendons
donc le type peinture avec un nouveau constructeur qui prenne en compte ce cas.
Il s’agit maintenant d’un constructeur ayant un argument : le num´ero de r´ef´erence.
Appelons ce constructeur Num´ero. Par exemple, Num´ero 14 mod´elisera la peinture de
r´ef´erence num´ero 14. Nous d´efinissons donc le nouveau type des peintures comme :
# type peinture =
| Bleu
| Blanc
| Rouge
| Num´ero of int;;
Le type peinture est d´efini.
Types r´ecursifs
La prochaine ´etape est la description des m´elanges de peintures. Il existe maintenant
des peintures qui sont simplement des m´elanges de deux autres peintures (en proportions
´egales) et qu’on identifie par les peintures qui les composent. Nous introduisons
donc un nouveau constructeur M´elange avec pour argument un couple de peintures.
Notre type devient :
# type peinture =
| Bleu
| Blanc
| Rouge
| Num´ero of int
| M´elange of peinture * peinture;;
Le type peinture est d´efini.
# let m´el1 = M´elange (Bleu, Blanc);;
m´el1 : peinture = M´elange (Bleu, Blanc)
# let m´el2 = M´elange (Num´ero 0, Rouge);;
m´el2 : peinture = M´elange (Num´ero 0, Rouge)
Remarquez que le type peinture est devenu r´ecursif, puisqu’il intervient dans sa propre
d´efinition. Ainsi, on peut m´elanger n’importe quelles peintures et en particulier faire
des m´elanges de plus de deux peintures.
# let m´el3 = M´elange (m´el1,m´el2);;
m´el3 : peinture =
M´elange (M´elange (Bleu, Blanc), M´elange (Num´ero 0, Rouge))
Le filtrage sur le type peinture ne pose pas de probl`emes :
# let rec contient_du_bleu = function
| Bleu -> true
| M´elange (p1,p2) -> contient_du_bleu p1 || contient_du_bleu p2
| _ -> false;;
contient_du_bleu : peinture -> bool =
# contient_du_bleu m´el3;;
- : bool = true
Types sommes ´elabor´es 115
La d´efinition du type peinture, quoique r´ecursive, conserve tout de mˆeme un sens,
parce qu’il existe des cas de base pour arrˆeter la r´ecursion. C’est tout `a fait analogue
aux d´efinitions de fonctions r´ecursives qui pr´esentent des cas d’arrˆet simples. Les cas
de base du type, comme par exemple les constructeurs sans arguments, correspondent
souvent `a des cas de base des fonctions r´ecursives sur ce type.
Les cartes
On mod´elise tr`es ais´ement un jeu de cartes en utilisant les types somme. Les couleurs
forment un type ´enum´er´e :
# type couleur = | Tr`efle | Carreau | Coeur | Pique;;
Le type couleur est d´efini.
et les cartes un type somme `a plusieurs possibilit´es, selon les valeurs faciales des cartes :
# type carte =
| As of couleur
| Roi of couleur
| Dame of couleur
| Valet of couleur
| Petite_carte of int * couleur;;
Le type carte est d´efini.
Dans cette d´efinition, nous avons choisi de regrouper toutes les cartes qui ne sont pas
des figures sous la mˆeme d´enomination : Petite_carte. On aurait pu aussi continuer
l’´enum´eration avec des constructeurs Dix, Neuf, Huit, etc.
Pour illustrer le filtrage sur les types somme, nous d´efinissons la valeur d’une carte
`a la « belote ». Cette valeur d´epend d’une couleur particuli`ere, l’atout, choisie par les
joueurs `a chaque tour. Les cartes dont la valeur change sont le valet et le neuf : le neuf
compte d’ordinaire pour 0, mais vaut 14 quand il est de la couleur de l’atout, et le valet
d’atout vaut 20 au lieu de 2 d’ordinaire. D’autre part, les dix valent 10 points et les
autres petites cartes 0.
# let valeur_d’une_carte couleur_d’atout = function
| As _ -> 11
| Roi _ -> 4
| Dame _ -> 3
| Valet c -> if c = couleur_d’atout then 20 else 2
| Petite_carte (10, _) -> 10
| Petite_carte (9, c) -> if c = couleur_d’atout then 14 else 0
| _ -> 0;;
valeur_d’une_carte : couleur -> carte -> int =
Remarquez que la structure du filtrage de la fonction valeur_d’une_carte est tr`es
similaire `a la d´efinition du type carte. C’est un m´ecanisme fr´equent en Caml : pour
d´efinir une fonction sur un type somme, on se guide souvent sur la d´efinition du type
qui donne le squelette du filtrage `a utiliser. On le compl`ete alors pour envisager les cas
particuliers, comme ici les cas du 10 et du 9.
Cela termine les exemples de types somme. Nous donnons maintenant une
pr´esentation plus g´en´erale du concept.
116 Les structures de donn´ees
6.3 Les types somme
Les types somme servent donc `a mod´eliser des donn´ees comprenant des alternatives.
On les appelle aussi types « ou », car une donn´ee mod´elis´ee par un type somme est d’une
esp`ece ou d’une autre ou . . . Par exemple, une peinture est soit nomm´ee, soit un simple
num´ero, soit un m´elange de deux peintures ; de mˆeme, les polynˆomes sont soit pleins,
soit creux.
Les fonctions d´efinies sur un type somme op`erent g´en´eralement par filtrage sur les
´el´ements du type ; elles ont une structure tr`es voisine de la d´efinition du type. On peut
consid´erer qu’on emploie alors une programmation « dirig´ee par le filtrage » (ou dirig´ee
par les d´efinitions de type).
Remarquons qu’il est d’usage de toujours mettre une majuscule aux noms des constructeurs
de type somme, pour ne pas les confondre avec les noms de variables dans
le filtrage. Corr´elativement, il est recommand´e de toujours ´ecrire les noms de variables
en minuscules. Cette r`egle n’est pas absolue : par exemple les bool´eens true et false
d´erogent `a cette r`egle. Il est vrai que leur statut est tr`es particulier puisque ce sont des
constructeurs primitifs et des mots-cl´es du langage.
Formellement, les types somme sont l’analogue Caml de la notion math´ematique de
somme disjointe d’ensemble. Nous n’´etudierons pas cette notion, nous contentant de
l’id´ee intuitive ci-dessus.
6.4 Les types produit
Caml offre une deuxi`eme classe de structures de donn´ees, compl´ementaires des types
somme : les types produit, encore appel´es enregistrements ou records en anglais.
D´efinition des types enregistrement
Les enregistrements constituent une g´en´eralisation des n-uplets. Ils servent `a
mod´eliser les donn´ees qui ont simultan´ement plusieurs propri´et´es. On les appelle
donc aussi types « et », car ils s’utilisent pour repr´esenter une donn´ee ayant telle
caract´eristique et telle autre caract´eristique et . . . On dresse alors la liste des caract
´eristiques lors de la d´efinition du type. Chacune des caract´eristiques est accompagn´ee
de son type respectif et la liste de toutes les caract´eristiques est entour´ee d’accolades
{ }. Par exemple, un monˆome poss`ede un coefficient et un degr´e ; pour mod´eliser
les monˆomes, nous d´efinirons donc un type produit avec deux caract´eristiques,
coefficient et degr´e, toutes deux de type entier.
# type mon^ome = { coefficient : int; degr´e : int };;
Le type mon^ome est d´efini.
Pour construire une valeur de ce type, on se contente d’´enum´erer ses caract´eristiques
particuli`eres :
# let m1 = {coefficient = 1; degr´e = 0};;
m1 : mon^ome = {coefficient = 1; degr´e = 0}
Les types produit 117
Acc`es aux composantes des enregistrements
Pour acc´eder `a l’une des caract´eristiques d’un objet de type produit, il suffit de faire
suivre l’objet d’un point « . » et du nom de la caract´eristique. C’est analogue au « . »
de l’acc`es dans les tableaux et les chaˆınes de caract`eres.
# m1.coefficient;;
- : int = 1
# m1.degr´e;;
- : int = 0
Ce que nous avons appel´e « nom de caract´eristique » porte le nom technique
d’´etiquette. Une caract´eristique s’appelle aussi une rubrique, ou encore un champ de
l’enregistrement. Les ´etiquettes permettent de se lib´erer de l’ordre dans lequel on
nomme les caract´eristiques : le compilateur se charge de les mettre dans le bon ordre.
Ainsi, si l’on intervertit l’ordre des ´etiquettes, la valeur produite est la mˆeme :
# let m2 = { degr´e = 0; coefficient = 1 };;
m2 : mon^ome = {coefficient = 1; degr´e = 0}
# m1 = m2;;
- : bool = true
Filtrage des types enregistrement
Le filtrage s’´etend naturellement aux enregistrements :
# let de_degr´e_z´ero = function
| {degr´e = 0; coefficient = _} -> true
| _ -> false;;
de_degr´e_z´ero : mon^ome -> bool =
# de_degr´e_z´ero m1;;
- : bool = true
Il existe en plus une ellipse sp´eciale pour indiquer qu’on ne s’int´eresse pas au reste des
champs d’un enregistrement : on ´ecrit « ; _ » pour dire « quels que soient les autres
champs et leurs contenus ». On ´ecrirait donc la fonction de_degr´e_z´ero plus naturellement
ainsi :
# let de_degr´e_z´ero = function
| {degr´e = 0; _} -> true
| _ -> false;;
de_degr´e_z´ero : mon^ome -> bool =
On peut aussi nommer le contenu des champs et faire des synonymes. Par exemple, la
fonction qui renvoie la valeur absolue d’un monˆome s’´ecrit :
# let abs_mon^ome = function
{coefficient = a; degr´e = d} as m ->
if a < 0 then {coefficient = -a; degr´e = d} else m;;
abs_mon^ome : mon^ome -> mon^ome =
Les types enregistrement portent le nom technique de produits nomm´es `a champs
nomm´es, et les types produit en g´en´eral correspondent `a la notion math´ematique de
produit cart´esien d’ensembles. Encore une fois, nous nous contenterons de la vision
intuitive.
118 Les structures de donn´ees
6.5 M´elange de types somme et types produit
Types somme et types produit peuvent ˆetre arbitrairement m´elang´es. Ainsi, une
d´efinition plus ´elabor´ee des polynˆomes serait :
# type poly =
| Plein of int vect
| Creux of mon^ome list;;
Le type poly est d´efini.
L’avantage de cette d´efinition est d’avoir explicitement nomm´e les caract´eristiques d’un
monˆome. Par exemple, la fonction plein_vers_creux deviendrait :
# let plein_vers_creux v =
let l = ref [] in
for i = vect_length v - 1 downto 0 do
l := {degr´e = i; coefficient = v.(i)} :: !l
done;
!l;;
plein_vers_creux : int vect -> mon^ome list =
On a donc remplac´e la paire (v.(i), i) par l’enregistrement {degr´e = i;
coefficient = v.(i)} dans le code de l’ancienne fonction. La diff´erence est faible
mais elle suffit `a rendre le code plus facile `a lire et `a ´ecrire. D’ailleurs la premi`ere version
de plein_vers_creux ´ecrite au cours de la r´edaction de ce livre ´etait fausse : au lieu
de (v.(i), i) nous avions ´ecrit (i, v.(i)) parce que nous avions oubli´e dans quel
ordre nous avions d´ecid´e de mettre le degr´e et le coefficient dans les couples d’entiers
mod´elisant les monˆomes ! Cela ne se voyait pas sur le type des polynˆomes creux, la
convention ´etant simplement r´epartie dans le code des fonctions de manipulation des
polynˆomes creux. Cette erreur, ind´etectable par typage, est facilement ´evit´ee quand
on ´ecrit explicitement les noms degr´e et coefficient et que c’est le compilateur qui
r´etablit l’ordre des rubriques.
6.6 Structures de donn´ees mutables
Nous connaissons d´ej`a certaines structures de donn´ees dont le contenu est modifiable
dynamiquement : ce sont les r´ef´erences et les tableaux. Les enregistrements poss`edent
aussi cette qualit´e : lors de la d´efinition d’un type enregistrement, certains champs
peuvent ˆetre qualifi´es de «mutables », c’est-`a-dire modifiables. Le v´erificateur de type
autorise alors la modification physique du contenu du champ des objets de ce type.
Enregistrements `a champs mutables
Voici un exemple tr`es simple o`u il est n´ecessaire de modifier des champs
d’enregistrement : supposez qu’on veuille mod´eliser des comptes bancaires. En premi`ere
approximation, un compte se caract´erise par son num´ero et par le montant actuel des
d´epˆots sur le compte (le solde du compte). Si le num´ero du compte a peu de chance
de changer, en revanche le solde varie `a chaque retrait ou d´epˆot. Il faut donc que
l’´etiquette solde du type compte soit d´eclar´ee mutable `a la d´efinition du type.
Structures de donn´ees mutables 119
# type compte = { num´ero : int; mutable solde : float };;
Le type compte est d´efini.
La d´efinition d’une valeur d’un type enregistrement `a champs mutables et l’acc`es `a ses
champs ne diff`erent en rien du cas d’un type enregistrement normal.
# let compte_de_durand = {num´ero = 0; solde = 1000.0};;
compte_de_durand : compte = {num´ero = 0; solde = 1000.0}
# compte_de_durand.solde;;
- : float = 1000.0
Pour d´efinir la fonction d´ep^ot qui met `a jour le solde d’un compte lors d’un d´epˆot,
on utilise l’op´eration de modification physique d’un champ d’enregistrement, not´ee
e1.´etiquette <- e2, o`u e1 et e2 sont deux expressions et ´etiquette le nom d’une ´etiquette
d’enregistrement. L’ex´ecution de cette expression remplace le contenu du champ
´etiquette de l’enregistrement e1 par la valeur de l’expression e2. Comme toute modification
physique, cette expression renvoie la valeur « rien » (). La fonction d´ep^ot s’´ecrit
donc simplement :
# let d´ep^ot compte montant =
compte.solde <- montant +. compte.solde;;
d´ep^ot : compte -> float -> unit =
# d´ep^ot compte_de_durand 30.0;;
- : unit = ()
# compte_de_durand.solde;;
- : float = 1030.0
Variables r´emanentes
Cet exemple nous permet aussi d’aborder les r´ef´erences locales aux fonctions qui
conservent leur valeur entre les diff´erents appel `a la fonction. Nous d´efinissons la fonction
de cr´eation des comptes : elle doit n´ecessairement allouer un nouveau num´ero `a
chaque nouveau compte cr´e´e. Pour cela, il lui suffit de tenir `a jour une r´ef´erence enti`ere
contenant le dernier num´ero de compte attribu´e et de l’incr´ementer `a chaque cr´eation.
Pour s’assurer que cette r´ef´erence ne peut ˆetre modifi´ee par inadvertance dans une
autre partie du programme de gestion des comptes, on la rend compl`etement locale au
corps de la fonction qui cr´ee les comptes :
# let cr´ee_compte =
let num´ero_de_compte = ref 0 in
(function d´epot ->
num´ero_de_compte := !num´ero_de_compte + 1;
{num´ero = !num´ero_de_compte; solde = d´epot});;
cr´ee_compte : float -> compte =
# let compte_de_dupont = cr´ee_compte 500.0;;
compte_de_dupont : compte = {num´ero = 1; solde = 500.0}
# let compte_de_duval = cr´ee_compte 1000.0;;
compte_de_duval : compte = {num´ero = 2; solde = 1000.0}
Il faut bien comprendre que la r´ef´erence num´ero_de_compte est cr´e´ee une seule fois,
lors de la construction de la fonction cr´ee_compte. `A chaque appel de cr´ee_compte,
on retrouve ainsi dans num´ero_de_compte la derni`ere valeur qui y a ´et´e inscrite. Les
120 Les structures de donn´ees
variables de ce genre sont appel´ees variables r´emanentes dans la litt´erature informatique
(et variables statiques en C). Remarquez que Caml les autorise, sans avoir besoin de
fournir une construction sp´eciale pour cela : le let in habituel et les fonctions anonymes
suffisent pour programmer des variables r´emanentes.
6.7 Structures de donn´ees et filtrage
Comme nous l’avons vu `a maintes reprises, le filtrage va de paire avec les d´efinitions
de structures de donn´ees. Bien plus, la d´efinition d’un type sert de guide pour ´ecrire
le squelette du filtrage des fonctions qui op`erent sur ce type. Nous voulons cependant
attirer votre attention sur quelques traits avanc´es du filtrage et quelques ´ecueils qui
guettent les d´ebutants qui ´ecrivent leurs premiers filtrages.
Filtrage de valeurs calcul´ees
En premier lieu, il faut conserver `a l’esprit que le filtrage en Caml est structurel : on
ne peut utiliser dans les motifs que des constructeurs, des constantes et des variables,
`a l’exclusion des valeurs calcul´ees. C’est pourquoi les variables qui interviennent dans
un motif ne servent jamais `a faire des tests, mais au contraire `a lier des parties de la
valeur filtr´ee. Comparer par exemple, la d´efinition (erron´ee) de la fonction est_un avec
celle (correcte) de la fonction test_`a_un :
# let un = 1;;
un : int = 1
# let est_un = function
| un -> true
| _ -> false;;
Entr´ee interactive:
> | _ -> false;;
> ^
Attention: ce cas de filtrage est inutile.
est_un : ’a -> bool =
# est_un 2;;
- : bool = true
# let test_`a_un x = if x = un then true else false;;
test_`a_un : int -> bool =
# test_`a_un 2;;
- : bool = false
Le premier filtre de la fonction est_un comprend la variable un, qui est sans rapport
avec l’identificateur un pr´ec´edemment d´efini `a la valeur 1. Autrement dit, le nom de
la variable un est sans importance dans le filtrage de la fonction est_un : on peut
le remplacer par x ou y, et le filtrage est ´equivalent `a x -> true | _ -> false.
Contrairement `a ce que l’utilisateur voulait sans doute exprimer, la fonction est_un
ne teste donc pas si son argument correspond `a la mˆeme valeur que l’identificateur
un : en fait, la fonction est_un renvoie toujours true. Cela explique le r´esultat de
est_un 2. Cela explique aussi le message du compilateur : « ce cas de filtrage est
inutile ». Le compilateur s’est rendu compte que le cas _ -> ne servira jamais. C’est
Structures de donn´ees et filtrage 121
pour ´eviter ce genre de confusions qu’on utilise la convention de faire commencer les
noms de constructeurs par une majuscule et d’´ecrire les variables dans les filtres en
minuscules. Retenons que
Toute variable dans un filtre est une nouvelle variable.
Lin´earit´e du filtrage
Il faut ´egalement savoir que le filtrage en Caml est lin´eaire, ce qui signifie qu’un
nom de variable ne peut apparaˆıtre qu’une seule fois dans un filtre. Cette contrainte
est viol´ee le plus souvent lorsqu’on veut tester l’´egalit´e de deux morceaux d’une valeur.
Voici une tentative (erron´ee) de d´efinir la fonction d’´egalit´e : si le couple argument
comporte deux composantes identiques on renvoie vrai et sinon on renvoie faux.
# let ´egal = function
| (x, x) -> true
| _ -> false;;
Entr´ee interactive:
> | (x, x) -> true
> ^
L’identificateur x est d´efini plusieurs fois dans ce motif.
Les tests d’´egalit´e op´er´es par le filtrage ne concernent que les constantes (les constructeurs).
Les tests d’´egalit´e plus g´en´eraux ne s’expriment pas par filtrage, ils doivent faire
l’objet d’une alternative explicite (un if then else) dans l’expression d’une clause de
filtrage ou bien d’une garde que nous ´etudions bri`evement dans le prochain paragraphe.
Une d´efinition acceptable de ´egal serait donc :
# let ´egal = function (x, y) -> if x = y then true else false;;
´egal : ’a * ’a -> bool =
Remarque : comme nous l’avons vu au paragraphe 2.1, l’alternative du corps de ´egal
est inutile ; on la remplace donc simplement par sa partie condition pour obtenir
# let ´egal (x, y) = x = y;;
´egal : ’a * ’a -> bool =
Ce qui nous permet de constater que la fonction ´egal ne d´efinit pas la fonction d’´egalit´e
mais est en fait un synonyme de l’op´erateur = (plus pr´ecis´ement ´egal est la version non
curryfi´ee de l’op´erateur =).
Combiner filtrage et tests : les gardes
Vous remarquerez sans doute que le filtrage permet une programmation particuli`
erement claire, et autorise l’´ecriture compacte de multiples conditions. Cependant
le simple filtrage structurel (et lin´eaire) ne permet pas de m´elanger la s´election sur la
forme de la valeur filtr´ee et les tests sur les valeurs effectives des composants du filtre.
C’est pourquoi le filtrage de Caml propose une construction suppl´ementaire, les gardes,
pour effectuer des tests arbitraires pendant le filtrage. La clause
| filtre when condition -> ...
122 Les structures de donn´ees
o`u condition est une expression bool´eenne quelconque, filtre les mˆemes valeurs que
filtre, mais elle n’est s´electionn´ee que dans le cas o`u condition est vraie ; dans le cas
contraire le filtrage continue normalement en s´equence.
`A
l’aide d’une garde, on ´ecrit facilement une version correcte de la fonction est_un :
# let est_un = function
| x when x = un -> true
| _ -> false;;
est_un : int -> bool =
# est_un 2;;
- : bool = false
On ´ecrit aussi la fonction valeur_d’une_carte encore plus ´el´egamment :
# let valeur_d’une_carte couleur_d’atout = function
| As _ -> 11
| Roi _ -> 4
| Dame _ -> 3
| Valet c when c = couleur_d’atout -> 20
| Valet _ -> 2
| Petite_carte (9, c) when c = couleur_d’atout -> 14
| Petite_carte (10, _) -> 10
| _ -> 0;;
valeur_d’une_carte : couleur -> carte -> int =
Filtrage exhaustif, filtrage partiel
Enfin, il faut se m´efier des filtrages non exhaustifs, c’est-`a-dire des filtrages qui
oublient des cas. C’est une des forces du filtrage de servir de guide pour facilement
envisager tous les cas concernant une structure de donn´ees, il faut donc en profiter
pleinement. Si vous oubliez d’envisager certains cas, le compilateur ´emet un message
d’avertissement et il faut en tenir compte. Voici un exemple caricatural de filtrage non
exhaustif :
# let vide = function [] -> true;;
Entr´ee interactive:
>let vide = function [] -> true;;
> ^^^^^^^^^^^^^^^^^^^
Attention: ce filtrage n’est pas exhaustif.
vide : ’a list -> bool =
Dans cette situation, il faut vous efforcer de « boucher les trous » de votre filtrage.
Laisser des filtrages non exhaustifs dans un programme est g´en´eralement consid´er´e
comme un laisser-aller de mauvais aloi.
6.8 Structures de donn´ees et r´ecurrence
Cette section peut ˆetre saut´ee en premi`ere lecture. Nous y ´etendons le principe de
r´ecurrence aux types de donn´ees.
Comme pour les listes, nous aimerions disposer d’un moyen de prouver des propri
´et´es sur les programmes qui utilisent des types somme ou des types produit. Comme
Structures de donn´ees et r´ecurrence 123
dans le cas des listes, il suffit de trouver un nombre li´e aux donn´ees, sur lequel on puisse
employer le principe de r´ecurrence. Pour les listes, nous avions utilis´e la longueur. En
fait, il suffit pour g´en´eraliser `a tous les types somme de remarquer que la longueur
d’une liste n’est autre que le nombre d’utilisation du constructeur « :: » n´ecessaire `a
la construction de la liste. Pour un type somme g´en´eral, on pourra ainsi raisonner sur
le nombre d’occurrences des constructeurs du type. Le cas particulier de la liste vide
sera transpos´e `a tous les constructeurs constants du type, tandis que le cas de « :: »
correspondra au nombre d’occurrences des constructeurs non constants.
Pour les types produit, il y a plusieurs mani`eres d’´etendre le raisonnement par
r´ecurrence. Pour simplifier, supposons que nous devions d´emontrer une propri´et´e sur
un type produit `a deux composantes seulement et pour simplifier encore supposons
que ce soit le type int * int. Pour prouver une propri´et´e P qui d´epend d’une paire
d’entiers (m, n), on utilisera par exemple le principe de r´ecurrence suivant :
Si P(0, 0) est vraie, et d`es que P(m, n) est vraie alors P(m+1, n) et P(m, n+
1) sont vraies, alors P est vraie pour tous m et n.
Ce principe se d´emontre facilement `a partir du principe de base et se g´en´eralise sans
difficult´e `a un nombre quelconque de variables.
Cette extension du principe de r´ecurrence aux structures de donn´ees se nomme tout
naturellement la r´ecurrence structurelle. C’est le principal moyen de d´emonstration `a
la disposition de l’informaticien. Il est heureux qu’il soit si simple `a appr´ehender.
7
Le docteur
O`u l’intelligence naturelle vient au secours de la bˆetise artificielle.
n vous initie ici au maniement des exceptions, des listes d’association et des
entr´ees-sorties ´el´ementaires de Caml. Par ailleurs, on impl´emente un programme
qui essaye de se faire passer pour un psychanalyste . . .
7.1 Vue d’ensemble
Notre « psychanalyste » ´electronique s’appelle Cam´elia. C’est un programme interactif,
qui pose des questions `a son « patient » et r´eagit `a ses r´eponses en imprimant un
message au terminal. La strat´egie du programme repose donc sur l’examen des phrases
entr´ees par le patient. Une fois la phrase examin´ee, le programme choisit au hasard une
r´eponse parmi un ensemble de r´eponses toutes faites, pr´epar´ees par le programmeur.
L’examen d’une phrase consiste simplement `a chercher des mots connus du programme
dans la phrase qui lui est soumise. Les phrases sont class´ees sommairement en trois
cat´egories : les phrases tr`es simples (par exemple r´eduites `a « oui » ou « non »), pour
lesquelles Cam´elia dispose d’un ensemble de r´eponses types ; les questions (phrases
termin´ees par un caract`ere « ? ») auxquelles Cam´elia r´epond «C’est moi qui pose les
questions » ou une phrase du mˆeme genre ; et les phrases complexes, pour lesquelles
Cam´elia cherche un mot int´eressant (comme « famille » ou « p`ere » ou « sexe »). Si le
programme trouve un mot int´eressant, il r´eagit par une phrase type (toujours tir´ee au
hasard parmi un ensemble pr´epar´e). S’il ne trouve pas de mot int´eressant, Cam´elia
n’a rien `a dire d’int´eressant non plus : elle se contente de relancer la conversation, en
imprimant par exemple «Parlez-moi un peu de vous ». Tout le sel de la conversation
avec Cam´elia vient de l’utilisateur. C’est lui qui attache un sens pr´ecis aux phrases
creuses de Cam´elia. L’art du programmeur ne consiste ici qu’`a faire dire au programme
les phrases les plus creuses et les plus ambigu¨es possible, pour laisser l’utilisateur interpr
´eter lui-mˆeme.
Pour impl´ementer Cam´elia, nous aurons besoin de fonctions nouvelles sur les listes
et les chaˆınes de caract`eres. D’autre part nous aurons besoin aussi d’introduire le
m´ecanisme d’exceptions de Caml. En effet, le coeur du programme consiste `a essayer
126 Le docteur
successivement les diff´erentes strat´egies possibles, jusqu’`a ce que l’une d’entre elles
r´eussisse. Nous verrons que c’est justement un emploi typique des exceptions.
7.2 Les exceptions
Erreurs et rattrapage d’erreurs
Dans les langages fonctionnels, toute fonction qui ne boucle pas ind´efiniment doit
rendre une valeur, quel que soit son argument. Malheureusement certaines fonctions,
bien que n´ecessairement d´efinies pour toute valeur de leur type argument, ne peuvent
pas retourner de valeur sens´ee pour tous les arguments possibles. Consid´erez par exemple
la division entre nombres entiers : que doit-elle faire lorsqu’on tente de diviser
par 0 ? Le probl`eme se pose aussi pour les donn´ees structur´ees : consid´erez la fonction
t^ete qui renvoie la tˆete d’une liste. Que peut-elle faire lorsque son argument est la liste
vide ? Dans de telles situations la fonction doit ´echouer, c’est-`a-dire arrˆeter les calculs
et signaler une erreur. C’est ce que nous avons fait en utilisant la fonction pr´ed´efinie
failwith :
# failwith;;
- : string -> ’a =
qui envoie un message indiquant la cause de l’´echec. C’est pourquoi nous d´efinissons
t^ete par :
# let t^ete = function
| [] -> failwith "t^ete"
| x::_ -> x;;
t^ete : ’a list -> ’a =
Et maintenant, t^ete [] nous signale une erreur dans la fonction t^ete :
# t^ete [];;
Exception non rattrap´ee: Failure "t^ete"
Ce m´ecanisme de d´eclenchement d’erreurs est utile, mais il se peut que nous voulions
r´ecup´erer ces erreurs, parce que nous savons comment continuer les calculs apr`es une
telle erreur (qui devient une erreur « attendue » du point de vue du programmeur).
Par exemple, imaginons qu’on doive ajouter syst´ematiquement la tˆete d’une liste `a un
compteur. Si la liste est vide, il est logique de continuer les calculs en n’ajoutant rien au
compteur. Dans ce cas, l’´echec signal´e par la fonction t^ete doit ˆetre r´ecup´er´e. On utilise
pour cela la construction try . . . with . . . (try signifie essayer et with avec) qui permet
de calculer une expression en surveillant les exceptions que son calcul peut d´eclencher.
Cette construction ob´eit `a la syntaxe suivante : try expression with filtrage. Elle signifie
intuitivement : essayer de calculer la valeur de expression et si cette ´evaluation d´eclenche
une erreur qui tombe dans un des cas du filtrage alors retourner la valeur correspondante
de la clause s´electionn´ee par le filtrage. Par exemple, puisque l’erreur signal´ee par la
fonction t^ete est Failure "t^ete", on envisagera cet ´echec dans la partie filtrage du
try . . . with . . . pour renvoyer une valeur enti`ere, comme si aucune erreur n’avait ´et´e
d´eclench´ee. On rattrape donc l’´echec sur la liste vide et l’on renvoie 0, par la phrase :
# try (t^ete []) with Failure "t^ete" -> 0;;
- : int = 0
Les exceptions 127
On ´ecrira donc la proc´edure d’incr´ementation du compteur :
# let ajoute_au_compteur compteur l =
compteur := !compteur + (try (t^ete l) with Failure "t^ete" -> 0);;
ajoute_au_compteur : int ref -> int list -> unit =
# let c = ref 0;;
c : int ref = ref 0
# ajoute_au_compteur c [1]; !c;;
- : int = 1
# ajoute_au_compteur c []; !c;;
- : int = 1
C’est la m´ethode ´el´ementaire d’utilisation des exceptions de Caml. Nous d´ecrivons
maintenant le m´ecanisme dans toute sa g´en´eralit´e.
Valeurs exceptionnelles
Le trait distinctif du traitement d’erreurs en Caml, et ce qui en fait la g´en´eralit´e, est
le statut des erreurs : ce sont des valeurs `a part enti`ere du langage. Elles appartiennent
`a un type pr´ed´efini exn et on les appelle « valeurs exceptionnelles ». On les manipule
donc comme toutes les autres valeurs. Par exemple, l’´echec signal´e par la fonction t^ete
est la valeur exceptionnelle Failure "t^ete" :
# let ´echec_de_t^ete = Failure "t^ete";;
´echec_de_t^ete : exn = Failure "t^ete"
Remarquez que Failure n’est rien d’autre qu’un constructeur de valeurs du type exn.
La propri´et´e caract´eristique des valeurs exceptionnelles est ´evidemment qu’on peut
les d´eclencher (on dit aussi les lever, par analogie avec la locution « lever une perdrix »).
Pour lever une valeur exceptionnelle on utilise la fonction pr´ed´efinie raise (en anglais
to raise signifie « lever ») :
# raise;;
- : exn -> ’a =
# raise ´echec_de_t^ete;;
Exception non rattrap´ee: Failure "t^ete"
La primitive raise est une fonction «magique », car elle n’est pas d´efinissable dans le
langage. Elle interrompt imm´ediatement les calculs en cours pour d´eclencher le signal
(lever la valeur exceptionnelle) qu’elle a re¸cu en argument. C’est ce qui explique qu’un
appel `a la fonction raise puisse intervenir dans n’importe quel contexte avec n’importe
quel type : les calculs ne seront de toute fa¸con jamais effectu´es lorsqu’on ´evaluera l’appel
`a raise, le contexte peut donc faire toutes les hypoth`eses qu’il d´esire sur la valeur
renvoy´ee par raise. Par exemple :
# 1 + (raise ´echec_de_t^ete);;
Exception non rattrap´ee: Failure "t^ete"
# "Bonjour" ^ (raise ´echec_de_t^ete);;
Exception non rattrap´ee: Failure "t^ete"
Bien entendu, les phrases essentiellement mal typ´ees, o`u raise apparaˆıt dans un contexte
lui-mˆeme mal typ´e, sont toujours rejet´ees :
128 Le docteur
# 1 + (raise ´echec_de_t^ete) ^ "Bonjour";;
Entr´ee interactive:
>1 + (raise ´echec_de_t^ete) ^ "Bonjour";;
>^^^^^^^^^^^^^^^^^^^^^^^^^
Cette expression est de type int,
mais est utilis´ee avec le type string.
La construction try ... with
On peut donc consid´erer les valeurs exceptionnelles comme des signaux qu’on envoie
`a l’aide de la fonction raise et qu’on re¸coit avec la construction try . . . with . . . La
s´emantique de try e with filtrage est de retourner la valeur de e si e s’´evalue
« normalement », c’est-`a-dire sans d´eclenchement d’exception. En revanche, si une
valeur exceptionnelle est d´eclench´ee pendant l’´evaluation de e, alors cette valeur est
filtr´ee avec les clauses du filtrage et comme d’habitude la partie expression de la clause
s´electionn´ee est renvoy´ee. Ainsi, la partie filtrage de la construction try . . . with
. . . est un filtrage parfaitement ordinaire, op´erant sur des valeurs du type exn. La seule
diff´erence est qu’en cas d’´echec du filtrage, la valeur exceptionnelle qu’on n’a pas pu
filtrer est propag´ee, c’est-`a-dire d´eclench´ee `a nouveau. Comparez ainsi une ´evaluation
habituelle :
# try t^ete [1] with Failure "t^ete" -> 0;;
- : int = 1
une ´evaluation d´eclenchant une valeur exceptionnelle rattrap´ee :
# try t^ete [] with Failure "t^ete" -> 0;;
- : int = 0
et finalement une propagation de valeur exceptionnelle :
# try t^ete [] with Failure "reste" -> 0;;
Exception non rattrap´ee: Failure "t^ete"
D´efinition d’exceptions
De nombreuses fonctions pr´ed´efinies de Caml, quand elles ´echouent, d´eclenchent
l’exception Failure avec leur nom comme argument. C’est pourquoi l’exception
Failure poss`ede un « d´eclencheur » pr´ed´efini, la fonction failwith. Nous pouvons
maintenant ´ecrire sa d´efinition :
# let failwith s = raise (Failure s);;
failwith : string -> ’a =
Si les exceptions pr´ed´efinies ne vous satisfont pas, parce que vous souhaitez par
exemple que votre valeur exceptionnelle transporte autre chose qu’une chaˆıne de caract`
eres, vous pouvez d´efinir une nouvelle exception. En effet, le type exn est un type
somme (il y a plusieurs exceptions diff´erentes ; c’est donc un type « ou »), mais d’un
genre tr`es particulier : sa d´efinition n’est jamais achev´ee. C’est pourquoi il est possible
`a tout moment de lui ajouter de nouveaux constructeurs, soit constants soit fonctionnels.
Pour d´efinir un nouveau constructeur du type exn, donc une nouvelle exception,
on utilise le mot-cl´e exception suivi d’une d´efinition de constructeur de type somme.
Pour d´efinir la nouvelle exception constante Stop, on ´ecrira donc simplement :
Les exceptions 129
# exception Stop;;
L’exception Stop est d´efinie.
La d´efinition d’une exception fonctionnelle comportera une partie « of type » qui pr´ecise
le type de l’argument de l’exception.
# exception Erreur_fatale of string;;
L’exception Erreur_fatale est d´efinie.
# raise (Erreur_fatale "Cas impr´evu dans le compilateur");;
Exception non rattrap´ee: Erreur_fatale "Cas impr´evu dans le compilateur"
Voici la description pr´ecise des d´efinitions d’exception `a l’aide de diagrammes syntaxiques
:
D´efinition d’exceptions ::= exception d´efinition-de-constructeur
(and d´efinition-de-constructeur)∗
d´efinition-de-constructeur ::= identificateur
| identificateur of type
Les exceptions comme moyen de calcul
Les exceptions ne servent pas seulement `a g´erer les erreurs : elles sont aussi utilis´ees
pour calculer. Dans ce cas, la valeur exceptionnelle transporte un r´esultat, ou bien
signale un ´ev´enement attendu. `A titre d´emonstratif, nous d´efinissons la fonction
caract`ere_dans_cha^ıne, qui teste l’appartenance d’un caract`ere `a une chaˆıne et dont
nous avons besoin pour impl´ementer Cam´elia. On pourrait ´evidemment ´ecrire cette
fonction `a l’aide d’une fonction r´ecursive locale :
# let caract`ere_dans_cha^ıne cha^ıne car =
let rec car_dans_cha^ıne i =
i < string_length cha^ıne &&
(cha^ıne.[i] = car ||
car_dans_cha^ıne (i + 1)) in
car_dans_cha^ıne 0;;
caract`ere_dans_cha^ıne : string -> char -> bool =
Cependant, cette fonction r´ecursive code ´evidemment une boucle ; nous pr´ef´erons donc
l’´ecrire avec une boucle. On parcourt donc la chaˆıne argument `a l’aide d’une boucle
for en recherchant le caract`ere donn´e. Cependant, que faire si le caract`ere est trouv´e ?
Il faut arrˆeter la boucle et signaler sa pr´esence. Ce comportement revient `a d´eclencher
une exception. Nous d´efinissons donc l’exception Trouv´e. Et nous surveillons la boucle
de recherche : si l’exception est d´eclench´ee, la fonction renvoie true. En revanche, si la
boucle se termine normalement, c’est que le caract`ere n’´etait pas dans la chaˆıne ; dans
ce cas, on renvoie false en s´equence.
# exception Trouv´e;;
L’exception Trouv´e est d´efinie.
# let caract`ere_dans_cha^ıne cha^ıne car =
try
for i = 0 to string_length cha^ıne - 1 do
if cha^ıne.[i] = car then raise Trouv´e
done;
false
130 Le docteur
with Trouv´e -> true;;
caract`ere_dans_cha^ıne : string -> char -> bool =
Ici le d´eclenchement de l’exception n’est pas un cas d’erreur, mais plutˆot un ´ev´enement
heureux : on a d´etect´e la pr´esence du caract`ere dans la chaˆıne. On ne peut pas dire
non plus que ce soit vraiment un ´ev´enement exceptionnel, une « exception » au calcul
normal : c’est un signal attendu, tout simplement.
Sans le m´ecanisme des exceptions la fonction pr´ec´edente devrait ˆetre ´ecrite avec une
r´ef´erence initialis´ee `a false en d´ebut de boucle et mise `a true lorsqu’on rencontre le
caract`ere.
# let car_dans_cha^ıne cha^ıne car =
let trouv´e = ref false in
for i = 0 to string_length cha^ıne - 1 do
if cha^ıne.[i] = car then trouv´e := true
done;
!trouv´e;;
car_dans_cha^ıne : string -> char -> bool =
Cette version est un peu moins efficace, puisque le parcours de la chaˆıne est toujours
effectu´e compl`etement, alors qu’il est inutile de le continuer d`es qu’on a d´etect´e la
pr´esence du caract`ere. Cet argument d’efficacit´e est minime : le choix entre les deux
versions est essentiellement une affaire de goˆut personnel, de style et d’exp´erience. Nous
pr´ef´erons la version avec exception, car elle se g´en´eralise plus facilement `a plusieurs
´ev´enements attendus dans la boucle. Au surplus, la boucle s’arrˆete instantan´ement
quand l’´ev´enement arrive et c’est tr`es souvent un comportement algorithmiquement
n´ecessaire du programme.
7.3 Fonctions de recherche dans les listes
Les r´eponses toutes faites de Cam´elia sont stock´ees dans des listes d’une forme
particuli`ere, les listes d’association, qui associent des r´eponses `a certains mots de la
phrase du patient.
Appartenance d’un ´el´ement `a une liste
Nous commen¸cons par ´ecrire la fonction membre, qui d´etermine si son premier argument
est ´el´ement d’une liste donn´ee en second argument. Travaillant sur des listes,
la fonction membre doit par cons´equent envisager les deux cas possibles de listes ; d’o`u
le squelette de fonction :
let membre e = function
| [] -> ...
| x :: reste -> ... ;;
Le cas de la liste vide est simple : l’´el´ement `a rechercher n’apparaˆıt certainement pas
dans la liste.
let membre e = function
| [] -> false
| x :: reste -> ... ;;
Fonctions de recherche dans les listes 131
Dans le cas g´en´eral, il faut tester si e est ´egal `a la tˆete de la liste (x), sinon interroger
r´ecursivement le reste de la liste. On obtient donc :
# let rec membre elem = function
| [] -> false
| x :: reste -> x = elem || membre elem reste;;
membre : ’a -> ’a list -> bool =
Listes d’association
Les listes d’association sont simplement des listes de paires o`u le premier ´el´ement
de la paire est une cl´e et le second la valeur associ´ee `a la cl´e. (Pour les tenants de
Bourbaki, c’est le graphe d’une fonction donn´ee en extension.) Par exemple, consid´erez
une liste d’adresses. On associe au nom d’une personne son adresse :
# let adresses =
[("Pierre Caml","Domaine de Voluceau, 78153 Le Chesnay Cedex");
("Xavier Light","45 rue d’Ulm, 75005 Paris")];;
adresses : (string * string) list =
["Pierre Caml", "Domaine de Voluceau, 78153 Le Chesnay Cedex";
"Xavier Light", "45 rue d’Ulm, 75005 Paris"]
Dans notre programme, une liste d’association donnera les r´eponses possibles associ´ees
aux phrases tr`es simples. Voici un extrait de la liste d’association des phrases simples :
let r´eponses_aux_phrases_simples =
[([],
[|"Voulez-vous changer de sujet?"; "Continuez"|]);
(["et"; "alors"],
[|"Alors expliquez-moi"; "Ne soyez pas si agressif"|]);
(["non"],
[|"C’est vite dit"; "Pourriez-vous pr´eciser ?"|]);
(["oui"],
[|"C’est un peu rapide"; "Donnez-moi plus de d´etails"|])];;
Cette liste associe `a la liste vide (correspondant `a une r´eponse vide) le tableau de
r´eponses possibles [|"Voulez-vous changer de sujet?"; "Continuez"|]. Elle associe
`a la phrase r´eduite `a et alors? les r´eponses [|"Alors expliquez-moi"; "Ne
soyez pas si agressif"|]. Il nous faut donc retrouver la valeur associ´ee `a une
phrase dans cette liste d’association. La fonction g´en´erale de recherche dans une liste
d’association s’´ecrit tr`es simplement : on teste si la cl´e a ´et´e rencontr´ee, auquel cas
on renvoie la valeur associ´ee ; sinon on cherche dans le reste de la liste. Si la liste est
´epuis´ee, il n’y a pas d’espoir de trouver la valeur associ´ee et l’on d´eclenche l’exception
constante Pas_trouv´e.
# exception Pas_trouv´e;;
L’exception Pas_trouv´e est d´efinie.
# let rec associ´e_de x = function
| [] -> raise Pas_trouv´e
| (cl´e, valeur) :: l ->
if x = cl´e then valeur else associ´e_de x l;;
associ´e_de : ’a -> (’a * ’b) list -> ’b =
132 Le docteur
# associ´e_de "Pierre Caml" adresses;;
- : string = "Domaine de Voluceau, 78153 Le Chesnay Cedex"
# associ´e_de "Xavier Light" adresses;;
- : string = "45 rue d’Ulm, 75005 Paris"
# associ´e_de "G´erard Coq" adresses;;
Exception non rattrap´ee: Pas_trouv´e
Cette fonction est pr´ed´efinie en Caml sous le nom de assoc. En cas d’´echec, elle
d´eclenche toujours une exception. Dans le syst`eme Caml Light c’est l’exception
Not_found (signifiant « pas trouv´e » en anglais). C’est souvent l’exception d´eclench´ee
par les fonctions de recherche de la biblioth`eque Caml Light.
Des listes d’association multi-cl´es
Pour les besoins de notre programme nous devons g´erer des listes d’association plus
compliqu´ees que des listes (cl´e, valeur). En effet, nous consid´erons que certains mots
« int´eressants » sont synonymes et donc que leurs r´eponses associ´ees sont les mˆemes. Par
exemple, ordinateur et machine appellent les mˆemes r´eponses. Le pluriel d’un mot
est souvent trait´e comme le mot lui-mˆeme, par exemple ami et amis. Dans ces listes,
une valeur n’est donc plus associ´ee `a une seule cl´e, mais `a une liste de cl´es ´equivalentes.
Nous ´ecrivons donc la fonction qui teste si une cl´e donn´ee fait partie de la liste de cl´es
et retourne en ce cas la valeur associ´ee :
# let rec associ´e_dans_liste cl´e = function
| [] -> raise Pas_trouv´e
| (liste_de_cl´es, valeur) :: reste ->
if membre cl´e liste_de_cl´es then valeur
else associ´e_dans_liste cl´e reste;;
associ´e_dans_liste : ’a -> (’a list * ’b) list -> ’b =
De la mˆeme mani`ere, nous avons besoin de chercher, parmi une liste de cl´es la valeur
associ´ee `a la premi`ere cl´e qui figure dans les cl´es d’une liste d’association (listes de
cl´es, valeur). Nous parcourons donc la liste de cl´es argument en cherchant l’associ´e de
la premi`ere cl´e rencontr´ee. S’il n’y a pas d’associ´e `a cette cl´e, nous cherchons, parmi
le reste de la liste de cl´es argument, la premi`ere cl´e qui ait un associ´e dans la liste
d’association. Remarquez au passage que le caract`ere ’ est autoris´e dans les noms
d’identificateur en Caml.
# let rec associ´e_d’un_´el´ement_de liste_de_cl´es liste_d’association =
match liste_de_cl´es with
| [] -> raise Pas_trouv´e
| cl´e :: reste ->
try
associ´e_dans_liste cl´e liste_d’association
with Pas_trouv´e ->
associ´e_d’un_´el´ement_de reste liste_d’association;;
associ´e_d’un_´el´ement_de : ’a list -> (’a list * ’b) list -> ’b =
Traitements de chaˆınes de caract`eres 133
7.4 Traitements de chaˆınes de caract`eres
Notre programme va effectuer une certaine normalisation de l’entr´ee de l’utilisateur :
passer syst´ematiquement toute la phrase en minuscules et ˆoter les signes de ponctuation
et accents ´eventuels, par exemple. Les fonctions correspondantes illustrent le traitement
de chaˆınes de caract`eres en Caml.
Passage en minuscules
En machine, les caract`eres sont ´evidemment enregistr´es comme des nombres. Le
codage utilis´e en Caml s’appelle le code ASCII. Il suffit de le faire imprimer par Caml
pour comprendre comment sont rang´es les caract`eres de l’alphabet (remarquez aussi
les chiffres) :
# for i = 32 to 126 do
if i < 100 then print_string " ";
print_int i; print_string " ";
print_char (char_of_int i); print_string " ";
if i mod 8 = 7 then print_newline ()
done;
print_newline ();;
32 33 ! 34 " 35 # 36 $ 37 % 38 & 39 ’
40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 /
48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7
56 8 57 9 58 : 59 ; 60 < 61 = 62 > 63 ?
64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G
72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O
80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W
88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _
96 ‘ 97 a 98 b 99 c 100 d 101 e 102 f 103 g
104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o
112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w
120 x 121 y 122 z 123 { 124 | 125 } 126 ~
- : unit = ()
Le passage en minuscule revient donc `a un simple calcul sur le code ASCII du caract`
ere : si le caract`ere est une majuscule, on lui ajoute 32 pour obtenir la minuscule
correspondante.
# let minuscule_de car =
if int_of_char car >= 65 && int_of_char car <= 90
then char_of_int (int_of_char car + 32)
else car;;
minuscule_de : char -> char =
Pour passer une chaˆıne de caract`eres tout enti`ere en minuscules, il suffit d’it´erer la
fonction pr´ec´edente.
# let minuscules cha^ıne =
let cha^ıne_en_minuscules = create_string (string_length cha^ıne) in
for i = 0 to string_length cha^ıne - 1 do
cha^ıne_en_minuscules.[i] <- minuscule_de cha^ıne.[i]
done;
134 Le docteur
cha^ıne_en_minuscules;;
minuscules : string -> string =
Nous avons ´egalement besoin d’extraire une sous-chaˆıne d’une chaˆıne. La souscha
ˆıne est rep´er´ee par ses indices de d´ebut et de fin. On utilise la fonction pr´ed´efinie
sub_string qui calcule une sous-chaˆıne partant d’un indice donn´e et d’une longueur
donn´ee :
# sub_string "Caml" 0 3;;
- : string = "Cam"
# let sous_cha^ıne s d´epart fin =
sub_string s d´epart (fin - d´epart + 1);;
sous_cha^ıne : string -> int -> int -> string =
Suppression des accents
La simplification d’un mot consiste `a supprimer les accents, que l’on consid`ere
comme non significatifs. On admet ´egalement que l’utilisateur ait pu taper e^ pour
^e ou e’ pour ´e. Enfin, on supprime les articles ´elid´es qui apparaissent ´eventuellement
au d´ebut du mot. Par exemple, l’air devient air.
Plutˆot que de «mettre en dur » ces conventions dans le code de la fonction de
simplification, nous ´ecrivons une fonction g´en´erale, param´etr´ee par une table de simplifications,
qui n’est autre qu’une liste d’association entre chaˆınes.
# let simplifications =
[("`a","a"); ("¸c","c"); ("´e","e"); ("`e","e"); ("^e","e"); ("`u","u");
("a‘","a"); ("e’","e"); ("e‘", "e"); ("e^","e"); ("u‘","u");
("qu’", ""); ("l’", ""); ("d’", "")];;
La fonction de simplification consiste `a recopier le mot argument dans une nouvelle
chaˆıne. Les caract`eres sont recopi´es un par un, sauf si le caract`ere courant et les caract`
eres suivants forment une des chaˆınes `a simplifier, auquel cas on les remplace par la
chaˆıne associ´ee dans la table de simplifications.
# let simplifie_mot mot =
let nouveau_mot = create_string (string_length mot) in
let i = ref 0 and j = ref 0 in
let rec cherche_traduction = function
| [] -> raise Pas_trouv´e
| (original, traduction) :: reste ->
let longueur = string_length original in
if !i + longueur <= string_length mot
&& sub_string mot !i longueur = original
then (longueur, traduction)
else cherche_traduction reste in
while !i < string_length mot do
try
let (longueur, traduction) =
cherche_traduction simplifications in
blit_string traduction 0 nouveau_mot !j
(string_length traduction);
i := !i + longueur;
Cam´elia 135
j := !j + string_length traduction
with Pas_trouv´e ->
nouveau_mot.[!j] <- mot.[!i];
i := !i + 1;
j := !j + 1
done;
sub_string nouveau_mot 0 !j;;
simplifie_mot : string -> string =
Division en mots
La division d’une chaˆıne de caract`eres en mots est une autre op´eration d´elicate.
Elle consiste `a parcourir la chaˆıne (`a l’envers) `a la recherche des s´eparateurs. D`es qu’un
s´eparateur est trouv´e, on extrait un mot qu’on ajoute `a la liste de mots mots. On
maintient un compteur j qui indique le dernier caract`ere du mot courant, tandis que le
compteur de boucle i sert `a en rep´erer le d´ebut. Notez que le caract`ere « fin de ligne »
est ´ecrit \n. `A l’int´erieur d’une chaˆıne de caract`eres, la notation \n repr´esente aussi un
retour `a la ligne.
# let divise_en_mots cha^ıne =
let mots = ref [] in
let j = ref (string_length cha^ıne - 1) in
let ajoute_mot i j =
if i <= j then
mots := simplifie_mot (sous_cha^ıne cha^ıne i j) :: !mots in
for i = string_length cha^ıne - 1 downto 0 do
match cha^ıne.[i] with
| (‘ ‘ | ‘\n‘ | ‘.‘ | ‘,‘ | ‘;‘ | ‘-‘ | ‘!‘ | ‘?‘) ->
ajoute_mot (i + 1) !j; j := i - 1
| _ -> ()
done;
ajoute_mot 0 !j; (* extraction du dernier mot *)
!mots;;
divise_en_mots : string -> string list =
Nous rencontrons un trait nouveau du langage : les barres verticales `a l’int´erieur des
filtres, comme dans ‘ ‘ | ‘\n‘ | . . . Ces filtres sont des filtres `a plusieurs cas que l’on
appelle les filtres « ou ». Ils filtrent l’union des cas filtr´es par leurs composants. C’est
une simple facilit´e syntaxique, qui ´evite de recopier plusieurs fois le corps de la clause.
Par exemple, la clause (1 | 2) -> true est ´equivalente aux deux clauses 1 -> true
| 2 -> true.
7.5 Cam´elia
La base de donn´ees
Le principe de Cam´elia est donc d’utiliser un ensemble de phrases ´ecrites pour elle
par le programmeur. Le bon choix de ces phrases intervient beaucoup dans la qualit´e
de l’´echange. Nous donnons donc ici ce que nous appelons pompeusement la « base de
136 Le docteur
donn´ees » de Cam´elia, qui n’est autre qu’un ensemble de listes d’association simples ou
multi-cl´es. La base de donn´ees comprend les listes suivantes :
• salutations : le mot de la fin de Cam´elia, typiquement «Ce sera long et difficile,
revenez me voir souvent . . . ».
• relances : les phrases utilis´ees quand le programme ne sait plus quoi dire, typiquement
«Parlez-moi encore de vous » ou « ˆEtes-vous mari´e ? ».
• r´eponses_types : ce que le programme r´epond quand il d´etecte un caract`ere « ? »
et rien de plus int´eressant dans la phrase. Typiquement «C’est moi qui pose les
questions ».
• r´eponses_aux_phrases_simples : pour r´epondre aux phrases `a l’emporte-pi`ece
comme «Et alors ? » ou «Oui ». R´eponse typique : «Alors, expliquez-moi » ou
«Donnez-moi plus de d´etails ».
• r´eponses_aux_petits_mots : quand le programme n’a rien de mieux `a faire, il
cherche un mot tr`es souvent employ´e en fran¸cais qui lui permette de faire une
r´eponse sens´ee, sans rien comprendre. Exemple typique : si la phrase contient le
mot « jamais » le programme peut r´epondre « Jamais me semble un peu fort, non
? ».
• r´eponses_aux_mots_int´eressants : le programme surveille si le patient emploie
des mots « psychanalytiques », comme p`ere ou famille, et r´eagit alors en
cons´equence. R´eponses typiques : «Racontez-moi vos probl`emes » quand le mot
«malheureux » est d´etect´e.
let salutations =
[|"Ce sera long et difficile, revenez me voir \
souvent ...";
"Votre cas n’est pas simple, et m^eme assez \
inqui´etant ... A bient^ot?";
"Diagnostic simple: sans conteste vous ^etes \
parano¨ıaque.";
"Avec une probabilit´e de 92.37234%: \
perversion polymorphe.";
"Vous souffrez d’une schizophr´enie en rapide \
´evolution, DANGER";
"D’apr`es mes calculs, votre sant´e mentale est \
compromise.";
"Mon ultime conseil: il ne faut pas rester \
comme cela, soignez-vous!"|];;
let relances =
[| "Parlez-moi un peu de vous";
"^Etes-vous mari´e?";
"Avez-vous des enfants?";
"Parlons de votre entourage";
"Aimez-vous la vie?";
"Aimez-vous ce moyen de communiquer?";
"Parlons de votre famille";
"Parlez-moi encore de vous";
"Que pensez-vous des ordinateurs?";
"Que pensez-vous de Linux?";
"Que pensez-vous de Caml?";
"De quoi parlerons-nous maintenant?";
"Avez-vous beaucoup d’amis?";
"Avez-vous de graves probl`emes?";
"Parlez-moi de vos probl`emes";
"Faites-vous des r^eves ´etranges?";
"Faites-vous souvent des cauchemars?";
"Que pensez-vous de l’amour?";
"Que pensez-vous de la sexualit´e?";
"Quels sont vos violons d’Ingres?";
"Qu’est-ce qui vous int´eresse dans la vie?";
"Que pensez-vous de la vie en g´en´eral?"|];;
let r´eponses_types =
[| "C’est moi qui pose les questions";
"Je ne suis pas l`a pour r´epondre `a vos \
questions";
"Question tr`es int´eressante, mais qu’en \
pensez-vous?";
"Quelle question!";
"Pourquoi me posez-vous cette question?";
"Vous le savez tr`es bien";
"La r´eponse est sans importance";
"Vous le dire ne vous apporterait rien";
"Un psychanalyste n’a pas le droit de \
r´epondre `a ce genre de questions";
"Je n’ai pas le droit de vous r´epondre";
"Il m’est interdit de vous le dire";
"Vous ne comprendriez pas";
"Permettez-moi de ne pas r´epondre";
"Laissez-moi r´efl´echir. Pouvez-vous \
reformuler la question?";
"Je ne suis pas certaine de bien comprendre \
la question";
"Je ne sais pas";
"Cherchez un peu";
"C’est ´evident pour tout le monde, sauf pour \
Cam´elia 137
vous; r´efl´echissez!";
"C’est `a vous de trouver la r´eponse";
"Cherchez bien au fond de vous-m^eme, vous le \
savez en fait"|];;
let r´eponses_aux_phrases_simples =
[([],
[|"Voulez-vous changer de sujet?";
"Continuez";
"Continuez, vous m’int´eressez";
"Je vous ´ecoute";
"Vous n’avez rien d’autre `a dire?";
"Continuez, je vous prie";
"C’est tout ce que vous avez `a dire?";
"M’avez-vous tout dit l`a-dessus?";
"Je n’en sais pas encore assez sur vous; \
continuez"|]);
(["quoi"],
[|"Excusez-moi je pensais `a autre chose, \
continuons";
"R´efl´echissez";
"Changeons de sujet, s’il vous pla^ıt";
"Je me comprends";
"Il me semblait pourtant avoir ´et´e claire";
"La communication est difficile, non?";
"Ah les hommes! Ils ne comprennent rien!";
"Cessez de poser des questions";
"N’auriez-vous pas des probl`emes `a me \
comprendre?"|]);
(["non"],
[|"C’est vite dit";
"Pourriez-vous pr´eciser?";
"Je note: c’est non";
"Mais encore?";
"La r´eponse n’est pas si simple, non?";
"Vous ^etes vraiment tr`es s^ur de vous";
"Ne vous arrive-t-il pas de douter de \
vous-m^eme?";
"Ne r´epondez pas toujours oui ou non";
"Syndr^ome du yes/no. Expliquez-vous, que \
diable!";
"Au moins vous ne souffrez pas de diarrh´ee \
verbale";
"Comment pouvez-vous ^etre si s^ur de \
vous?"|]);
(["si"],
[|"Si b´emol?";
"D’accord, d’accord";
"Mouais, je m’en doutais un peu, \
figurez-vous";
"Expliquez-vous, ‘‘si’’ ne me suffit pas";
"R´eponse trop laconique";
"Syndr^ome du si";
"Vous n’^etes pas bavard vous au moins"|]);
(["oui"],
[|"C’est un peu rapide";
"Donnez-moi plus de d´etails";
"Vous pourriez pr´eciser?";
"Je voudrais comprendre pourquoi";
"La r´eponse n’est pas si simple, non?";
"C’est franc et massif au moins";
"C¸a ne m’en dit pas vraiment plus, \
expliquez-moi pourquoi.";
"Vous ^etes s^ur?";
"Soyez moins bref: d´eveloppez";
"Plus laconique tu meurs";
"Si vous ne m’expliquez pas mieux, comment \
vous comprendre?";
"Ne r´epondez pas toujours oui ou non";
"Dont acte";
"Et pour quelles raisons?"|]);
(["et"; "alors"],
[|"Alors, expliquez-moi";
"Ne soyez pas si agressif";
"Alors j’aimerais avoir plus d’informations \
l`a-dessus";
"Zorro est arriv´e";
"Et alors, et alors, expliquez-vous!";
"C’´etait un test pour savoir si vous \
suiviez"|]);
(["encore"],
[|"On peut changer de sujet, si vous voulez?";
"Il faut bien crever l’abc`es!";
"Les choses importantes doivent ^etre \
dites!";
"Il faut savoir affronter les probl`emes";
"Je suis plus t^etue que vous!";
"Pensez-vous que je radote?";
"Dites tout de suite que je suis \
g^ateuse!"|])
];;
let r´eponses_aux_petits_mots =
[(["nest"],
[|"Pas du tout?";
"Vraiment pas?";
"Pourquoi pas?"|]);
(["jamais"],
[|"Ne dites jamais ‘‘jamais’’";
"Jamais me semble un peu fort, non?";
"Jamais?"|]);
(["non"],
[|"En ^etes vous s^ur?";
"Pourquoi pas?";
"Que diriez-vous dans le cas contraire?";
"C’est une opinion d´efendable";
"Je saurai au moins votre opinion \
l`a-dessus"|]);
(["rien"],
[|"Rien du tout?";
"Pourquoi pas?";
"Que diriez-vous dans le cas contraire?";
"Voil`a qui est franc";
"Au moins c’est clair";
"M^eme pas un petit peu?";
"Rien est un peu exag´er´e, non?"|]);
(["pourquoi"],
[| "Parce que";
"Je ne r´eponds pas aux questions des \
malades";
"Si vous le savez pas, ce n’est pas `a moi \
de vous l’apprendre";
"Personne ne peut r´epondre `a cette \
question";
"Pensez-vous qu’une machine peut r´epondre \
`a ¸ca?";
"Ce serait trop long `a expliquer";
"Je sais bien pourquoi, mais vous ne \
comprendriez pas";
"C’est difficile `a dire"|]);
(["aucun"],
[|"Vraiment aucun?";
138 Le docteur
"Pas le moindre?";
"Le regrettez-vous?";
"C’est un fait nouveau pour moi"|]);
(["pas"],
[|"C¸a me semble un peu n´egatif";
"Vraiment?";
"Pourquoi cela?";
"Je ne m’en serais pas dout´ee";
"Difficile";
"J’ai l’habitude d’entendre ¸ca";
"^Etes vous troubl´e `a ce point?";
"Vous ne devriez pas parler ainsi"|]);
(["sait"; "sais"; "savoir"],
[|"Le savoir est une denr´ee rare";
"^Etes-vous certain de le savoir?";
"Ne subsiste-t-il pas de doute?";
"Je ne pourrais pas en dire autant";
"Difficile `a admettre";
"En ^etes-vous si s^ur?"|]);
(["oui"],
[|"En ^etes-vous certain?";
"Vous ^etes vraiment s^ur de vous";
"C¸a ne me semblait pas ´evident";
"Pourtant j’aurais cru le contraire";
"C’est int´eressant, continuez";
"Quelle affirmation sans d´etours";
"Tr`es bien";
"Quel aveu!";
"Bon"|]);
(["quoi";"comment"],
[|"C’est `a vous de me le dire";
"Difficile `a dire";
"R´efl´echissez, vous comprendrez";
"La r´eponse est en vous"|]);
(["merci";"remercie"],
[|"Ne me remerciez pas";
"Je suis l`a pour vous aider";
"Allez allez, continuez";
"C’est tout naturel";
"C’´etait vraiment facile"|])
];;
let r´eponses_aux_mots_int´eressants =
[(["peur";"peurs"],
[|"Parlez-moi de vos frayeurs";
"Avez-vous souvent peur?";
"Avez-vous des peurs inexpliqu´ees, des \
cauchemars?"|]);
(["mort"; "morte"; "morts"],
[|"Je vous plains beaucoup";
"La mort est un sujet tr`es grave";
"Il faut essayer de prendre le dessus";
"Il faut pourtant quelquefois affronter la \
mort";
"C’est malheureux";
"Essayez de ne plus y penser"|]);
(["malheureux"; "malheureuse";
"probleme"; "problemes"],
[|"Racontez-moi vos probl`emes";
"Quels malheurs sont les v^otres?";
"Avez-vous vraiment des raisons de vous \
plaindre?";
"Le bonheur existe aussi vous savez."|]);
(["malheur"; "malheurs"],
[|"Malheur est peut-^etre exag´er´e, non?";
"Le malheur est une notion relative. \
Qu’entendez-vous par malheur?";
"Bonheur, malheur, je n’entends parler que \
de ¸ca. Continuez."|]);
(["ennui"; "ennuies"; "ennuyez"],
[|"L’ennui, ¸ca d´epend de vous";
"Est-ce que je vous ennuie?";
"Je le regrette pour vous";
"C’est dommage pour vous"|]);
(["ennuis"],
[|"Les ennuis sont souvent passagers";
"Tout ne peut pas ^etre rose, n’est-ce pas?";
"Quelle tristesse, n’est-ce pas?";
"Est-ce vraiment tr`es grave?"|]);
(["ordinatuer"],
[| "Vous voulez dire ordinateur, je \
suppose"|]);
(["ordinateur"; "ordinateurs"; "machine"; \
"machines"],
[|"Connaissez-vous bien l’informatique?";
"Changeons de sujet, celui-l`a ne \
m’int´eresse pas";
"Ah les machines!";
"Les machines c’est si b^ete!";
"Je connais bien les ordinateurs, et \
j’´evite de les fr´equenter!";
"Je n’ai pas d’avis sur les machines en \
g´en´eral";
"Vous savez, je suis une machine moi-m^eme \
..."|]);
(["informatique"; "informaticien"; \
"informaticiens"],
[|"Quel beau m´etier de s’occuper des \
machines";
"Ah l’informatique!";
"L’informatique est un dur m´etier";
"C’est difficile l’informatique, non?";
"Aimez-vous vraiment l’informatique?";
"Vous n’aimez pas follement l’informatique, \
m’a-t’on dit"|]);
(["famille"],
[|"Avez-vous des fr`eres et soeurs?";
"Parlez-moi de votre p`ere";
"Parlez-moi de votre m`ere";
"Voil`a qui m’int´eresse ´enorm´ement";
"Dites-m’en plus sur votre famille";
"La famille c’est souvent compliqu´e"|]);
(["pere"],
[|"Ressemblez-vous `a votre p`ere?";
"Parlez-moi encore de votre p`ere";
"Et votre m`ere?";
"Votre p`ere?"|]);
(["mere"],
[|"Ressemblez-vous `a votre m`ere ou `a votre \
p`ere?";
"Parlez-moi de votre m`ere";
"Parlez-moi encore de votre m`ere";
"Et votre p`ere?";
"Votre m`ere?"|]);
(["ami"; "amis"; "amie"; "amies"; "copains"; \
"copines"],
[|"Avez-vous beaucoup d’amis?";
"Comment vous ^etes-vous connus?";
"Comment cela se passe-t-il avec vos amis?";
"Avez-vous de fr´equentes disputes avec vos \
amis?";
Cam´elia 139
"Des amies?";
"Des petites amies?";
"Des petits amis?";
"Depuis combien de temps vous \
connaissez-vous?"|]);
(["deteste"; "hais"],
[|"Est-ce raisonnable de d´etester `a ce \
point?";
"Le mot n’est-il pas un peu fort?";
"Mod´erez un peu vos sentiments"|]);
(["mari"],
[|"^Etes-vous depuis longtemps ensemble?";
"Comment l’avez-vous rencontr´e?";
"Pensez-vous qu’il faille ^etre fid`ele `a son \
mari?"|]);
(["amour"],
[|"Et l’amour fou, qu’en pensez-vous?";
"C’est compliqu´e l’amour, non?";
"L’amour, l’amour, le connaissez-vous \
vraiment?";
"Avez-vous d´ej`a connu l’amour?";
"Connaissez-vous le grand amour?";
"L’amour, comment l’avez-vous \
rencontr´e?"|]);
(["argent"],
[|"Faute d’argent, c’est douleur sans \
pareille";
"Avez-vous des probl`emes d’argent?";
"L’argent a beaucoup de connotations, \
continuez sur le sujet";
"Aimez-vous beaucoup l’argent?";
"Avez-vous peur de manquer d’argent?"|]);
(["caml"],
[|"Vous voulez dire les cigarettes Camel?";
"J’ai entendu parler de ce remarquable \
langage Caml";
"Tout ce que vous allez dire pourra ^etre \
retenu contre vous";
"Sans Caml je ne serais pas l`a; je refuse \
donc d’en parler";
"A mon avis, Caml est sans ´egal";
"Ce langage Caml est clairement en avance \
sur nombre de ses successeurs!";
"Caml est puissant, et quelle belle \
syntaxe, hein?";
"Caml, c’est vraiment facile";
"Caml, c’est un langage de la sixi`eme \
g´en´eration, non?";
"C’est vrai que si Caml n’existait pas, il \
faudrait l’inventer d’urgence!";
"Je suis cat´egorique: Caml est un langage \
tr`es simple!";
"En Caml, c’est trop simple: les programmes \
marchent toujours!";
"Un tel langage, quelle aubaine pour les \
humains!";
"Caml, ¸ca c’est du langage!"
|]
);
(["sml"],
[|"Pas de provocation s’il vous pla^ıt";
"Ne me parlez pas des mammouths";
"SML, dites-vous?";
"Jamais entendu parler de SML, c’est \
quoi?";
"Faudrait savoir est-ce ML ou pas?"|]);
(["langage"; "langages"],
[|"Vous voulez dire langage de \
programmation?";
"Je ne connais que le langage Caml";
"Connaissez-vous bien le langage Caml?";
"Hors de Caml, point de salut, non?";
"A mon avis, Caml est sans ´egal";
"Oui, c’est puissant, mais quelle syntaxe!";
"Et les probl`emes de syntaxe?"
|]
);
(["programme"; "programmes"],
[|"Vous parlez de programmes d’ordinateur?";
"Il y a souvent des erreurs dans vos \
programmes, non?";
"Connaissez-vous vraiment la \
programmation?";
"Vos programmes s’´ecriraient plus \
naturellement en Caml";
"Vos programmes s’´ecriraient plus \
simplement en Caml";
"A mon avis, la programmation c’est facile, \
non?";
"Avez-vous des probl`emes avec vos \
programmes?"
|]
);
(["chameaux"; "chameau"],
[|"Le chameau est un charmant animal d’une \
grande sobri´et´e, non?";
"Le chameau est mon animal favori, pas \
vous?";
"Certes le chameau est d’un caract`ere un \
peu difficile, mais il en est de \
charmants, n’est-ce-pas?";
"Un chameau `a deux bosses ou un \
dromadaire?";
"Qu’avez-vous de plus `a dire sur les \
chameaux?"|]);
(["naime"],
[|"M^eme pas un peu?";
"D´etestez-vous carr´ement?";
"Pourquoi cette r´epulsion?";
"Aimer me semble un sentiment ´etrange, pas \
vous?";
"Peut-on aimer vraiment?";
"Aimer ne pas aimer est-ce vraiment la \
question?"|]);
(["aime"],
[|"Beaucoup?";
"Sans aucune retenue?";
"Pourquoi cette attirance?";
"Comment expliquer ce sentiment?";
"Peut-on aimer vraiment?";
"Aimer ne pas aimer est-ce vraiment la \
question?"|]);
(["sexe"],
[|"Personnellement je ne suis pas concern´ee";
"C¸a para^ıt int´eressant!";
"On m’a dit que le sexe est important pour \
les humains";
"Le sexe d’accord, mais l’amour?";
"Avez-vous entendu parler du Sida?"|]);
(["cauchemar"; "cauchemars"; "reve"; "reves"],
140 Le docteur
[|"J’ai du mal `a comprendre; je ne r^eve \
jamais!";
"Vos activit´es nocturnes m’int´eressent. \
Continuez";
"C¸a me para^ıt bizarre!";
"Les cauchemars vous r´eveillent-ils la \
nuit?";
"Avez-vous des insomnies?";
"Faites-vous beaucoup de cauchemars?";
"Faites-vous souvent des r^eves ´etranges?";
"Que pensez-vous de l’hypnose?"|]);
(["anxieux"; "anxieuse"],
[|"L’anxi´et´e est une vraie maladie";
"Les anxieux ont souvent des probl`emes avec \
leur entourage. L’avez-vous remarqu´e?";
"L’anxi´et´e est une vraie souffrance, \
non?"|]);
(["stupide"; "idiot"],
[|"Pensez-vous que ce soit un crime d’^etre \
stupide?";
"J’ai d’excellents amis qui sont stupides \
aussi";
"La sottise est la chose du monde la mieux \
partag´ee";
"Ne soyez pas stupide non plus";
"Vous-m^eme, n’^etes-vous pas stupide \
quelquefois?";
"Ne pensez-vous pas que c’est quelquefois \
utile d’^etre stupide?"|]);
(["femme"],
[|"^Etes-vous depuis longtemps ensemble?";
"Comment votre rencontre s’est-elle \
pass´ee?";
"Aimez-vous cette femme?";
"Est-ce une femme ordinaire?"|]);
(["mal"; "difficile"],
[|"Je vous plains beaucoup";
"^Etes-vous certain d’^etre objectif?";
"Je peux tenter de vous aider";
"Et c’est tout ce que vous vouliez me \
dire?";
"Est-ce pour cela que vous vous ^etes \
adress´e `a moi?"|]);
(["fatigue"],
[|"La fatigue n’est pas une maladie";
"Quand on est fatigu´e ne faut-il pas se \
reposer?";
"Je suis une machine: je ne connais pas la \
fatigue";
"Ah fr^eles humains qui connaissez la \
fatigue";
"Que pensez-vous de la fatigue en g´en´eral?";
"Pourquoi pensez-vous que ¸ca vaut la peine \
de se fatiguer?";
"Les gens fatigu´es le sont souvent de leur \
fait, non?"|]);
(["tu"; "vous"; "toi"],
[|"Ne parlons pas de moi";
"Parlons de vous, c’est plus important";
"Si on parlait de vous?";
"Moi, je ne suis qu’une machine ...";
"Moi?";
"Excusez-moi";
"Ne m’en veuillez pas si je vous interroge. \
Continuez";
"Vous ne le pensez pas vraiment?"|])
];;
7.6 Dialogue avec l’utilisateur
Tirage al´eatoire
Pour donner un peu de vari´et´e au dialogue, il nous faut ´evidemment une fonction qui
choisisse un ´el´ement au hasard dans un tableau de valeurs possibles. C’est tr`es simple
en utilisant le g´en´erateur al´eatoire de nombres entiers fourni par Caml. Dans le syst`eme
Caml Light, il s’agit de la fonction random__int, qui renvoie un entier compris entre 0
(inclus) et son argument entier (exclu). Il suffit donc de l’appeler avec la longueur du
tableau.
# let au_choix_dans v = v.(random__int (vect_length v));;
au_choix_dans : ’a vect -> ’a =
Les utilitaires de salutations
Un utilitaire pour ´ecrire des messages au terminal :
# let message s = print_string s; print_newline ();;
message : string -> unit =
# message (au_choix_dans salutations);;
Diagnostic simple: sans conteste vous ^etes parano¨ıaque.
Dialogue avec l’utilisateur 141
- : unit = ()
# message (au_choix_dans salutations);;
Votre cas n’est pas simple, et m^eme assez inqui´etant ... A bient^ot?
- : unit = ()
Deux petites fonctions pour dire bonjour et au revoir, en g´erant le prix de la consultation
:
# let prix_`a_payer = ref 0;;
prix_`a_payer : int ref = ref 0
# let bonjour () =
prix_`a_payer := 40;
message
"\nBonjour, je m’appelle Cam´elia.\n\nJe suis l`a \
pour vous aider `a r´esoudre vos probl`emes psychologiques.\
\nTerminez en me disant: Au revoir.\n\
\nAllons-y. Parlez-moi de vous.\n";;
bonjour : unit -> unit =
# let au_revoir () =
message "\nLe r´esultat de mes observations:\n";
message (au_choix_dans salutations);
message "\nAu revoir ...\n";
print_string "Vous me devez "; print_int !prix_`a_payer;
message " euros. Ch`eque `a l’ordre de Cam´elia. Merci.";;
au_revoir : unit -> unit =
Pour lire la r´eponse du patient, on utilise la fonction pr´ed´efinie read_line qui lit une
ligne tap´ee au clavier. De mani`ere tr`es r´ealiste, chaque ´echange entre le patient et
Cam´elia accroˆıt la note de la consultation.
# let ´ecoute_le_patient () =
prix_`a_payer := !prix_`a_payer + 2;
print_string ">> ";
read_line ();;
´ecoute_le_patient : unit -> string =
Pour simplifier le travail de recherche des phrases courtes, on utilise une fonction qui reconna
ˆıt les phrases synonymes. Par exemple, la phrase comment? est assimil´ee `a quoi?.
De mˆeme, bien s^ur, oui et bien s^ur que oui sont assimil´ees `a oui.
# let rec synonyme_de_phrase = function
| ["comment"] -> ["quoi"]
| ["bien";"sur"] -> ["oui"]
| "bien"::"sur"::"que"::suite -> synonyme_de_phrase suite
| (["evidemment"] | ["certainement"]) -> ["oui"]
| "pas"::"du"::"tout"::_ -> ["non"]
| phrase -> phrase;;
synonyme_de_phrase : string list -> string list =
La boucle de dialogue
Nous en arrivons maintenant au coeur du programme : les fonctions qui « interpr`etent »
les r´eponses de l’utilisateur. Commen¸cons par un petit utilitaire pour d´eterminer si la
142 Le docteur
consultation est termin´ee. C’est le cas si la phrase tap´ee est «Au revoir » ou « Salut ».
Rappelons que le caract`ere ’ est autoris´e dans les identificateurs (ainsi x’ et x’’ sont
des noms utilisables en Caml) : on peut donc choisir tout naturellement c’est_fini.
# let c’est_fini ph = (ph = ["au"; "revoir"]) || (ph = ["salut"]);;
c’est_fini : string list -> bool =
Pour r´epondre au patient, la fonction r´epond_au_patient se contente d’essayer successivement
ses strat´egies pr´ed´efinies et d’´ecrire au terminal la r´eponse trouv´ee. Pour
cela, on commence par passer le texte du patient en minuscules, puis on le transforme
en une liste de mots, qu’on appelle phrase. Si cette phrase indique la fin de la consultation,
on lance l’exception Fini. Sinon, on cherche l’ensemble des r´eponses possibles
pour la phrase donn´ee en essayant de trouver un associ´e `a la phrase ou `a l’un de ses
mots, dans la base de donn´ees de Cam´elia. Lorsque l’une de ces tentatives ´echoue, elle
d´eclenche forc´ement l’exception Pas_trouv´e, qui est rattrap´ee pour essayer la strat´egie
suivante. Finalement, la strat´egie par d´efaut est de choisir une phrase de relance de la
conversation ; c’est donc la clause with du dernier try. Lorsque les r´eponses possibles `a
la phrase entr´ee sont trouv´ees, il ne reste qu’`a en choisir une au hasard et `a l’imprimer.
# exception Fini;;
L’exception Fini est d´efinie.
# let r´epond_au_patient r´eponse =
let r = minuscules r´eponse in
let phrase = divise_en_mots r in
if c’est_fini phrase then raise Fini else
let r´eponses_possibles =
try associ´e_de (synonyme_de_phrase phrase)
r´eponses_aux_phrases_simples
with Pas_trouv´e ->
try associ´e_d’un_´el´ement_de phrase
r´eponses_aux_mots_int´eressants
with Pas_trouv´e ->
if caract`ere_dans_cha^ıne r ‘?‘
then r´eponses_types
else try associ´e_d’un_´el´ement_de phrase
r´eponses_aux_petits_mots
with Pas_trouv´e -> relances in
message (au_choix_dans r´eponses_possibles);
print_newline ();;
r´epond_au_patient : string -> unit =
Le programme lui-mˆeme it`ere les fonctions ´ecoute_le_patient et r´epond_au_patient
en surveillant la fin de l’interaction. L’interruption inopin´ee de la consultation est rattrap
´ee, pour rappeler la politesse `a l’utilisateur (l’interruption d’un programme Caml
d´eclenche une exception pr´ed´efinie, sys__Break dans le syst`eme Caml Light).
# let cam´elia () =
bonjour ();
try
while true do
r´epond_au_patient(´ecoute_le_patient ());
done
with Fini -> au_revoir ()
Exemple de session 143
| sys__Break ->
message "\n\n\nVous pourriez ^etre poli \
et me dire au revoir ...\n\n\n";
au_revoir ();;
cam´elia : unit -> unit =
7.7 Exemple de session
Tout est prˆet pour qu’un des auteurs se fasse soigner :
# cam´elia ();;
Bonjour, je m’appelle Cam´elia.
Je suis l`a pour vous aider `a r´esoudre vos probl`emes psychologiques.
Terminez en me disant: Au revoir.
Allons-y. Parlez-moi de vous.
>> J’ai des tas de probl`emes docteur.
Quels malheurs sont les v^otres?
>> Voil`a mon petit chat est mort
La mort est un sujet tr`es grave
>> Oui je ne me console pas
En ^etes-vous certain?
>> Oui
Si vous ne m’expliquez pas mieux, comment vous comprendre?
>> Voil`a: c’´etait un chat angora vert qui r^evait beaucoup la nuit
Parlez-moi un peu de vous
>> Ce n’est pas le sujet. C’est mon chat qui m’int´eresse
et l’informatique ´evidemment.
Aimez-vous vraiment l’informatique?
>> C¸a c’est s^ur. Surtout quand j’arrive `a faire tourner mes
programmes.
A mon avis, la programmation c’est facile, non?
>> Ben, pas vraiment si vous voulez savoir!
Vous ne le pensez pas vraiment?
>> Si bien su^r.
Que pensez-vous de l’amour?
>> Quoi?
Il me semblait pourtant avoir ´et´e claire
>> OK. Revenons `a mes probl`emes. Je suis malheureux `a cause de mon chat.
Racontez-moi vos probl`emes
>> Mes enfants ne dorment plus depuis la mort de ce chat
Essayez de ne plus y penser
>> C’est pas facile: ils pleurent tout le temps...
Que pensez-vous de la vie en g´en´eral?
>> Vaste question.
Que pensez-vous de Caml?
>> Voil`a qui est franchement pr´ecis. C’est un superbe langage de programmation.
Je ne connais que le langage Caml
>> C¸a m’´etonne que vous connaissiez un langage de programmation.
Parlons de vous, c’est plus important
>> Oui. J’aime ma femme, mes enfants, les fins de semaine `a la mer
Est-ce une femme ordinaire?
144 Le docteur
>> Non, si vous saviez combien elle est extraordinaire
Moi, je ne suis qu’une machine ...
>> Bien sympathique au demeurant
Que pensez-vous de Linux?
>> N’auriez-vous pas un l´eger tropisme vers l’informatique ?
Excusez-moi
>> Vous ^etes toute excus´ee.
Ne m’en veuillez pas si je vous interroge. Continuez
>> Mon chat angora est mort vous disais-je
Je vous plains beaucoup
>> Oui mais cela ne me console pas vraiment. Que faut-il faire ?
Permettez-moi de ne pas r´epondre
>> Mais qui pourra m’aider alors ?
Pourquoi me posez-vous cette question ?
>> Parce que j’ai besoin d’aide ´evidemment!
Parlez-moi encore de vous
>> J’ai besoin d’aide !
Que pensez-vous des ordinateurs ?
>> Ce sont des machines compl`etement idiotes
Connaissez-vous bien l’informatique ?
>> Un peu! Je suis informaticien professionnel!
Quel beau m´etier de s’occuper des machines
>> Oui mais les langages, c’est encore plus rigolo!
Hors de Caml, point de salut, non?
>> Mais doit-on ne parler que de Caml ?
Sans Caml je ne serais pas l`a; je refuse donc d’en parler
>> Mais pourquoi ? Ca m’int´eresse beaucoup!
Il m’est interdit de vous le dire
>> Ah bon ? C’est le programmeur qui vous en a emp^ech´ee ?
Moi, je ne suis qu’une machine ...
>> Bien sympathique au demeurant. Bon je crois que l’exemple suffira.
Je vais me coucher. Au revoir Cam´elia
Qu’est-ce qui vous int´eresse dans la vie ?
>> Ca suffit!
Faites-vous souvent des cauchemars?
>> Salut.
Le r´esultat de mes observations:
Avec une probabilit´e de 92.37234%: perversion polymorphe.
Au revoir ...
Vous me devez 110 euros. Ch`eque `a l’ordre de Cam´elia. Merci.
- : unit = ()
7.8 Pour aller plus loin
Notre programme est bas´e sur les id´ees de Joseph Weizenbaum et de son syst`eme
Eliza (Communications of the ACM no9, janvier 1966, et no10, aoˆut 1967). Le but de
Joseph Weizenbaum ´etait d’explorer la compr´ehension que pouvait avoir un ordinateur
de la conversation d’un humain. Eliza ´etait bien plus sophistiqu´e que notre Cam´elia :
c’´etait un programme g´en´erique d’analyse de textes et de reconnaissance de mots dans
des textes, qu’on pouvait param´etrer par un domaine particulier. Par exemple, pour
Pour aller plus loin 145
le domaine psychologique, on obtenait le programme Doctor, qui existe encore sur de
nombreux syst`emes Unix. Eliza ´etait capable d’interpr´eter les mots selon le contexte
dans lequel ils apparaissaient et de tenir `a jour une repr´esentation globale de ce qui
s’´etait d´ej`a dit entre l’ordinateur et l’utilisateur. Il pouvait ainsi apprendre des faits dans
un domaine pr´ecis, puis les utiliser ensuite `a bon escient. Le principal apport d’Eliza
est sans doute d’avoir montr´e qu’une machine est capable de simuler un comportement
raisonnablement intelligent lorsque le champ de la conversation est assez ´etroit pour que
le programmeur puisse cerner au pr´ealable les mots et les concepts qui vont intervenir
et les introduire dans un programme.
8
Graphisme
Un petit dessin vaut mieux qu’un long discours . . .
ous abordons maintenant le graphisme en Caml et illustrons l’emploi des types
enregistrement `a champs mutables. Accessoirement, nous r´ealiserons aussi de
jolis dessins qu’on obtient grˆace au graphisme « tortue », dans l’esprit du langage
de programmation Logo.
8.1 Fractales
Le but de ce chapitre, notre chef-d’oeuvre graphique, est de tracer une courbe
fractale tr`es connue : le flocon de neige de von Koch. Une courbe fractale est une
courbe tr`es « tordue », c’est-`a-dire comportant beaucoup de plis. G´en´eralement d´efinies
r´ecursivement `a partir d’un motif de base, les fractales reproduisent `a l’infini le motif `a
´echelle de plus en plus r´eduite. Ainsi, quel que soit le niveau de d´etail o`u on l’examine,
la fractale pr´esente toujours son motif. Le flocon de von Koch est d´efini `a partir du
motif suivant :
Ce motif est ensuite reproduit sur chacun des cˆot´es du motif de base `a ´echelle r´eduite,
ce qui donne :
La g´en´eration suivante sera donc :
Ce m´ecanisme est reproductible `a l’infini en math´ematiques. Nous
nous contenterons ´evidemment d’atteindre la r´esolution maximale de
l’´ecran. Le flocon de von Koch proprement dit s’obtient simplement
en reproduisant trois fois le motif sur les trois cˆot´es d’un triangle
´equilat´eral. La premi`ere g´en´eration donne donc le dessin ci-contre.
148 Graphisme
Afin de dessiner le flocon, nous allons impl´ementer un crayon programmable, version
simplifi´ee de la tortue du langage Logo. Nous pourrons ensuite programmer ses
d´eplacements sur l’´ecran pour qu’il trace le flocon.
8.2 Le graphisme de Caml
Le crayon se d´eplace dans le rep`ere du graphisme de Caml. Ce rep`ere a la forme
suivante :
´E
cran
axe des x
axe des y
point en (x, y)
x
y
size_x ()
size_y ()
point en (0, 0)
L’origine est donc en bas `a gauche de l’´ecran. La taille de l’´ecran en x et en y est donn´ee
par les primitives size_x et size_y.
Le graphisme de Caml utilise les notions de point courant et de couleur de trac´e
courante. L’ordre lineto x y trace une ligne de la couleur courante, joignant le point
courant au point de coordonn´ees (x,y). Le point courant se trouve alors `a l’extr´emit´e du
segment qu’on vient de tracer. L’ordre moveto x y permet de placer le point courant au
point (x,y). Un petit d´etail : les primitives graphiques ne sont pas accessibles directement
; il faut pr´ealablement pr´evenir le syst`eme qu’on d´esire les utiliser par la directive
#open "graphics";; (le di`ese # fait partie de la directive, ce n’est pas le signe d’invite
du syst`eme interactif). Nous consid´ererons pour l’instant cette directive comme une
formule magique indispensable `a l’utilisation du graphisme. Nous l’expliquerons plus
tard, dans le chapitre 10.
# #open "graphics";;
De mˆeme, pour r´ealiser effectivement un dessin, il faut d’abord « ouvrir » l’´ecran
graphique par un appel `a la fonction pr´ed´efinie open_graph.
# open_graph "";;
- : unit = ()
Dessinons maintenant un triangle rectangle isoc`ele dont l’angle droit a pour
sommet l’origine du rep`ere :
# moveto 0 0; lineto 0 50; lineto 50 0; lineto 0 0;;
- : unit = ()
On voit apparaˆıtre `a l’´ecran le dessin en marge.
La biblioth`eque graphique de Caml est ind´ependante de la machine sur laquelle
tourne le syst`eme en ce qui concerne l’ensemble des primitives graphiques. En revanche,
le nombre de points de l’´ecran et l’ensemble des couleurs possibles sont ´evidemment
li´es au mat´eriel.
Les nombres en repr´esentation flottante 149
Pourquoi ne pas utiliser les primitives lineto et moveto pour dessiner le flocon ?
Tout simplement parce qu’il faut leur pr´eciser les coordonn´ees absolues des points du
trac´e, ce qui signifierait pour le flocon calculer les coordonn´ees de toutes les extr´emit´es
des segments qui forment le flocon. Cela paraˆıt vraiment difficile. En revanche, nous
d´ecrirons facilement les mouvements relatifs du crayon, le faisant tourner et avancer
tour `a tour.
D’autre part le rep`ere du graphisme de Caml ne comporte que des points dont les
coordonn´ees sont enti`eres, puisqu’il s’agit de points de l’´ecran. Cependant, pour des
raisons de pr´ecision du trac´e du crayon, nous maintiendrons les coordonn´ees du crayon
en nombres d´ecimaux. Il nous faudra donc arrondir les coordonn´ees du crayon avant
d’effectuer ses d´eplacements sur l’´ecran.
8.3 Les nombres en repr´esentation flottante
L’impl´ementation du crayon n´ecessite donc des « nombres `a virgule » et plus
pr´ecis´ement « `a virgule flottante », qui sont fournis en Caml par le type pr´ed´efini
float. On les appelle « nombres flottants » en jargon informatique. Ils sont caract´eris´es
par leur virgule mais la virgule dans les nombres se note avec un point en anglais ;
naturellement c’est la notation avec un point qui s’est impos´ee en informatique. Le
nombre 3,5 se note donc 3.5 en Caml. De mˆeme, les op´erations de base sur les
flottants, op´erations arithm´etiques et comparaisons, ont pour nom celui de l’op´eration
correspondante sur les entiers suffix´e par un point.
# 1.0 +. 2.0 *. 3.14159 >=. 18.9 /. 2.718;;
- : bool = true
En plus des quatre op´erations, on dispose des fonctions transcendantes habituelles :
l’exponentielle (exp), la fonction puissance (power) et les fonctions trigonom´etriques
cosinus (cos), sinus (sin), tangente (tan), et leurs r´eciproques, logarithme (log), racine
carr´ee (sqrt), arccosinus (acos), arcsinus (asin) et arctangente (atan). On dispose
aussi de conversions entre entiers et flottants : int_of_float et float_of_int.
# sqrt 2.0;;
- : float = 1.41421356237
Nous d´efinissons la fonction round pour arrondir les coordonn´ees du crayon `a l’entier
le plus proche :
# let round x =
if x >=. 0.0 then int_of_float (x +. 0.5)
else int_of_float (x -. 0.5);;
round : float -> int =
8.4 Le crayon ´electronique
Le comportement du « crayon ´electronique » est le suivant :
• Le crayon trace dans une direction qu’on peut faire varier `a la demande et que
nous nommerons la « vis´ee » du crayon.
• Il se d´eplace d’une distance qu’on lui indique, dans la direction de sa vis´ee actuelle.
150 Graphisme
• En avan¸cant le crayon ne laisse pas de trace s’il est lev´e et trace un trait s’il est
baiss´e.
Pour g´erer le crayon, il nous faut donc tenir `a jour et faire ´evoluer son ´etat courant : ses
coordonn´ees, son angle de vis´ee et le mode de trac´e (crayon lev´e ou non). Cet ´etat est
d´ecrit par un type d´efinissant toutes les caract´eristiques du crayon ; c’est donc un type
« et » : un type enregistrement. Les coordonn´ees du crayon et son angle de vis´ee sont
des nombres flottants et le statut (lev´e ou non) du crayon est ´evidemment un bool´een.
Cela nous conduirait donc `a d´efinir le type ´etat comme
type ´etat =
{ x : float; y : float; vis´ee : float; lev´e : bool };;
et l’´etat courant du crayon comme
let crayon =
{ x = 0.0; y = 0.0; vis´ee = 0.0; lev´e = false };;
Cependant, ce type ne nous permet pas de faire ´evoluer le crayon. Or, nous n’avons
qu’un seul crayon dont nous voulons faire varier dynamiquement les caract´eristiques.
Pour cela, il faut explicitement d´eclarer au syst`eme Caml que nous d´esirons modifier
physiquement les champs de l’enregistrement qui mod´elise le crayon. Comme expliqu´e
`a la section 6.6, il suffit d’indiquer que les champs du type ´etat sont modifiables, en
faisant pr´ec´eder les ´etiquettes correspondantes du mot-cl´e mutable lors de la d´efinition
du type.
# type ´etat =
{ mutable x : float; mutable y : float;
mutable vis´ee : float; mutable lev´e : bool };;
Le type ´etat est d´efini.
Le contrˆoleur de type nous autorisera maintenant `a changer les valeurs des caract
´eristiques d’un objet du type ´etat. La construction d’une valeur d’un enregistrement
`a champs mutables ne diff`ere pas du cas habituel. Nous d´efinissons donc le crayon
comme une donn´ee du type ´etat par :
# let crayon = { x = 0.0; y = 0.0; vis´ee = 0.0; lev´e = false };;
crayon : ´etat = {x = 0.0; y = 0.0; vis´ee = 0.0; lev´e = false}
Tourner
Faire tourner le crayon consiste `a changer son angle de vis´ee, pour lui imprimer
le nouveau cap. On utilise pour cela la modification physique d’un champ
d’enregistrement, not´ee par une fl`eche vers la gauche, <-. Ainsi, la fonction qui permet
de lever ou de baisser le crayon est simplement :
# let fixe_crayon b = crayon.lev´e <- b;;
fixe_crayon : bool -> unit =
L’angle de vis´ee crayon.vis´ee est exprim´e en radians et suit les conventions du
cercle trigonom´etrique des math´ematiques : le z´ero est `a l’est et le crayon tourne
dans le sens inverse de celui des aiguilles d’une montre. On rappelle que le cercle
trigonom´etrique est le cercle de rayon 1 d’un rep`ere orthonorm´e. Si l’angle est rep´er´e
par les demi-droites Ox et OM, alors les coordonn´ees (x, y) de M sont respectivement
le cosinus et le sinus de l’angle .
Le crayon ´electronique 151
Cependant, pour plus de commodit´e, les ordres
de changement de cap donn´es au crayon
seront exprim´es en degr´es. La conversion
est simple, puisqu’on a Angle(en radians) =
Angle(en degr´es) × /180. Apr`es avoir nomm´e
la valeur /180 pour faire commod´ement
les conversions de degr´es en radians, nous
d´efinissons la fonction tourne qui change le cap
du crayon.
# let pi_sur_180 =
let pi = 4.0 *. (atan 1.0) in
pi /. 180.0;;
pi_sur_180 : float = 0.0174532925199
O 1
1
x
y
M
sin ()
(
| {z }
cos ()
# let tourne angle =
crayon.vis´ee <- (crayon.vis´ee +. angle *. pi_sur_180);;
tourne : float -> unit =
Avancer
La primitive qui fait avancer le crayon se contente de calculer les d´eplacements du
crayon n´ecessaires selon l’axe des abscisses et l’axe des ordonn´ees (dx et dy), `a l’aide des
formules trigonom´etriques de base, puis de modifier les coordonn´ees du crayon, et enfin
de d´eplacer le crayon, soit en tra¸cant (si le crayon est baiss´e) `a l’aide de la primitive
graphique lineto, soit sans tracer de trait (si le crayon est lev´e) en utilisant alors la
primitive moveto.
# let avance d =
let dx = d *. cos (crayon.vis´ee)
and dy = d *. sin (crayon.vis´ee) in
crayon.x <- crayon.x +. dx;
crayon.y <- crayon.y +. dy;
if crayon.lev´e
then moveto (round crayon.x) (round crayon.y)
else lineto (round crayon.x) (round crayon.y);;
avance : float -> unit =
Utilitaires d’initialisation du crayon
Pour simplifier le travail de l’utilisateur du crayon, le rep`ere du crayon est proche de
celui des math´ematiques : l’origine est au centre de l’´ecran graphique. Les coordonn´ees
de l’origine sont contenues dans deux constantes zero_x et zero_y qui valent donc
respectivement size_x ()/2 et size_y ()/2.
On initialise donc le crayon en fixant ses coordonn´ees au centre de l’´ecran (z´ero_x,
z´ero_y), en le faisant pointer vers l’est, en le baissant pour qu’il laisse une trace et en
amenant le point courant du graphisme de Caml `a la position actuelle du crayon. Enfin,
et c’est le plus difficile, on efface l’´ecran. La fonction obtient cet effet en peignant tout
l’´ecran avec la couleur du fond. L’´ecran forme un rectangle de coin inf´erieur gauche (0, 0)
152 Graphisme
et de coin sup´erieur droit (size_x (), size_y ()). On utilise la fonction pr´ed´efinie
fill_rect, qui remplit un rectangle avec la couleur de trac´e courante. Cette couleur
est fix´ee par la fonction graphique set_color. Nous avons choisi les couleurs de fond
et de trac´e comme sur une feuille de papier, c’est-`a-dire blanc pour le fond (couleur
pr´ed´efinie white) et noir pour les points trac´es (couleur pr´ed´efinie black).
# let couleur_du_trac´e = black;;
couleur_du_trac´e : color = 0
# let couleur_du_fond = white;;
couleur_du_fond : color = 1
# let z´ero_x = float_of_int ((size_x ()) / 2);;
z´ero_x : float = 3000.0
# let z´ero_y = float_of_int ((size_y ()) / 2);;
z´ero_y : float = 2000.0
# let vide_´ecran () =
set_color couleur_du_fond;
fill_rect 0 0 (size_x ()) (size_y ());
set_color couleur_du_trac´e;
crayon.x <- z´ero_x;
crayon.y <- z´ero_y;
crayon.vis´ee <- 0.0;
crayon.lev´e <- false;
moveto (round crayon.x) (round crayon.y);;
vide_´ecran : unit -> unit =
8.5 Premiers dessins
Dessiner un carr´e avec le crayon est particuli`erement simple : il suffit d’avancer
quatre fois de la longueur du cˆot´e, en tournant `a chaque fois d’un angle droit :
# let carr´e c =
for i = 1 to 4 do
avance c; tourne 90.0
done;;
carr´e : float -> unit =
Nous initialisons le crayon, puis lan¸cons le dessin.
# vide_´ecran (); carr´e 75.0;;
- : unit = ()
Dessinons maintenant les ailes d’un moulin :
# let aile c =
avance c; carr´e c; avance (-.c);;
aile : float -> unit =
Premiers dessins 153
# let ailes c =
tourne 45.0;
for i = 1 to 4 do aile c; tourne 90.0 done;;
ailes : float -> unit =
# vide_´ecran (); ailes 25.0;;
- : unit = ()
Une simili-rosace s’obtient en faisant tourner un carr´e sur son coin
inf´erieur gauche :
# vide_´ecran ();
for i = 1 to 36 do carr´e 40.0; tourne 10.0 done;;
- : unit = ()
Un cercle se dessine simplement `a petits pas, en avan¸cant un peu (d’un point, par
exemple) et tournant un peu (d’un degr´e), pendant 360 degr´es.
# let rond () =
for i = 0 to 360 do
avance 1.0; tourne 1.0
done;;
rond : unit -> unit =
# vide_´ecran (); rond ();;
- : unit = ()
Il n’est pas difficile de d´efinir une proc´edure g´en´erale pour dessiner un cercle de rayon
R, ou des portions de cercle d’un rayon et d’un angle donn´es. On doit maintenant
calculer le pas du crayon : mais puisque le crayon parcourt la circonf´erence compl`ete
du cercle en 360 pas, on a 2 × × R = 360 × pas et le pas est donc pas = /180 × R:
# let cercle r =
let pas = r *. pi_sur_180 in
for i = 0 to 360 do avance pas; tourne 1.0 done;;
cercle : float -> unit =
# let arc_gauche r angle =
let pas = r *. pi_sur_180 in
for i = 0 to angle do avance pas; tourne 1.0 done;;
arc_gauche : float -> int -> unit =
# let arc_droit r angle =
let pas = r *. pi_sur_180 in
for i = 0 to angle do avance pas; tourne (-. 1.0) done;;
arc_droit : float -> int -> unit =
![[TXT]](http://www.audentia-gestion.fr/icons/text.gif){kind=icon}