TODO
====

Correctness
-----------

* RECV instruction.

* Investigate why seemingly big-enough ARs are actually not big enough.

* Immutable values.  This will help solve the problems of using
  values as keys in a dictionary, and the problem of (not) sharing
  data between processes.

* (BIG) Stack type checker in assembler.

* (BIG) Fix file processes to really be concurrent, esp. in read.
  Use `select` (maybe export fd's to the scheduler.)

* (BIG) Error handling.  Instead of just `assert()` (which isn't even there
  when you define `NDEBUG`), throw an exception if the unexpected
  happens.  Or, send a message to the process which created this
  process.  (This will require `self` be accessible throughout the code
  somehow.)

Testing
-------

* Falderal tests for all variants of conditionals.

* Falderal test for closures.

* Falderal test for sending and receiving messages.

* Falderal tests for dictionaries.

* Falderal test for portraying cyclic values.

* Falderal test for saving cycling values.

Accessibility
-------------

* Document C APIs (header files).

* enum success { SUCCESS = 1; FAILURE = 0; } and return this instead of int.

* Portray values from stream_render: %v or similar.

* Figure out way to debug messages received by file process
  (can't write to file process, or you'll get an infinite loop.)

Portability
-----------

* Measure sizeof struct value et al in buildinfo.  Spit out defines.
  Think about how 64-bit systems will handle all this.

Footprint
---------

* "small immediates" embedded in appropriate VM instructions.

* Go back to having "functional values", but basically say
  that these are ARs with zero space allocated for arguments / locals.
  Then have a VM instruction to create an AR from a functional value.
  (Maybe also have a VM instruction to create a full AR instead of a
  functional value, from a label, for when you want to call it one-off.)

Performance
-----------

* Allow symbols (/strings) to be interned.  There is of course a
  tradeoff here, so "allow" rather than "require".
  Maybe have VALUE_TAG being "small strings" (fit in a struct value,
  so, like, 7 characters).  Then many problems go away...?

* Option to create a (non-interned) symbol from a const string in
  a way that does not copy the const string.

* More efficient access of free variables.  Split each AR into two sections: bound variables
  and free variables.  The bound variables are stored in the AR itself.  Free variables are
  stored in some other AR; pointers to them are stored in this AR.  Then accessing a bound
  variable is only a single indirection.  Tradeoff is that more work needs to be done when
  creating a functional value.

* In ARs, store top-of-stack pointer as a machine pointer,
  not a tuple index.