Hello Free Pascal community!
I'm pleased to announce the addition of type helpers which extend the existing helper concept with the ability to extend primitive types.
Motivation:
With class and record helpers the possibility was created to extend classes and records with types without subclassing the type (which wouldn't be possible with records anyway). This allows to add e.g. methods to types in units that you can't influence or where you can't influence with type is instantiated (e.g. the TStrings descendant used in TMemo). Now it is logical to extend this also to other types supported by Pascal, but here more driven by the possibility to group methods together and have them appear to belong to the primitive type.
While this does not bring the concepts of boxing of managed languages/environments like Java and .NET to Pascal it does nevertheless look this way.
Syntax:
The declaration of type helpers looks as follows:
TYPENAME = type helper[(BASEHELPER)] for EXTENDEDTYPE DECLARATIONS
end;
Like class and record helpers they support all visibility sections and you can define methods, properties and constructors. Inside methods declared in the helper "Self" will be of the extended type's type and it's value can also be changed.
Similar to record helpers class methods MUST be declared as static.
Usage:
A type helper is active if it is in scope. This means it must either have been declared in the same unit before the code which wants to use the helper or it needs to be declared in a used unit. As with class and type helpers only one helper for a given type can be active and thus you need to keep in mind the scoping rules when using helpers (e.g. the current unit is searched in the order implementation section then interface section (if the code is in the implementation section) and then the used units are searched from right to left and each unit from top to bottom).
In some cases the meaning of a type depends on the compiler settings the helper is compiled with. E.g. the type Integer is either a ShortInt or a LongInt depending on the current mode (fpc/tp vs. objfpc/delphi) and the type String is different depending on the switches {$H+/-} and {$modeswitch unicodestring}. This needs to be kept in mind when working with these "generic" types. Another special case is the type Extended on platforms that don't support that type (and thus it will be defined as Double).
Additionally a type declared as "NewType = type OldType" is considered a completly independant type as it is the case with e.g. operator overloads as well.
If a helper for the type is in scope you can simply invoke it's methods or properties like you'd do on classes or records. Let's suppose we have a helper with method "ToString: String" for the type LongInt in scope then it will look like this:
=== example begin ===
var
i: LongInt;
begin
Writeln(i.ToString);
end.=== example end ===
Additionally to invoking type helpers on variables they can also be used on constants though special care needs to be taken that the correct type is used. E.g. the constant "200" will be handled as a "Byte" whereas "20" will be handled as "SmallInt". Also the type of string constants depends on the current mode switch (especially {$H+/-} and {$modeswitch unicodestring}) and also the content of the string. E.g. in case of "{$mode objfpc}{$H+}" a string containing unicode characters will be handled as a UnicodeString constant and thus only helpers for UnicodeString will apply.
For the following example let's assume the helper from the previous example is in scope again:
=== example begin ===
begin
Writeln($12345678.ToString);
end.=== example end ===
Additionally addresses (e.g. "@i") (type: Pointer) and the built in constants "True" (type: Boolean), "False" (type: Boolean) and "Nil" (type: Pointer) are allowed as well. Please note that in the case of typed addresses also the untyped pointer type will be used, because a corresponding typename might not be available to the current unit (and thus the helper could not be found). Constants that can't be used with type helpers are set and array constructors.
Class methods (and properties) can be either used on variables or constants, but also on the type name itself:
=== example begin ===
type
TLongIntHelper = type helper for LongInt
class procedure Test; static;
end;
class procedure TLongIntHelper.Test;
begin
Writeln('Test');
end;
var
i: LongInt;
begin
i.Test;
$12345678.Test;
LongInt.Test;
end.=== example end ===
Supported types:
There is a restrictions on the type which can be extended. Basically every primitive type is allowed besides the following:
* file types (TextFile, file of ...)
* procedural variables
Of course types like records, classes, Objective C classes, C++ classes, objects and interfaces are forbidden as well.
Viewed from the other perspective this means that the following types are allowed:
* ordinal types
* string types (including char types)
* set and enum types
* array types
* boolean types
* Variant
* floating point types
* pointer types
Delphi compatibility:
This feature was introduced by Delphi XE3, but instead of using the more logical "type helper" syntax they added support for primitive types to the "record helper" one. Thus to keep Delphi compatibility this is also the syntax used in mode Delphi. Also in non Delphi modes inheritance for helper types is supported.
Future developments:
Add support for more types, especially interface and object types. They will either be added as class helpers or as "object helper" and "interface helper" (as objects and interfaces support inheritance the scoping rules inside the helper will resemble class helpers more than record/type helpers).
Allow that multiple helpers are active for one type at a single time. This is one of the main restrictions of the current helper implementation. For this corresponding lookup rules need to be defined and the feature will be added as a modeswitch (maybe by default enabled in mode objfpc).
Add support for helpers to the JVM target. The most likely implementation approach is to pass the "Self" value as an additional parameter and treat the methods otherwise as static ones (like is done in .NET for helper methods).
Regards,
Sven