Introduction
La conception et la programmation modulaire permettent le découpage
d'une application en unités logicielles et, autant qu'il est
possible, le développement séparé de ces unités.
Un module est compilable séparément des autres unités
constituant l'application. En conséquence, le développeur d'une
application utilisant les ressources d'un module n'est pas obligé de
disposer des sources du module, seul le code compilé lui suffit pour
obtenir l'exécutable final de son application. Cependant, il doit
connaître, pour construire le source de sa propre application,
les identificateurs (types, fonctions, exceptions, voire modules)
fournis par le module. Pour ce faire, un module possède une
interface qui décrit les types et les valeurs qu'il fournit.
L'explicitation d'une interface permet de rendre son utilisation
indépendante de son implantation. L'utilisateur d'un module ne
connaît que les noms des fonctions fournies sans avoir accès à
leur implantation. Ainsi, s'il ne change rien à l'ensemble des noms
connus, l'administrateur d'un module peut changer du tout au tout son
implantation sans que ses utilisateurs aient besoin de s'en apercevoir.
Ce qui est un avantage pour la maintenance des
applications. L'interface permet, à l'instar de déclarations
locales, de masquer certains éléments d'implantation que le
concepteur du module ne souhaite pas publier. La principale
application de ce mécanisme est la réalisation de
types de données abstraits.
Enfin, les mécanismes de modules évolués (et celui d'Objective CAML en
fait partie) permettent la définition de
modules paramétrés ou génériques. Ce sont des modules prenant
d'autres modules en paramètre ce qui accroît les possibilités
de réutilisation de code.