Author: Christian.Queinnec@lip6.fr

## 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.