Introduction `a la programmation fonctionnelle avec Ocaml

Introduction ` a la programmation fonctionnelle avec Ocaml
M.V. Aponte
15 mars 2010
1 Introduction
Depuis les d´ ebuts de l’informatique une tr` es grande quantit´ e de langages de programmation (voir figure
11) sont apparus, si bien qu’il est parfois difficile de faire un choix, de les comparer ou tout simplement
de les distinguer. Les paradigmes de programmation sont ` a cet ´ egard un pr´ ecieux outil. Il s’agit de styles
de programmation commun´ ement accept´ es par les programmeurs, avec la particularit´ e de bien s’adapter ` a
certains types de probl` emes, et auxquels adh` erent plus ou moins la grande majorit´ e des langages. Parmi les
styles les plus connus on trouve la programmation imp´ erative, la programmation objet, la programmation
logique, la programmation fonctionnelle. Peu de langages de appartiennent ` a une seule de ces cat´ egories.
Le plus souvent, ils sont hybrides : ils se classent majoritairement dans une cat´ egorie, tout en int´ egrant des
capacit´ es int´ eressantes appartenant ` a d’autres styles. La connaissance de plusieurs paradigmes permet au
programmeur de discerner parmi la jungle des langages, et de comprendre et d’exploiter au mieux les avan-
tages des diff´ erents styles.
Ocaml est un langage fonctionnel incorporant plusieurs paradigmes de programmation. Il est issu du
langage ML, et a r´ ecemment influenc´ e le langage F# de la plate-forme .NET d´ evelopp´ ee par Microsoft. Il
incorpore des traits imp´ eratifs et objets ainsi que de puissantes constructions modulaires. Il est d´ evelopp´ e` a
l’INRIA depuis les ann´ ees 80. Ocaml est un langage int´ eressant ` a plusieurs ´ egards :
– Ocaml est fortement typ´ e avec des types inf´ er´ es statiquement et du polymorphisme param´ etrique.
Cela en fait un langage sˆ ur et facile ` a employer.
– Ocaml poss` ede les traits habituels des langages objets : classes, instances, h´ eritage multiple et liaison
retard´ ee. Il propose aussi des constructions plus ´ evolu´ ees : parmi celles-ci les classes abstraites et les
classes param´ etr´ ees.
– Ocaml poss` ede un syst` eme de modules tr` es g´ en´ eriques, un m´ ecanisme de programmation par filtrage
puissant autorisant une ´ ecriture de fonctions concise et claire, des structures des donn´ ees r´ ecursives
expressives et faciles ` a d´ ecrire et ` a exploiter via la programmation par filtrage.
– La s´ emantique de Ocaml est bien d´ efinie et la partie purement fonctionnelle est particuli` erement
adapt´ e au raisonnement math´ ematique sur les programmes que nous aborderons en deuxi` eme par-
tie de ce cours.
– Ocaml poss` ede un glaneur de cellules (garbage collector), et des nombreuses biblioth` eques. Il peut
ex´ ecuter des processus l´ egers (threads) et communique sur Internet (ouverture de canaux de commu-
nication, applications client-serveur, etc.). Il offre ´ egalement la possibilit´ e d’interagir avec le langage
C.
1. Source : http://www.oreilly.com/news/graphics/prog lang poster.pdf
1

