Overview of the Caml Light implementation
The Caml Light system comprises the following parts:
- An interactive system, based on a read-eval-print loop: the user
enters a phrase, the system compiles it and executes it on the fly,
then print the outcome of evaluation. The interactive system is great
for learning the language and testing programs.
- A batch compiler and linker,
camlc, with a
command-line interface similar to the one of C compilers. The compiler
produces standalone executable programs that can later be invoked just
as any other command on the system. It integrates smoothly within the
Unix programming environment (make, Emacs, ...).
- A medium-sized standard library, providing a number of
general-purpose functions and implementations of a few essential data
structures (lists, arrays, hash tables, sets, ...).
- A tool to build libraries of frequently-used program modules.
- A parser generator and a lexical analyzer generator, in the style
- Various programming tools:
Check here for more information.
- A source-level debugger with replay capabilities (``time travel'').
- An hypertext browser for modules.
- A simple Emacs editing mode, plus the ability to run the
toplevel or the debugger under Emacs.
- Search by types on modules.
- Several interface libraries:
- An extensive Graphic User Interface based on Tk.
- Portable graphic primitives (simple line and text drawings).
- Interface with the Unix system calls.
- Arbitrary-precision rational arithmetic (extremely efficient).
- High-level string operations (regular expressions, ...).
Caml Light is freely distributed for non-commercial use. Click
here to transfer it.
Caml Light is available on the following platforms:
- Most Unix machines. We have tested the current distribution on
the following machines, but many more have been reported to work:
- DecStation 3000/300 under OSF/1 2.0.
- Sun Sparcstation 10 under SunOS 4.1.
- DecStation 5000/200 under Ultrix 4.1.
- 486 PC under Linux 1.2.6
- Any Macintosh with at least 2M of RAM and System 6 or 7.
- Any PC under Windows 95, Windows NT, and also Windows 3.1
compatibility system is installed.
- Any Atari ST machine with at least 2M of RAM.
Caml Light is implemented as a bytecode compiler (it produces code for
an abstract machine, which is then interpreted by a C program), hence
it is small, portable and has modest memory requirements. The runtime
system (the part written in C) is about 100K, plus another 100K of
bytecode for the compiler. The compiler itself is written in Caml
Light and ``bootstrapped'' -- compiled by itself.
2 megabytes of memory are enough to recompile the whole
system. Other implementations of ML generally use up at least ten
times more memory. The generated standalone programs are very small.
Because of the overhead of interpreting the bytecode, programs
generated by Caml Light run about ten times slower than programs
generated by the best native-code compilers. The slowdown is more
important for programs performing mostly arithmetic operations and
loops, and less important for highly symbolic computations.
Owing to their small memory footprints, Caml Light programs start up
quickly and do not cause virtual memory thrashing. Combined with
generational, incremental garbage collection, this makes interactive
Caml Light programs very responsive, with no annoying pauses in the
middle of user interaction.
The Caml Light compiler is so small and simple that it runs very
quickly (above 200 lines/second on a modern workstations), much faster
than native-code compilers. During the development phase, this often
compensates for the slow execution of the generated program.
The interactive, toplevel-based compiler is similarly very responsive.
Caml Light is written entirely in C and in Caml. The only assumptions
it makes are: a 32-bits or 64-bits architecture, with a flat address
space; a good quality C compiler (ANSI or K & R); and the POSIX
subsystem of Unix.