Type compatibility

8.7 Type compatibility

Whenever a generic class is specialized with a different set of template types, this results in a new, distinct type.

The types are assignment compatible if the same template types are used.

If the same types are used, and compiler can reuse a previously generated generic, it will reuse this previously generated generic, but this is not guaranteed to be possible: you may still have 2 separate generic types, but they will be assignment compatible.

Take the following generic definition:

{$mode objfpc}
unit ua;

interface

type
  Generic TMyClass<T> = Class(TObject)
    Procedure DoSomething(A : T; B : INteger);
  end;

Implementation

Procedure TMyClass.DoSomething(A : T; B : Integer);

begin
  // Some code.
end;

end.

And the following specializations:

{$mode objfpc}
unit ub;

interface

uses ua;

Type
TB = Specialize TMyClass<string>;

implementation

end.

the following specializations is identical, but appears in a different unit:

{$mode objfpc}
unit uc;

interface

uses ua;

Type
TB = Specialize TMyClass<string>;

implementation

end.

The following will then compile:

{$mode objfpc}
unit ud;

interface

uses ua,ub,uc;

Var
  B : ub.TB;
  C : uc.TB;

implementation

begin
  B:=C;
end.

The types ub.TB and uc.TB are assignment compatible. It does not matter that the types are defined in different units. They could be defined in the same unit as well:

{$mode objfpc}
unit ue;

interface

uses ua;

Type
  TB = Specialize TMyClass<string>;
  TC = Specialize TMyClass<string>;

Var
  B : TB;
  C : TC;

implementation

begin
  B:=C;
end.

Each specialization of a generic class with the same types as parameters is a new, distinct type, but these types are assignment compatible if the template types used to specialize them are equal.

If the specialization is with a different template type, the types are still distinct, but no longer assignment compatible. i. e. the following will not compile:

{$mode objfpc}
unit uf;

interface

uses ua;

Type
  TB = Specialize TMyClass<string>;
  TC = Specialize TMyClass<integer>;

Var
  B : TB;
  C : TC;

implementation

begin
  B:=C;
end.

When compiling, an error will result:

Error: Incompatible types: got "TMyClass<System.LongInt>"
expected "TMyClass<System.ShortString>"

[next] [prev] [prev-tail] [front] [up]