Delphi Language Guide Delphi for Microsoft Win32 Delphi for the Microsoft. Net framework

Procedural Types
Procedural types allow you to treat procedures and functions as values that can be assigned to variables or passed
to other procedures and functions.
About Procedural Types
Procedural types allow you to treat procedures and functions as values that can be assigned to variables or passed
to other procedures and functions. For example, suppose you define a function called 
Calc
 that takes two integer
parameters and returns an integer:
function Calc(X,Y: Integer): Integer;
You can assign the 
Calc
 function to the variable 
F
:
var F: function(X,Y: Integer): Integer;
F := Calc;
If you take any procedure or function heading and remove the identifier after the word procedure or function, what's
left is the name of a procedural type. You can use such type names directly in variable declarations (as in the previous
example) or to declare new types:
type
  TIntegerFunction = function: Integer;
  TProcedure = procedure;
  TStrProc = procedure(const S: string);
  TMathFunc = function(X: Double): Double;
var
  F: TIntegerFunction;   { F is a parameterless function that returns an integer }
  Proc: TProcedure;      { Proc is a parameterless procedure }
  SP: TStrProc;          { SP is a procedure that takes a string parameter }
  M: TMathFunc;          { M is a function that takes a Double (real) parameter and returns 
a Double }
 
  procedure FuncProc(P: TIntegerFunction);  { FuncProc is a procedure whose only parameter 
is a parameterless integer-valued function }
On Win32, the variables shown in the previous example are all procedure pointers - that is, pointers to the address
of a procedure or function. On the .NET platform, procedural types are implemented as delegates. If you want to
reference a method of an instance object (see Classes and objects), you need to add the words 
of object
 to the
procedural type name. For example
type
  TMethod      = procedure of object;
  TNotifyEvent = procedure(Sender: TObject) of object;
These types represent method pointers. A method pointer is really a pair of pointers; the first stores the address of
a method, and the second stores a reference to the object the method belongs to. Given the declarations
type
  TNotifyEvent = procedure(Sender: TObject) of object;
90

---

  TMainForm = class(TForm)
    procedure ButtonClick(Sender: TObject);
     ...
  end;
var
  MainForm: TMainForm;
  OnClick: TNotifyEvent
we could make the following assignment.
OnClick := MainForm.ButtonClick;
Two procedural types are compatible if they have
the same calling convention,
the same return value (or no return value), and
the same number of parameters, with identically typed parameters in corresponding positions. (Parameter
names do not matter.)
Procedure pointer types are always incompatible with method pointer types. The value nil can be assigned to any
procedural type.
Nested procedures and functions (routines declared within other routines) cannot be used as procedural values, nor
can predefined procedures and functions. If you want to use a predefined routine like 
Length
 as a procedural value,
write a wrapper for it:
function FLength(S: string): Integer;
          begin
            Result := Length(S);
          end;