Page 7 - FREE_TRIAL6Months

AN INTRODUCTION TO GENERICS CONTINUATION 2 PAGE 1/5
BY MICHAËL VAN CANNEYT
starter &expert
Delphi and Lazarus If we want to reduce the number of functions that
ABSTRACT Generics have been available in Free
Pascal and in Delphi for quite some time now and are
increasingly used thoughout the VCL. In this article,
we take a closer look at this language construct.
INTRODUCTION:
THE PROBLEM
Object Pascal is a strongly typed Function Min(A,B : T) : T;
language. This is one of the good
reasons for using Object Pascal, since it
ensures that if the code compiles, it will not contain
too many obvious mistakes that can happen in
languages with e.g. dynamic typing, such as passing
a string or an object to a function that expects an
integer. The compiler will catch such an error at
compile time. In dynamically typed languages, such
an error will only be detected when
running the code. It also presents a drawback.
In case you want to have a structure or function that
needs to be implemented for several types, then you TList from the classes unit (or TCollection) is
need to implement it separately for each type,
even if the actual code for the function looks 100%
the same. For instance:
For instance:
Function Min(A,B : Integer) : Integer;
begin
If A<B then
Result:=A
else
Result:=B;
end;
This function can be used with an integer type
(in fact, all integer-like types such as byte, word
etc.). But it cannot be used with a string.
In Javascript, the function
function min (a,b) {
if (a<b) {
return a;
} else {
return b;
} solution to this problem. Generic types can be
} made using records (with or without methods),
can be used with all basic types (all types for
which < is defined); you need to write it only
once.
In Object Pascal, you need to write the function
for each type that you wish to use it with, the
overloading feature of the language takes care of
selecting the right version when it is used.
When implementing the above function
Min(), even though the code inside the
function will look 100% the same, the function
must be written for each type separately.
10 Issue Nr 8 2016 BLAISE PASCAL MAGAZINE
THE SOLUTION: GENERICS
we must implement, then basically - what is
required - is a function in which the type of the
parameters and return value is a parameter
itself, so it can be specified at a later time, and
let the compiler generate the function for us,
with the type we specify.
Something like
begin
If A<B then
Result:=A
else
Result:=B;
end; //Where T is unknown.
This requirement, to be able to specify the type of
some fields or function parameters later on,
extends to structures:
a classical example.
The TList type can be used with pointers.
Using some typecasting, it is possible to make
descendents that accept objects: given a class
TMyClass one can make a TMyClassList
descendent of TList with a default array
property that has type TMyClass.
Some overloads are needed with typecasts,
but it works.
With GENERICS, it is possible to define a list
class, in which the type of the elements is not
yet determined, but which can be filled in later.
The statement where the actual type is
determined, is called instantiating in Delphi,
or specializing in Free Pascal.
Roughly, this is something like:
TList<T> = Class
Property Items [Aindex : Integer] : T Read GetA;
end;
Here, T would be a placeholder for a type.
Generic types (and functions in FPC) are the
classes and arrays and procedural types.
In Free Pascal, it is also possible to create actual
generic functions or procedures.
The compiler implementation of generics in
Free Pascal and Delphi is presumably quite
different, which means that some things
which are possible in Free Pascal, will not
be possible in Delphi.
Since Free Pascal aims to be Delphi compatible, the
opposite should not be the case
(barring bugs in Free Pascal, obviously).