1986 1990 1990 1991 1991 1993 1994 1995 1996 1996 1997 1997 2000 2001 2001 2003 2003 2004
History of Programming Languages
©2004 O’Reilly Media, Inc. O’Reilly logo is a registered trademark of O’Reilly Media, Inc. All other trademarks are property of their respective owners. part#30417
19601954 1965 1970 1975 1980 1985 1990 1995 2000 2002
2001 2003 2004
For more than half of the fifty years computer programmers have been
writing code, O’Reilly has provided developers with comprehensive,
in-depth technical information. We’ve kept pace with rapidly changing
technologies as new languages have emerged, developed, and
matured. Whether you want to learn something new or need
answers to tough technical questions, you’ll find what you need
in O’Reilly books and on the O’Reilly Network.
This timeline includes fifty of the more than 2500 documented
programming languages. It is based on an original diagram created
by Éric Lévénez (www.levenez.com), augmented with suggestions
from O’Reilly authors, friends, and conference attendees.
For information and discussion on this poster,
go to www.oreilly.com/go/languageposter.
www.oreilly.com
FIGURE 1 – La jungle des langages de programmation
– Ocaml est un langage compil´ e qui poss` ede une boucle interactive : les tests y sont plus faciles. On
peut ´ egalement produire du code ex´ ecutable portable (bytecode) ou natif, dont l’efficacit´ e est proche
du code C dans certains cas.
Malgr´ e ses origines acad´ emiques Ocaml est un langage dont l’utilisation d´ epasse le domaine de la re-
cherche en langages et leurs outils associ´ es. Il est utilis´ e pour l’enseignement dans des nombreuses uni-
versit´ es en France, aux Etats Unis et au Japon, et dans les classes pr´ eparatoires franc¸aises. Il est de plus
en plus adopt´ e en industrie : dans l’industrie a´ eronautique pour l’analyse des programmes, en vertu de sa
sˆ uret´ e de programmation (projet Astr´ ee : Analyse Statique de logiciels Temps-R ´ Eel Embarqu´ es) ; pour le
contrˆ ole des syst` emes critiques en avionique (Airbus) et dans le secteur nucl´ eaire. Des grands groupes de
l’industrie du logiciel utilisent Ocaml (F# :Microsoft, Intel, XenSource). Il est employ´ e´ egalement pour
´
ecrire des applications dans le secteur financier (Jane Street Capital, Lexifi), par des projets libres comme
MLDonkey (peer-to-peer), GeneWeb (logiciel de g´ en´ ealogie), Unison (logiciel de synchronisation de fi-
chiers multi-plateforme dans certaines distributions Linux), par certains logiciels de l’environnement KDE,
par des syst` emes bio-informatiques pour l’analyse des prot´ eines, et par beaucoup d’autres.
1.1 La programmation fonctionnelle
La programmation fonctionnelle est fond´ ee sur la notion math´ ematique de fonction. Une fonction relie
les ´ el´ ements de deux ensembles : le domaine et le co-domaine de la fonction. Ainsi, ` a chaque valeur du
domaine, la fonction fait correspond une unique valeur de son co-domaine.
tri : suite d’articles →suite d’articles tri´ es
s7→ tri(s)
La caract´ eristique essentielle des fonctions est d’associer une seule valeur image pour chaque valeur
du domaine, de mani` ere stable et ind´ ependante du contexte. En math´ ematiques, une fonction appliqu´ ee sur
un mˆ eme argument, donne toujours le mˆ eme r´ esultat : elle ne change pas de r´ esultat selon la valeur des
2

variables ou de ”l’´ etat du syst` eme”. Les op´ erations des langages de programmation imp´ eratifs ne jouissent
pas de cette stabilit´ e. Voici par exemple une op´ eration simple en langage C :
i n t i = 0 ;
i n t f ( int j ) {
i = i + j ;
r e t u r n i ;
}
L’op´ eration fne correspond pas ` a une fonction : son r´ esultat n’est pas seulement fonction de son argu-
ment jmais aussi de la valeur courante de la variable globale i, qui de plus est modifi´ ee lors de chaque
appel. Le r´ esultat obtenu d´ epend donc de l’´ etat des variables au moment de l’appel, et modifie directement
cet ´ etat. L’op´ eration fne peut pas ˆ etre ´ etudi´ ee en dehors de son contexte.
L’id´ ee derri` ere la programmation fonctionnelle est de favoriser la r´ ealisation des calculs ` a l’aide de
fonctions au sens math´ ematique du terme. Ceci afin de tirer parti de leur s´ eparation du contexte et de la
stabilit´ e qui en d´ ecoule.
1.1.1 Les fonctions vues comme des valeurs
En programmation fonctionnelle les fonctions sont des valeurs au mˆ eme titre que les entiers, les enre-
gistrements ou les tableaux. Ainsi par exemple, il est possible de stocker une fonction dans une variable
ou dans un tableau afin de l’appliquer plus tard ` a son argument, ou de passer une fonction en param` etre ` a
une autre fonction. Cela ´ el` eve les fonctions au statut des donn´ ees. On parle alors de pleine fonctionnalit´ e
ou ordre sup´ erieur ou encore des fonctions comme ´ etant des entit´ es de premi` ere classe. Il en d´ ecoule un
m´ ecanisme de g´ en´ eralisation assez puissant. Consid´ erons par exemple la fonction de tri d’un ensemble d’ar-
ticles. Son fonctionnement d´ epend du crit` ere d’ordonnancement ` a employer pour r´ ealiser le tri. Plutˆ ot que
de fixer celui-ci dans la fonction de tri, on peut le lui passer en tant qu’argument. La fonction de tri devient
g´ en´ erale ` a tout crit` ere et peut ˆ etre employ´ ee dans beaucoup de contextes.
tri : crit` ere de comparaison ×suite d’articles →suite d’articles tri´ es
(fcomp, s)7→ tri(fcomp, s)
Cette g´ en´ eralisation en Ocaml prendra la forme :
l e t t r i ( f c o m p a r e , a r t i c l e s ) = . . .
Dans d’autres langages, ce genre de g´ en´ eralisation est plus lourde ` a implanter. Par exemple, en C, il
faudra transmettre la fonction au moyen d’un pointeur, en Java il faudra transmettre la fonction ` a l’int´ erieur
d’un objet dont on aura d´ efinit la classe ou l’interface auparavant.
interface Order {
boolean compa re ( O b j e c t a , O b j e c t b ) ;
}
O b j e c t [ ] t r i ( O b j e c t [ ] a r t i c l e s , O rde r o ) ;
3

1.2 La programmation g´ en´ erique par les types
L’id´ ee derri` ere la programmation g´ en´ erique ou g´ en´ ericit´ eest de ne pas restreindre inutilement le type
des donn´ ees et des fonction, mais au contraire, de le rendre g´ en´ eriques ` a toute valeur compatible avec leur
d´ efinition. En pratique, ceci est fait par le biais de param` etres de types qui jouent le rˆ ole de type g´ en´ erique,
pouvant ˆ etre remplac´ e plus tard par un type sp´ ecifique. Par exemple, en Java 1.5 on peut d´ efinir le type d’une
cellule (dans une liste chaˆ ın´ ee) dont la nature du contenu d´ epend du param` etre de type A :
class Cellule<A>{A c o n te n u ; C e l l u l e s u i v a n t };
En C++, on utilisera les partons (templates) pour g´ en´ eraliser le type d’une fonction. Par exemple, voici la
fonction identit´ equi renvoie son arugment sans lui appliquer aucune op´ eration :
template <typename A>
A i d e n t i t y (A x ) {
r e t u r n x ;
}
Ce m´ ecanisme de g´ en´ eralisation est pr´ esent dans beaucoup de langages : C++, Java, Ada, Haskell, Eiffel,
SML, Ocaml. Il permet de concilier flexibilit´ e du typage avec la rigueur du typage statique ; il favorise
fortement la r´ eutilisation du code, et permet ´ egalement le typage plus pr´ ecis (avec moins d’erreurs) du code
g´ en´ erique. Il s’agit d’un exemple r´ eussi de m´ elange de styles de programmation dans la mesure o` u il a ´ et´ e
adopt´ e par diff´ erents langages de styles tr` es divers.
1.3 Avantages et contraintes de la programmation fonctionnelle
La programmation fonctionnelle pure (sans effets de bord) pr´ esente beaucoup d’avantages :
1. “Modularit´ e” de la programmation, simplification du d´ ebogagge : les fonctions au sens math´ ematique
peuvent ˆ etre consid´ er´ ees comme des boˆ ıtes noires au sein des programmes. Il devient plus facile de les
concevoir s´ epar´ ement, de circonscrire leurs effets, et d’isoler les erreurs. Par ailleurs, la g´ en´ eralisation
des fonctions par le biais de param` etres fonctionnels favorise la structuration des programmes et la
r´ eutilisation d’algorithmes.
2. Formalisme math´ ematique sous-jacent : cela permet la v´ erification du langage (compilateur, typage,
s´ emantique formelle) mais aussi des programmes via diverses analyses, tests ou ` a l’aide de prouveurs
automatiques.
3. G´ en´ ericit´ e, flexibilit´ e, r´ eutilisation : la programmation g´ en´ erique par les types favorise la r´ eutilisation
du code tout en assurant un typage pr´ ecis. Les fonctions et les donn´ ees deviennent plus g´ en´ eriques et
donc potentiellement r´ eutilisables.
Ces avantages ont un prix : les contraintes impos´ ees par l’usage de la programmation fonctionnelle pure,
parmi lesquelles on peut mentionner :
– Pas d’effets de bords : pas d’affectation, pas de variables modifiables. Seules les constantes sont
admises ;
– Une fonction ne peut pas changer ce qui lui est ext´ erieur ;
– Le comportement d’une fonction ne peut pas ˆ etre modifi´ e de l’ext´ erieur ;
– Certaines constructions sont proscrites : boucles it´ eratives, goto.
– La r´ ecursivit´ e est ` a utiliser afin de coder les boucles.
– La gestion implicite de la m´ emoire devient indispensable.
4

2 D´ ebuter avec Ocaml : quelques principes
Ocaml est un langage compil´ e. Au choix, il peut ˆ etre compil´ e vers un langage interm´ ediaire (bytecode)
ou vers du code natif avec des performances comparables ` a celles du code C. Il poss` ede ´ egalement un mode
interactif o` u il analyse et r´ epond ` a chaque phrase entr´ ee par l’utilisateur.
2.1 Le mode interactif
Pour lancer Ocaml en mode interactif on tape la commande ocaml dans la fenˆ etre des commandes
(sous Unix). Vous aurez la r´ eponse :
% ocaml
O b j e c t i v e Caml v e r s i o n 3 . 07
#
Le caract` ere #invite l’utilisateur ` a entrer une phrase ´ ecrite dans la syntaxe Ocaml , phrase qui par
exemple nomme une valeur, explicite une d´ efinition ou d´ ecrit un algorithme. En mode interactif, chaque
phrase Ocaml doit terminer par ;; puis l’utilisateur valide sa frappe par un retour chariot. D` es lors, Ocaml
analyse la phrase :
– calcule son type (inf´ erence des types),
– la traduit en langage ex´ ecutable (compilation)
– et enfin l’ex´ ecute afin de fournir la r´ eponse demand´ ee.
En mode interactif, Ocaml donne syst´ ematiquement une r´ eponse qui contient :
– Le nom de la variable d´ eclar´ ee s’il y en a.
– Le type inf´ er´ epar le typage.
– La valeur calcul´ ee par l’ex´ ecution.
# let x = 4+2;;
val x : int = 6
La r´ eponse d’Ocaml signale que l’identificateur xest d´ eclar´ e(val x), avec le type des entiers (:int)
et la valeur calcul´ ee 6 (=6). Un exemple qui utilise la valeur xd´ ej` a d´ eclar´ ee :
# x *3;;
- : int = 18
2.2 Le mode compil´ e
Consid´ erons un fichier source hello.ml avec le code suivant :
p r i n t s t r i n g ” H e l l o World ! \n ” ; ;
Sous une fenˆ etre de commande Unix nous pouvons compiler, lier et ex´ ecuter ce programme par la com-
mande :
ocamlc -o hello hello.ml
./hello
Hello World!
5