Presentation of Part III
The third part of this work is dedicated to application development and
describes two ways of organizing applications: modules and objects. The
goal is to easily structure an application for incremental and rapid
development, maintenance facilitated by the ability to change gracefully,
and the possibility of reusing large parts for future development.
We have already presented the language's predefined modules
(8) viewed as compilation units.
Objective CAML's module language supports on the one hand the
definition of new simple modules in order to build one's own libraries, perhaps
including abstract types, and on the other hand the definition of modules
parameterized by other modules, called
functors. The advantage of this parameterization lies in being able
to ``apply'' a module to different argument modules in order to create
specialized modules. Communication between modules is thus explicit, via
the parameter module signature, which contains the types of its
global declarations. However, nothing stops you from applying a functor to
a module with a more extended signature, as long as it remains
compatible with the specified parameter signature.
Besides, the Objective CAML language has an object-oriented extension.
First of all object-oriented programming permits structured communication
between objects. Rather than applying a function to some arguments, one
sends a message (a request) to an object which knows how to deal with
it. The object, an instance of a class (a structure gathering together
data and methods), then executes the corresponding code. The main relation
between classes is inheritance, which lets one describe subclasses which
retain all the declarations of the ancestor class. Late binding between
the name of a message and the corresponding code within the object takes
place during program execution. Nevertheless Objective CAML typing guarantees
that the receiving object will always have a method of this name, otherwise
type inference would have raised a compile-time error. The second
important relation is subtyping, where an object of a certain class can
always be used in place of an object of another class. In this way a new
type of polymorphism is introduced: inclusion polymorphism.
Finally the construction of a graphical interface, begun in chapter
5, uses different event management models. One puts together
in an interface several components with respect to which the user or the
system can produce events. The association of a component with a
handler for one or more events taking place on it allows one to easily add
to and modify such interfaces. The component-event-handler association can
be cloaked in several forms: definition of a function (called a callback),
inheritance with redefinition of handler methods, or finally
registration of a handling object (delegation model).
Chapter 14 is a presentation of modular programming. The
different prevailing terminologies of abstract data types and module
languages are explained and illustrated by simple modules. Then the module
language is detailed. The correspondence between modules (simple or not)
and compilation units is made clear.
Chapter 15 contains an introduction to object-oriented
programming. It brings a new way of structuring Objective CAML programs, an
alternative to modules. This chapters shows how the notions of
object-oriented programming (simple and multiple inheritance, abstract
classes, parameterized classes, late binding) are articulated with respect
to the language's type system, and extend it by the subtyping relation to
inclusion polymorphism.
Chapter 16 compares the two preceding software
models and explains what factors to consider in deciding between the two,
while also demonstrating how to simulate one by the other. It treats
various cases of mixed models. Mixing leads to the enrichment of each of
these two models, in particular with parameterized classes using the
abstract type of a module.
Chapter 17 presents two classes of
applications: two-player games, and the construction of a world of
virtual robots. The first example is organized via various
parameterized modules. In particular, a parameterized module is used to
represent games for application of the minimax ab
algorithm. It is then applied to two specific games: Connect 4 and
Stone Henge. The second example uses an object model of a world and
of abstract robots, from which, by inheritence, various simulations
are derived. This example is presented in chapter
21.