Author: Christian.Queinnec@lip6.fr

## Description of the language

##### Objective CAML is a functional language:

it manipulates functions as values in the language. These can in turn be passed as arguments to other functions or returned as the result of a function call.

##### Objective CAML is statically typed:

verification of compatibility between the types of formal and actual parameters is carried out at program compilation time. From then on it is not necessary to perform such verification during the execution of the program, which increases its efficiency. Moreover, verification of typing permits the elimination of most errors introduced by typos or thoughtlessness and contributes to execution safety.

##### Objective CAML has parametric polymorphism:

a function which does not traverse the totality of the structure of one of its arguments accepts that the type of this argument is not fully determined. In this case this parameter is said to be polymorphic. This feature permits development of generic code usable for different data structures, such that the exact representation of this structure need not be known by the code in question. The typing algorithm is in a position to make this distinction.

##### Objective CAML has type inference:

the programmer need not give any type information within the program. The language alone is in charge of deducing from the code the most general type of the expressions and declarations therein. This inference is carried out jointly with verification, during program compilation.

##### Objective CAML is equipped with an exception mechanism:

it is possible to interrupt the normal execution of a program in one place and resume at another place thanks to this facility. This mechanism allows control of exceptional situations, but it can also be adopted as a programming style.

##### Objective CAML has imperative features:

I/O, physical modification of values and iterative control structures are possible without having recourse to functional programming features. Mixture of the two styles is acceptable, and offers great development flexibility as well as the possibility of defining new data structures.

##### Objective CAML executes (threads):

the principal tools for creation, synchronization, management of shared memory, and interthread communication are predefined.

##### Objective CAML communicates on the Internet:

the support functions needed to open communication channels between different machines are predefined and permit the development of client-server applications.

##### Numerous libraries are available for Objective CAML:

classic data structures, I/O, interfacing with system resources, lexical and syntactic analysis, computation with large numbers, persistent values, etc.

##### A programming environment is available for Objective CAML:

including interactive toplevel, execution trace, dependency calculation and profiling.

##### Objective CAML interfaces with the C language:

by calling C functions from an Objective CAML program and vice versa, thus permitting access to numerous C libraries.

##### Three execution modes are available for Objective CAML:

interactive by means of an interactive toplevel, compilation to bytecodes interpreted by a virtual machine, compilation to native machine code. The programmer can thus choose between flexibility of development, portability of object code between different architectures, or performance on a given architecture.

### Structure of a program

Development of important applications requires the programmer or the development team to consider questions of organization and structure. In Objective CAML, two models are available with distinct advantages and features.

##### The parameterized module model:

data and procedures are gathered within a single entity with two facets: the code proper, and its interface. Communication between modules takes place via their interface. The description of a type may be hidden, not appearing in the module interface. These abstract data types facilitate modifications of the internal implementation of a module without affecting other modules which use it. Moreover, modules can be parameterized by other modules, thus increasing their reusability.

##### The object model:

descriptions of procedures and data are gathered into entities called classes; an object is an instance (value) of a class. Interobject communication is implemented through ``message passing'', the receiving object determines upon execution (late binding) the procedure corresponding to the message. In this way, object-oriented programming is ``data-driven''. The program structure comes from the relationships between classes; in particular inheritance lets one class be defined by extending another. This model allows concrete, abstract and parameterized classes. Furthermore, it introduces polymorphism of inclusion by defining the subtyping relationship between classes.
The choice between these two models allows great flexibility in the logical organization of an application and facilitates its maintenance and evolution. There is a duality between these two models. One cannot add data fields to a module type (no extensibility of data), but one can add new procedures (extensibility of procedures) acting on data. In the object model, one can add subclasses of a class (extensibility of data) for dealing with new cases, but one cannot add new procedures visible from the ancestor class (no extensibility of procedures). Nevertheless the combination of the two offers new possibilities for extending data and procedures.

### Safety and efficiency of execution

Objective CAML bestows excellent execution safety on its programs without sacrificing their efficiency. Fundamentally, static typing is a guarantee of the absence of run-time type errors and makes useful static information available to the compiler without burdening performance with dynamic type tests. These benefits also extend to the object-oriented language features. Moreover, the built-in garbage collector adds to the safety of the language system. Objective CAML's is particularly efficient. The exception mechanism guarantees that the program will not find itself in an inconsistent state after a division by zero or an access outside the bounds of an array.