Work in progress
----------------

The compiler contains some code for the following features,
which are not yet completed, but which we hope to complete
at some time in the future:

* There is a `--target il' option, which generates MSIL code
  for Microsoft's new .NET common language runtime.
  See <http://www.cs.mu.oz.au/mercury/dotnet.html> and/or
  <http://www.cs.mu.oz.au/mercury/information/dotnet/mercury_and_dotnet.html>.

* There is a `--target asm' option, which generates assembler by
  interfacing directly with the GCC back-end, rather than going via C.

* Thread-safe engine.

* Independent AND-parallelism.

* We have added support for dynamic link libraries (DLLs) on Windows.
  This is not yet enabled by default because it has not yet been tested
  properly.

* There is a new `--optimize-constructor-last-call' option
  which identifies opportunities for LCO where a call
  is followed only by some constructor invocations.
  However, these opportunities are not exploited yet.

* There is a new garbage collector that does accurate garbage
  collection (.agc grade).  It is currently limited to deterministic
  code, and needs a great deal of tuning and optimization.  It also
  needs testing.

* Mercury is now the official programming language for Melbourne Uni's
  "Aditi" deductive database system.  The Mercury compiler includes
  support for interfacing to Aditi.  However Aditi itself is not yet
  complete and has not yet been made publicly available.
  (The Aditi support is documented in doc/reference_manual.texi,
  but for now that documentation is commented out -- it's not
  included in the formatted versions of the reference manual,
  only in the TexInfo source code.)

* Converting procedures to tail-recursive form via automatic
  accumulator introduction (--introduce-accumulators).

* The Mercury debugger (mdb) now includes some support for declarative
  debugging.

* There is a `--generate-bytecode' option, for a new back-end
  that generates bytecode.  The bytecode generator is basically
  complete, but we don't have a bytecode interpreter.

We also have some code that goes at least some part of the way towards
implementing the features below.   However, for these features, the
code has not yet been committed and thus is not part of the standard
distribution.

* A bytecode interpreter, for use with the `--generate-bytecode' option.

* A `--target java' option, which generates Java.

* Support for aliasing in the mode system.

* Support for automatic structure reuse (reusing old data
  structures that are no longer live, rather than allocating
  new memory on the heap) and compile time garbage collection

* Sequence quantification (see the description in
  http://www.cs.mu.oz.au/research/mercury/information/reports/minutes_15_12_00.html).

* A SOAP interface.

* A QuickCheck-style module for software testing.

* Improvements to the debugger's pretty-printer.

Work not in progress
--------------------

The compiler also contains some code for the following features,
but work on them has stopped, since finishing them off would be
quite a bit more work, and our current priorities lie elsewhere.
Still, these would make interesting and worthwhile projects
if someone has the time for it.

* There is a `--generate-prolog' option for a new back-end
  that generates Prolog code.
  Not very much progress has really been made on this.
