first beta release of Caml Light 0.7

first beta release of Caml Light 0.7

[Xavier Leroy]

It is my pleasure to announce the first beta release of Caml Light
version 0.7.  The release is available by anonymous FTP:

        host:      ftp.inria.fr
        directory: lang/caml-light/Release7beta

This is still beta software: it is reasonably stable and works fine
for us, but still may change before the final release (which is
scheduled for end of February). Only the Unix version is distributed;
the Macintosh and PC versions have not been updated yet.

A detailed list of changes since release 0.61 is included at the end
of this message. In short: there are many new features,
many new contributed tools and libraries, and a few incompatibilities
with the previous release.

As with all beta releases, this release will be useful only if there
are enough brave users that compile it and give it a try. You will
help us a lot if you do some of the following:

* Run a significant body of Caml code through it and report if you had
serious difficulties with the incompatibilities.

* Exercise the new features and tools.

* Compile the system on "exotic" platforms. We develop under SunOS
  4.1.3 and DEC OSF1 2.0, with frequent tests under Ultrix 4.1 and
  Linux; anything else is "exotic" for us and worth a try.

* Read carefully the changed parts of the documentation.

* Provide translations of error messages to more languages.

* Make precise bug reports to caml-light@pauillac.inria.fr.

Your help in making a better Caml Light will be appreciated.

- Xavier Leroy

----------------------------------------------------------------------

Detailed list of changes:

* Source-level debugger with replay capabilities. Compiler support for
  the debugger added.

* New contributed libraries and tools:
        - a complete X-windows toolkit based on TCL/TK.
        - a profiler for Caml Light programs (execution counts)
        - lorder: determine ordering of .zo files at link-time

* Polymorphism is now restricted to values (let x = e generalizes the type of
  x only if e is syntactically a value, e.g. a constant, a variable, a
  function, a tuple of values, etc). This ensures correct, type-safe handling
  of polymorphic mutable structures.

* "Guards" in pattern-matching (match ... with pat when cond -> expr).

* Partial matches and unused match cases are correctly detected now.

* Internationalized error messages (controlled by the LANG environment
  variable; known languages so far: american english, french).
  More detailed error messages.

* Various fixes in the garbage collector to fight fragmentation of the
  major heap, result in major speedups for some long-running programs.

* Generic comparisons (prefix < : 'a -> 'a -> bool). Compiler optimizations
  for comparisons on base types.

* Type-checker rewritten in bottom-up style instead of top-down style.
  Hopefully this makes type errors more understandable.

* let rec (f : ty) = ... now supported.

* New class of infix and prefix symbols supported (e.g. *=, !!, ++, with
  precedence/associativity determined by their first character).

* Syntactic sugar:
  - Alternate syntax for string access and update (s.[i], s.[i] <- c).
  - := can be used instead of <- in array,  record and string assignment,
    e.g. record.lbl := val or array.(index) := val).
  - Final semicolons permitted in sequences, lists, arrays and records
    (e.g. begin ...; ...; end or [1;2;]).
  - Initial | permitted in pattern matchings and type definitions
    (e.g. function | pat -> expr | ...
     or type t = | Cstr1 | ...)
  - "\/" and "/\" synonymous for "&" and "or".

* Optimized access to unqualified identifiers in symbol tables.

* Parser cleaned up a bit, reduce/reduce conflicts eliminated.

* New library modules: format (to write pretty-printers), gc (to control the
  garbage collector and obtain various statistics on memory allocation).

* The toplevel pretty-prints values and types.

* New toplevel functions: install_printer (user-defined printing functions,
  now type safe and associated with a type expression -- e.g. int list --
  not with a type constructor -- e.g. list); set_print_depth (control
  the printing depth for values).

* Better support for non-generalizable type variables in phrases:
  they no longer cause an error immediately, the check is delayed till
  the end of the compilation unit.

* Static type-checking of printf. User-defined printers supported in printf
  formats (%a and %t).

* Parsing engine now reentrant; a camlyacc-generated parser can call
  another one in one of its actions.

* Better support for 64-bit architectures: 32-bit architectures can read
  values written on a file by a 64-bit architecture; max length of strings
  and arrays now determined by the runtime system.

* New primitive ouput_compact_value to write arbitrary values to disk in
  a more compact (but more CPU-demanding) format than output_value.

* More robust parsing of argv (some Unix kernels set argv[0] = argv[1] = file
  when a #! file is run).

* CAMLRUNPARAM environment variable to set GC parameters.

* contrib/libgraph: implemented alternate event handling methods if async I/O
  are not available; ask for system calls to be restarted if possible;
  restart read and write system calls if interrupted.

* contrib/libnums: upgraded the bignum library; better 64-bit support
  (but still has some 64-bit bugs); alternate names for num operations
  (+/ -/ */ etc).

Main incompatibilities with Caml Light 0.61:

* Polymorphic generalization has been severely restricted to eliminate
  unsoundness w.r.t. polymorphic mutables. As a consequence, several
  "let" declarations that used to be polymorphic are now monomorphic,
  which may cause type errors later. See the manual p. 54 for a complete
  description of the problem and several workarounds.

* `:=' as assignment operator for record fields cause difficulties if
  one of the record fields is a reference: r.lbl := v used to mean
  `update the reference r.lbl with the value v', and now means
  `assign the mutable field lbl of r the value v'. Consider turning
  { lbl: T ref ... } into { mutable lbl: T }. Or add extra parentheses
  (r.lbl) := v to force the interpretation of `:=' as reference assignment.
  
* Due to the new infix operators, extra blank space sometimes needs
  to be inserted, e.g. `x+!y' should now be written `x+ !y'.