* Static directive: def static int inc()...

* Inheritance, virtual calls, compatibility rules. Syntax?
  class point3d(int x, int y, int z) .point(x, y)

* Properties

* Operator 'in' for vectors? 'lin'?

* Static calls at compile time: objects constructed at compile time
  can be modified with method calls, so either restrict static calls
  or make sure def objects are not modified through method calls

* Procedures, pipes. Procedures are declared as, e.g.
  def void convert() <char, char> ...

* Exceptions: there is no 'throw' keyword, just calling an exception ctor
  throws one

* Alternate syntax for string keys in dictionaries: dict->key. This will
  work for dynamic states too (?). Also, the ability to iterate over all
  state members with the 'for' operator - how?

* Nullable types: patented by Microsoft. Instead, maybe just use 'any'
  and operator 'default', e.g. v = v default 0 (if null then assign 0)

* Read-only variables (const) and const subexpressions? A bit problematic:
  const should be part of type, not var definition.

* 'public' and 'forward' blocks

* External function defs: syntax? def int v() #extern

* Small ordinals with the 's' prefix? Custom prefixes can be used for
  measurement units as well. Meas. units are compatible with ints but not
  compatible with each other.

* finally { ... } is a nested block which is executed if the enclosing
  block reaches its end, i.e. the finally label. For states this is the
  destructor. Not the same as try ... finally construct.

* Structs are almost like vectors, except element types are specified    
  individually. Can be used for returning multiple values from functions.    
  So a struct descriptor is a vector of types?

* Operator 'split': a combination of 'case' and 'while' for fifos (?)
  Or maybe switch i = ... with semantics similar to 'for'?

* For loop for fifos?

* Ordinal set operations: inversion (not), union (or), intersection
  (and), subtraction (-)

* Run-time range checking (as well as compile-time)

* Tiny set implementation?

* HTML/XML embedded mode, also arbitrary text embedded mode

* Compiler directives: DEBUG ON|OFF  RANGE_CHECK ON|OFF  ASSERT ON|OFF
  DUMP ON|OFF  MARKUP ON|OFF (syntax?)

* Two versions of the binary: debug and release. Debug helps to debug
  both the program (assertions, dumps and range checking are on) and the
  compiler itself

* Abstract module and module inheritance paradigm. Modules can be loaded
  at run time, but they should be inherited from some known module type.
  Database drivers can be written this way.

* Have the code generator evaluate some operations at generation time if  
  possible.

* Dequeue operator >> -- does it make sense when there's deq()? Don't
  think so.

* Floating point type

* Transform some of the dict opcodes to vector ops so that the future
  transition to static data allocation is easier (?)

* goto (?)

* Multidimensional arrays implemented as a single vector with "flat"
  indexing?

* Assignment operators (+=, etc) aren't very nice with the
  boolean/bitwise and, or, etc. However, these are necessary at least:
  |=, +=, -=, *=, /=, %=

* A lot of TODO's in the source