Proposal to add simple inhieritance to the language.

Tagged structures allow for dynamic casting between types in a hierarchy.
Children (rather pointers to) can be up-cast to their parents, a safe
conversion that may recive language level support or even be implicit.
Parents can be down cast to their children, which might fail if the underlying
object is not of the child type, or a child of that.

This does not however cause dynamic look-up. During function calls the
underlying type is ignored, and the pointer type is used to type match the
function call.

The name tagged structure comes from tagged union, which carries a value to
say which of the possible values is currently stored in the union. The idea
here is similar, however the possibilities are more open ended.

Alternate names include virtual structure and abstract structure.


Syntax:

"struct" name [ "tagged" [ parent-name ] ] "{" fields "}"

The keywords can change (although they currently reflect the concept name
closely). More formally, in terms of grammar this adds:

struct-or-union-specifier
	...
	struct identifier tagged { struct-declaration-list }
	struct identifier tagged parent-identifier { struct-declaration-list }

"tagged" by itself create a tagged structure that is the root of a new tree.
It has no parent tagged structure. If "tagged" is used with a parent than
that is the parent of this node.

Tagged structures have fields beyond the ones listed. Root tags have a type
field added which give the type of the instance. Child tags prepend all of
their parent's fields to their field list so they can be upcast.

The type field may be public, if it is then it can be accessed through a
simple field access "instance.type". The type field would then be able to be
used to access the type object, which contains the information for the type.
It may just be a pointer to the type object "*instance.type", although a
lookup function could also be used.


Usage:

The central feature for tagged structs is a checked cast between pointer types
to the structures. A cast is successful if the true type of the pointed object
is of the type being cast to or any of its children, otherwise the cast
returns null.

The type field should also allow for equality comparison of types.

Currently, with only these operations (and similar features) the type field
could be hidden and the operations given through helper functions. However
if the type object has more complex (or even open ended) information in it
than providing direct access becomes very valuable.


Implemenation:

Adding to the field list would have to be handled during translation. The
simple act of adding declarations should not be difficult, althought it might
take a bit of work to find the parent's declarations.

Type objects are also simple in to generate, they should just be global
(program lifetime) structures. Getting there to be exactly one instance of
each allows the pointer to the structure to be used as the type id, and that
should be possible to do during linking.


Traits:

[is_]tagged[_struct](dtype T)
True if the given T is a tagged struct of some kind. This promises that it has
a type object, but nothing else.

[is_]tagged_under(dtype parent, dtype child)
True if child is a child type of parent. Requires that both are tagged structs
and that child can upcast to parent.


Functions:

forall(dtype T | is_tagged(T), dtype U | is_tagged(U))
T * dynamic_cast(U * value)
The cast function, that safely converts the U* into a T*, returning null if
the underlying object value points to is not a child type of T. A shorter name
might be perfered. The runtime should be no more than linear with the depth
of U in the inhiertance tree.

bug#11 might require `bool dynamic_cast(T ** dst, U * src)` instead.


Tagging Unions (Extention):

Using this system as is does not really work if used on unions directly.
No new options to the union can be added, as they must be able to upcast.
Similarly, if options are removed, writing to an upcast union is invalid.
To allow for growth each option would have to be a structure itself.

Which brings us to "tagget struct union", ie. a union of tagged structures
as opposed to tagging the union itself. This extention acts as a constraint.
If unions are declared tagged instead of creating a new tagged type, all
possible values of the union must be of that tagged type or a child type.


Custom Type Objects (Extention):

Some method to define type objects used within a tree of types. One option is
to allow the tree's type object to be specified by the tree root. It would
then have to be filled in for each type in the tree, including the root.

The only required field is the parent field, a pointer to the type object's
type. (This is also the only required field on the tagged structure itself.)

A further extention could allow expanding type objects, so child types could
append fields to their parent's feild list. They might need their own type
objects at that point, or maybe static checks will be enough to see the
minimum field list.