Interpreter kernel

  o  Some primitives (such as provide/require/feature? and several
     special forms) should be written in Scheme, not in C.

  o  How to gain more heap space:  POINTER(x) should be relative to the
     start of the heap.  Also, as objects are 4-byte or 8-byte aligned,
     the rightmost bits are always unused.

  o  Provide a list (include file) of external functions exported by the
     interpreter that can be used by an extension.  Not all functions
     that are currently declared in include/extern.h should be used by
     extensions.

     Also, it should not matter to an extension writer whether a
     primitive is written in Scheme or in C -- primitives should not
     be invoked directly via the P_ functions.  Instead, a more general
     mechanism is needed.

  o  Implement a pure heap for constant objects (should be placed into
     read-only text segment by "dump").

  o  Quasiquote for vectors.

  o  MAX_READ_SYMBOL and MAX_READ_STRING are artificial limits and
     should go.

  o  Symbols like '1\2 must print as 1\2.

  o  Documentation strings.  Put them into an extra field in S_Compound.
     New primitives:  procedure-documentation, macro-documentation.

  o  Generic print, equal, etc. functions should be provided for
     extensions.

  o  Treat # as comment character if file starts with #! (hard to
     implement, as this requires the reader to detect beginning of line).

  o  Provide a version of the interpreter without main() for applications
     that insist in providing their own main().


Dynamic loading and "dump"

  o  dump.ecoff.c is wrong; it copies the wrong symbol table.

  o  Dump for NEXT-OS/MACH.

  o  ld-based loading for NEXT-OS/MACH.

  o  Dump for HP-PA machines.

  o  Perhaps dlopen() should be supported to provide a restricted
     dynamic loading facility on systems that do not have real
     incremental loading.  However, this would probably break dump,
     as dump requires the executable to be linked statically.


Extensions

  o  Motif 1.2:  add support for new widgets and new functions.

  o  A UNIX process interface.

  o  A general POSIX extension.


Projects

  o  Symbol completion would be really useful (but hard to implement).

  o  The number system of Elk is not a standard-conforming `number
     system subset' and should be fixed.

  o  A reasonable debugger and a better trace facility are needed.

  o  Exceptions should be implemented correctly.  It should no longer
     be possible to interrupt the interpreter at any point.
     Also, some exceptions (e.g. timer interrupt) must return to the
     point where they were raised (i.e. the handler is not required
     to invoke a continuation).

  o  map and for-each should also work for other data structures
     (vectors, populations, ...).

  o  The error-handler should be invoked with a symbol identifying the
     error as an argument.  The symbol has an error text property
     holding the full text.

  o  Ports: the accessor functions should be part of the port object.

  o  Implement tables.  Need to be rehashed on each GC.  Table object
     holds hash function, compare function, etc.

  o  Implement weak conses (see memmag.c of C-Scheme).  Weak conses are
     needed for populations and object-hash.

  o  Implement object-hash and object-unhash.

  o  Implement populations (weak sets).  Primitives: make-population
     population?  add-to-population  remove-from-population
     population-member?  population->list  population-empty?
     map/walk(?)-population.

  o  It should be possible to define new types in Scheme (not only in
     extensions).  New primitive: define-type (similar to define-structure?).
