Type Compatibility and Identity

To understand which operations can be performed on which expressions, we need to distinguish several kinds of compatibility among types and values. These include:

Type identity
Type compatibility
Assignment compatibility

Type Identity

When one type identifier is declared using another type identifier, without qualification, they denote the same type. Thus, given the declarations

Copy Code

type
  T1 = Integer;
  T2 = T1;
  T3 = Integer;
  T4 = T2;

T1, T2, T3, T4, and Integer all denote the same type. To create distinct types, repeat the word type in the declaration. For example,

Copy Code

type TMyInteger = type Integer;

creates a new type called TMyInteger which is not identical to Integer.

Language constructions that function as type names denote a different type each time they occur. Thus the declarations

Copy Code

type
  TS1 = set of Char;
  TS2 = set of Char;

create two distinct types, TS1 and TS2. Similarly, the variable declarations

Copy Code

var
  S1: string[10];
  S2: string[10];

create two variables of distinct types. To create variables of the same type, use

Copy Code

var S1, S2: string[10];

Copy Code

type MyString = string[10];
var
    S1: MyString;
    S2: MyString;

Type Compatibility

Every type is compatible with itself. Two distinct types are compatible if they satisfy at least one of the following conditions.

They are both real types.
They are both integer types.
One type is a subrange of the other.
Both types are subranges of the same type.
Both are set types with compatible base types.
Both are packed-string types with the same number of characters.
One is a string type and the other is a string, packed-string, or Char type.
One type is Variant and the other is an integer, real, string, character, or Boolean type.
Both are class, class-reference, or interface types, and one type is derived from the other.
One type is PAnsiChar or PWideChar and the other is a zero-based character array of the form array[0..n] of PAnsiChar or PWideChar.
One type is Pointer (an untyped pointer) and the other is any pointer type.
Both types are (typed) pointers to the same type and the {$T+} compiler directive is in effect.
Both are procedural types with the same result type, the same number of parameters, and type-identity between parameters in corresponding positions.

Assignment Compatibility

Assignment-compatibility is not a symmetric relation. An expression of type T2 can be assigned to a variable of type T1 if the value of the expression falls in the range of T1 and at least one of the following conditions is satisfied.

T1 and T2 are of the same type, and it is not a file type or structured type that contains a file type at any level.
T1 and T2 are compatible ordinal types.
T1 and T2 are both real types.
T1 is a real type and T2 is an integer type.
T1 is PAnsiChar, PWideChar, PChar or any string type and the expression is a string constant.
T1 and T2 are both string types.
T1 is a string type and T2 is a Char or packed-string type.
T1 is a long string and T2 is PAnsiChar, PWideChar or PChar.
T1 and T2 are compatible packed-string types.
T1 and T2 are compatible set types.
T1 and T2 are compatible pointer types.
T1 and T2 are both class, class-reference, or interface types and T2 is a derived from T1.
T1 is an interface type and T2 is a class type that implements T1.
T1 is PAnsiChar or PWideChar and T2 is a zero-based character array of the form array[0..n] of Char (when T1 is PAnsiChar) or of WideChar (when T1 is PWideChar).
T1 and T2 are compatible procedural types. (A function or procedure identifier is treated, in certain assignment statements, as an expression of a procedural type.)
T1 is Variant and T2 is an integer, real, string, character, Boolean, interface type or OleVariant type.
T1 is an OleVariant and T2 is an integer, real, string, character, Boolean, interface, or Variant type.
T1 is an integer, real, string, character, or Boolean type and T2 is Variant or OleVariant.
T1 is the IUnknown or IDispatch interface type and T2 is Variant or OleVariant. (The variant's type code must be varEmpty, varUnknown, or varDispatch if T1 is IUnknown, and varEmpty or varDispatch if T1 is IDispatch.)