Présentation de la partie III
La troisième partie de cet ouvrage se consacre à la réalisation
d'applications et décrit deux styles d'organisation d'applications
: modules et objets. Le but est de modéliser facilement l'application
pour un développement incrémentiel et rapide, une maintenance facilitée
par une bonne évolutivité et la possibilité de réutiliser de grandes
parties pour de futurs développements.
Nous avons déjà présenté les modules prédéfinis
(8) du langage vus comme unités de
compilation. Le langage de modules d'Objective CAML permet d'une part de
définir de nouveaux modules simples, pour construire ses propres
bibliothèques, y compris avec des types abstraits, et d'autre
part de définir des
modules paramétrés par d'autres modules, appelés foncteurs.
L'intérêt de ce paramétrage est de pouvoir << appliquer >> un module sur
différents modules arguments pour créer des modules spécifiques.
La communication entre modules est alors explicite via
la signature du module paramètre, contenant le type des déclarations globales de celui-ci.
Rien n'empêche cependant d'appliquer un foncteur à un module
de signature plus importante qui reste néanmoins compatible avec celle indiquée au paramètre.
D'autre part le langage Objective CAML possède une extension objet. La
programmation objet permet tout d'abord une modélisation de la
communication entre objets. On n'applique plus une fonction à ses
arguments, mais on envoie un message (une requête) à un objet qui
saura le traiter. L'objet, instance d'une classe (structure de
regroupement données/méthodes), exécutera alors le code
correspondant. La relation principale entre les
classes est l'héritage qui
permet de décrire des sous-classes qui possèdent déjà toutes les
déclarations
de la classe ancêtre. La liaison retardée entre le nom d'un message et
le code correspondant dans l'objet s'effectue à l'exécution du
programme. Néanmoins le typage d'Objective CAML garantit qu'un
objet receveur possédera toujours une méthode de ce nom, sinon
l'inférence de types aura provoqué une erreur à la compilation. La
deuxième relation importante est celle de sous-typage, où un objet
d'une certaine classe pourra toujours être utilisé à la place d'un
objet d'une autre classe. On introduit par là un nouveau type de
polymorphisme : le polymorphisme d'inclusion.
Enfin la construction d'interface graphique, abordée au chapitre
5, utilise différents modèles de gestion d'événements. On
assemble dans une interface plusieurs composants sur lesquels
l'utilisateur ou le système peut produire des
événements. L'association d'un composant et du traitement d'un ou
plusieurs événements se produisant sur celui-ci permet d'ajouter et de
modifier facilement de telles interfaces. L'association
composant-événement-traitement peut revêtir plusieurs formes : une
fonction (dite callback), ou un héritage avec redéfinition des
méthodes de traitement, ou enfin un enregistrement d'un objet traitant
(modèle par délégation).
Le chapitre 14 est une présentation de la programmation
modulaire. Les différentes terminologies provenant des types
abstraits de données et des langages de modules sont exposées et illustrées
par des modules simples. Le langage des modules est ensuite
détaillé . La correspondance entre modules simples ou non et unités de
compilation est explicitée.
Le chapitre 15 contient une introduction à la
programmation objet. Elle apporte une
nouvelle structuration des programmes Objective CAML, alternative aux modules.
Ce chapitre montre comment les notions de programmation objet
(héritage simple et multiple, classes abstraites, classes paramétrées, liaison retardée)
s'articulent autour
du système de types du langage et l'étendent par la relation de sous-typage
au polymorphisme d'inclusion.
Le chapitre 16 compare les deux organisations
précédentes en précisant les éléments de choix tout en montrant
comment simuler l'une par l'autre.
Il traite différents cas d'organisations
mixtes. Le mélange permet d'enrichir chacune des deux organisations en
particulier avec les classes paramétrées utilisant un type abstrait
d'un module.
Le chapitre 17 présente deux
applications : des jeux à deux joueurs et la construction d'un monde
de robots virtuels. Le premier exemple est organisé en plusieurs
modules paramétrés. On y utilise en particulier un module paramétré par la représentation d'un jeu pour l'algorithme minimax ab.
Il est ensuite appliqué à deux jeux : Puissance 4 et
Stone Henge. Le deuxième exemple utilise une modélisation objet
d'un monde et d'un robot abstrait dont on dérive, par héritage,
plusieurs simulations. Cet exemple sera repris au chapitre
21.