Still to do:

Get the interpreter to switch off checking for undefined
first params.

Allow floats with integral values to be used in the place of
integers in rlist rset srlist srset and so on.

Allow values to be deleted in-place from sets. Need to propagate
deletions to all derived sets. Ie, if
  x : set of Entity
  y : set of x
then deleting a from x should delete a from y too, if present.

Need lazy intersect just like lazy eval, so that type intersections
can be supported by definition. 
Ie, need support for multiple inheritance by declaration.

For noting:

Any routine starting with a capital letter is `user visible'. Hence:
1. No assumptions can be made about the non-self arguments, other than
   that they are descended from Object.
2. Argument refcounts have been increased by one by the calling
   convention and must be decreased by one before control returns
   to their caller. 
3. Internal calls to these routines must obey the same calling
   convention as the `user level', ie. increase refcounts of
   all arguments by one.

Assign_to_component(self, i, v) normally returns self as
result whenever refcount(self) = 1. In other words, it normally performs
an in place update of self in this case. When it does NOT do so,
it must incorporate self into the returned value.

Copy_of returns a new copy only if its argument has a refcount > 1.
Making a copy of x `consumes' x (decrements its refcount).
Not all classes need define the copy_of method because owners
of their instances can obtain another `copy' simply by incrementing
the refcounts. Use of copy_of is to be confined to the class
defining it. Class Object does note use copy_of. It is only declared
in this class so to that C++ type checking does not get in the way
when one inc_refs an argument before passing it to copy_of.

Iterators introduce a nested scope when allocated. When reclaimed,
they restore the current scope applicable when allocated. They
must thus be reclaimed before leaving the scope containing their
declaration. Iterators are not sharable or restartable. They are
consumed by iterating them, or by converting them into lists or sets.
These operations are mutually exclusive.

When an expression function calls itself recursively, it contains
a circular reference to itself (ie. it is itself the value of one of the
global variables that have been frozen into it.)

Sets and lists of size > max(Integer) all have len(s) = -1.
In the case of lists, this can only happen when specified as
a range such as [0..max(Integer)].

The hashval of a Dset is set equal to the hashval of the underlying Map.
This is only correct as long as the hashval of a single element Slist is equal
to the hashval of the single element. Should either of the above assumptions
become invalid, the alloc function for Dset must be changed accordingly.
