A brief history of OCaml The current definition and implementation
of the OCaml language is the result of continuous and still ongoing
research over the last two decades. The OCaml language belongs to the
ML family. The language ML was invented in 1975 by Robin Milner
to serve as a “meta-language”, i.e. a control language or a scripting
language, for programming proof-search strategies in the LCF proof assistant.
The language quickly appeared to be a full-fledged programming
language. The first implementations of ML were realized around 1981
in Lisp. Soon, several dialects of ML appeared: Standard ML at Edinburgh,
Caml at INRIA, Standard ML of New-Jersey, Lazy ML developed
CONTENTS 5
at Chalmers, or Haskell at Glasgow. The two last dialects slightly differ
from the previous ones by relying on a lazy evaluation strategy (they are
called lazy languages) while all others have a strict evaluation strategy
(and are called strict languages). Traditional languages, such as C, Pascal,
Ada are also strict languages. Standard ML and Caml are relatively
close to one another. The main differences are their implementations and
their superficial —sometimes annoying— syntactic differences. Another
minor difference is their module systems. However, SML does not have
an object layer.
Continuing the history of Caml, Xavier Leroy and Damien Doligez
designed a new implementation in 1990 called Caml-Light, freeing the
previous implementation from too many experimental high-level features,
and more importantly, from the old Le Lisp back-end.
The addition of a native-code compiler and a powerful module system
in 1995 and of the object and class layer in 1996 made OCaml a very
mature and attractive programming language. The language is still under
development: for instance, in 2000, labeled and optional arguments on
the one hand and anonymous variants on the other hand were added to
the language by Jacques Garrigue.
In the last decade, other dialects of ML have also evolved independently.
Hereafter, we use the name ML to refer to features of the core
language that are common to most dialects and we speak of OCaml,
mostly in the examples, to refer to this particular implementation. Most
of the examples, except those with object and classes, could easily be
translated to Standard ML. However, only few of them could be straightforwardly
translated to Haskell, mainly because of both languages have
different evaluation strategy, but also due to many other differences in
their designs.