Author: Christian.Queinnec@lip6.fr

## Elements of the evaluation

The Objective CAML distribution supplies two online compilers, one generating bytecodes and the other producing instructions for the most modern processors. The toplevel uses the bytecode compiler. Beyond that, the distribution offers numerous libraries in the form of modules and some tools for calculating dependencies between modules, for profiling, and for debugging. Finally, thanks to its interface with the C language, it is possible to link Objective CAML programs to C programs. Languages which similarly offer an interface with C, such as the JNI (Java Native Interface) of Java, become accessible in this way.
The reference manual gives the language syntax, and describes the development tools and the library signatures. This set (language, tools, libraries, documentation) makes up a development environment.

### Language

#### Specification and implementation

There are two ways to approach a new language. A first way is to read the language specification to have a global vision. A second is to plunge into the language's user manual, following the concepts illustrated by the examples. Objective CAML has neither one, which makes a self-taught approach to it relatively difficult. The absence of a formal specification (such as SML has) or a descriptive one (such as ADA's) is a handicap for understanding how a program works. Another consequence of the lack of a specification is the impossibility of getting a language standard issued by ISO, ANSI, or IEEE. This strongly limits the construction of new implementations tailored for other environments. Fortunately INRIA's implementation is of high quality and best of all, the sources of the distribution can be downloaded.

#### Syntax

The particulars of syntax are a non-negligible difficulty in approaching Objective CAML. They can be explained by the functional origin of the language, but also by historical, that is to say anecdotal, factors.
The syntax of application of a function to its arguments is defined by simple juxtaposition, as in f 1 2. The lack of parentheses bothers the neophyte as much as the C programmer or the confirmed Lisp programmer. Nevertheless, this difficulty only arises when reading the code of a programmer who's stingy with parentheses. Nothing stops the neophyte Objective CAML programmer from using more explicit parenthesization and writing (f 1 2).
Beyond the functional core, Objective CAML adopts a syntax sometimes at odds with customary usage: access to array elements uses the notation t.(i) and not the usual brackets; method invocation is noted by a pound (# character) and not a dot, etc. These idiosyncrasies don't make it easier to get a grip on Objective CAML.
Finally, the syntax of Objective CAML and its ancestor Caml has undergone numerous modifications since their first implementation. Which hasn't pleaded in favor of the enduring nature of the developed applications.
To end on a more positive note, the pattern-matching syntax, inherited from the ML family, which Objective CAML incorporates, structures function definitions by case pleasingly and with simplicity.

#### Static typing

The fundamental character of the Objective CAML language resides in the language's static typing of expressions and declarations. This guarantees that no type error surfaces during program execution. Static type inference was conceived for the functional languages of the ML family, and Objective CAML has been able to maintain the greater part of this type discipline for the imperative and object-oriented extensions. However, in the object-oriented case, the programmer must sometimes give type inference a hand through explicit type constraints. Still, Objective CAML preserves static typing of expressions, and definitions, which provides an unsurpassed measure of execution safety: an Objective CAML program, will not return the ``method not found'' exception, which is not the case for dynamically typed object-oriented languages.
Objective CAML's parametric polymorphism of types allows the implementation of general algorithms. It is channeled into the object-oriented layer where parametric classes produce generic code, and not an expansion of code as generated by the templates of other languages. In itself, parametric polymorphism is an important component of code reusability.
The object-oriented extension adds a notion of inclusion polymorphism which is obtained by specifying subtyping relationships between objects. It reconciles code reusability, which constitutes the strength of the inheritance relationship between classes, with the security of static typing.

### Libraries and tools

The libraries supplied with the distribution cover great needs. The programmer finds there, as a standard, the implementation of the most usual data structures with their basic functions. For example: stacks, queues, hash tables, AVL trees. More advanced tools can be found there as well, such as the treatment of data streams. These libraries are enriched in the course of successive language versions.
The `Unix` library allows lower-level programming as much for I/O as for process management. It is not identical for all platforms, which limits its use to some extent.
The exact arithmetic library and the regular expression library facilitate the development of specific applications.
Unfortunately the portable graphics library offers little functionality to support the construction of graphical user interfaces.
C libraries can easily be interfaced with the Objective CAML language. Here, the free availability of well-structured and duly commented sources definitely unlocks the potential for contact with the outside world and the various and sundry libraries to be found there.
Among the supplied tools, those for lexical and syntactic analysis, indispensable whenever dealing with complex textual data, are especially noteworthy. Based on the classic `lex` and `yacc`, they integrate perfectly with sum types and the functionality of Objective CAML, thus making them simpler to use than their predecessors.
Finally, no matter what soundness its features may bring, use of a language ``in actual practice'' never avoids the debugging phase of a program. The Objective CAML 2.04 distribution does not supply an IDE. Certainly, using the toplevel allows one to proceed rapidly to compilation and unit tests of functions (which is an undeniable advantage), but this usage will vary by platform and by programmer: cut-and-paste under X-Windows, calling the shell under `emacs`, requesting evaluation of a buffer under Windows. The next version (see appendix B) provides for the first time an environment for Unix containing a browser for interfaces and modules and a structured editor linked to the toplevel. Finally the distribution's debugger remains hard to use (in particular, because of the functional aspect and the language's parametric polymorphism) and limited to the Unix system.

### Documentation

The documentation of the distribution consists of the reference manual in printable (PostScript) and online (HTML) format. This manual is not in any case an introduction to the language. On the contrary it is indispensable for finding out what's in the libraries or what parameters the commands take. Some pedagogical material can be found on Inria's Caml page, but it is mostly regarding the Caml-Light language. Thus the language is missing a complete tutorial manual, we hope that this book fills this gap.