.PAS File Format – Generics and anonymous methods

Generic types

A generic type is a class, record, interface, array, procedural type or method (and, in Free Pascal, stand-alone routine) with one or more type parameters in angle brackets. Delphi 2009 and Free Pascal 2.2 and later have them.

type
  TStack<T> = class
  private
    FItems: array of T;
  public
    procedure Push(const Item: T);
    function Pop: T;
  end;

procedure TStack<T>.Push(const Item: T);
begin
  SetLength(FItems, Length(FItems) + 1);
  FItems[High(FItems)] := Item;
end;

var
  Numbers: TStack<Integer>;
begin
  Numbers := TStack<Integer>.Create;
  Numbers.Push(42);
end;

The two syntaxes

{$mode objfpc}
type
  generic TBox<T> = class
    Value: T;
  end;
  TIntBox = specialize TBox<Integer>;   { a name for one specialisation }
  generic function Max<T>(A, B: T): T;

A generic routine is a procedure or function with type parameters (function Max<T>(A, B: T): T;). In Delphi it must be a method of a class or record; Free Pascal also allows stand-alone generic routines. Two angle brackets closing together (TList<TList<Integer>>) are read as two brackets, not as a shift.

Constraints

type
  TFactory<T: class, constructor> = class
    function Make: T;                      { T.Create is allowed }
  end;
  TCompare<T: IComparable> = class end;   { T must implement an interface }
  TNumberBox<T: record> = class end;      { T must be a value type }
  TDescendant<T: TControl> = class end;   { T must be TControl or a descendant }

A constraint after a colon limits the types that may be used. The forms are a class type or interface type (the argument must be it or implement it), class (any class), record (a value type), constructor (a class with a parameterless constructor), and a list of these, separated by commas. Without a constraint the code may use only what every type has.

What the compiler does

• A generic is a template, and the compiler produces code for each distinct set of type arguments (a specialisation), as C++ templates do. There is no code for the generic itself.
• Default(T) is the zero value of T. SizeOf(T), TypeInfo(T) and GetTypeKind(T) work inside a generic, and TypeInfo and RTTI give the name of the specialisation.
• Inside a generic, operators cannot be applied to T unless its constraint provides them, so arithmetic on a type parameter is done through helpers such as TComparer<T> or IComparer<T>.
• A generic may inherit from another generic: TBase<T> = class … end; TDerived<T> = class(TBase<T>), and from a specialisation.
• Methods of a generic class are defined outside with the type and its parameters written out: procedure TStack<T>.Push(…). The names of the parameters must match.

Generic collections

The generic library units are Generics.Collections and Generics.Defaults in Delphi. Free Pascal ships units of the same names in its rtl-generics package, and the older gvector, gmap and gutil units in fcl-stl. The main types:

Anonymous methods and closures

type
  TIntFunc = reference to function(X: Integer): Integer;

function Adder(N: Integer): TIntFunc;
begin
  Result := function(X: Integer): Integer
            begin
              Result := X + N;      { N is captured }
            end;
end;

TThread.Queue(nil, procedure begin Label1.Caption := 'done'; end);
List.Sort(TComparer<Integer>.Construct(
  function(const A, B: Integer): Integer begin Result := A - B; end));

An anonymous method is a routine without a name written as an expression, which may use the variables of the routine around it (it captures them, and they live as long as the method). It is assigned to a variable of a reference to procedure or function type, which also accepts ordinary routines and methods. Delphi 2009 introduced them. Free Pascal’s development version has anonymous functions and function references behind the anonymousfunctions and functionreferences mode switches (the Delphi mode turns both on).

Type inference and other late additions

• Delphi 10.3 and later infer the type of an inline variable from its initial value: var X := TList<Integer>.Create;.
• Free Pascal’s development version has the mode switches typeinquiry and arrayoperators. Delphi XE7 and later add +, Insert and Concat for dynamic arrays.