Generics proposals

= Why

• Typesafety
• Speed
• Readability

= Usage example

(dannym proposal)

 type
 TGenericList<T> = class
 public
   procedure Add(stuff: T);
 end;

<plugwash> tmycollection=template(tobject)[x] <plugwash> tintegercollection=tmycollection[integer] <oliebol> template mycollection (x: tobject) is more logical

=Terms

type user:

• the function in the compiler that defines a variable or return type and thus 'uses a (already defined) type'.

immediate type:

• not generic and not specialized, i.e. 'normal type'

generic type:

• template for a class with some unspecified types, never to be filled in into this class type. Only by specialisation.

specialisation:

• copy generic type tree to new specialized type tree,

type parameters:

• T and Q, the unknown types for the generic TSomeGeneric<T,Q>

specialized type:

• a generic type with all type parameters know, written into a real class type (tree) and reused if possible

= Changes

x. Changes in class definition representation

---

Each class definition representation has added fields for:

 - class instantiation mode
    0  immediate type
    1  generic type, no instantiation, just generate specialized type
    2  specialized type

 - when mode 2:
     generic type uplink (what, unitname, typename?)
   when mode 1:
     list of specialized types known so far (and where)
   when mode 0: 
     nothing

== x. Changes in 'type user' compilation (for class types only)

Each class type user will have to check mode of the class type.

If mode is immediate

 - proceed as always till now.

If mode is specialized

 - proceed as always till now 
 - keep in mind the generic type for some checks later (and debugging).

If mode is generic, this:

 - check 'list of specialized types' for the type parameter to use.
   If there is already a specialized type, use that.
   (given that it is compatible with 'compile parameters' XXXX)

 - If not available, clone the generic type in the tree, and fill in the
   type params with the actual types to use.

   Write that out to XXXX?

= Other things to note (for later)

 - what if a method implementation depends on the type used to know how the implementation should look like ?

 procedure Add(value: T is TObject);
 procedure Add(value: T is Integer);
 ?