Generics proposals
Generic Types
=
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: TSomeGeneric<T,Q> T and Q, the unknown types for the generic
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 but 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?