What does "Reference to" do exactly in Delphi?

Question

While reading the documentation at Anonymous Methods in Delphi I started to wonder. I've always used something like this:

type TMathFn = Function(A, B: Integer): Integer;
var fn: TMathFn;

Always worked for me. But this document tells me to use this instead:

type TMathFn = Reference to Function(A, B: Integer): Integer;
var fn: TMathFn;

And as I've been developing in Delphi from 1994 until 2010 I'm a bit unfamiliar with this "Reference to" part. Still, both options seem to work identically. So...
Are they identical?

HeartWare · Accepted Answer · 2020-11-02T13:42:53.577

"REFERENCE TO" is to allow Anonymous Methods (inline definitions of PROCEDUREs/FUNCTIONs), which can Capture a context (for example local variables, which are captured as references, ie. if you change the variable after capture, it's the modified value that is captured, see below).

TYPE TMyProc = REFERENCE TO PROCEDURE(CONST S : STRING);

PROCEDURE Information(CONST S : STRING);
  BEGIN
    MessageDlg(S,mtInformation,[mbOK],0)
  END;

PROCEDURE RunProc(P : TMyProc ; CONST S : STRING);
  BEGIN
    P(S)
  END;

PROCEDURE A(B,C : INTEGER);
  VAR
    D : INTEGER;
    P : TMyProc;

  BEGIN
    D:=3;
    // D is 3 at the time of capture
    P:=PROCEDURE(CONST S : STRING)
         BEGIN
           Information(S+': '+IntToStr(D)+' -> '+IntToStr(B))
         END;
    // D is now 4 - and is reflected in the captured routine, as
    // the capture is done by REFERENCE and not by VALUE.
    INC(D);
    RunProc(P,'Hello')
  END;

BEGIN
  A(2,3)
END.

Will show "Hello: 4 -> 2" in a message box.

The above definition of P "captures" (includes) the variables D and B so that even if you pass it to another function, where these variables don't exist, you can still access them.

This would be (nearly) impossible to do with ordinary PROCEDURE [OF OBJECT] types, as they can't access local variables declared at the point of execution.

Clear enough for me. As I just need function pointers, I can skip the "reference to". As I suspected. :) — Wim ten Brink, Nov 02 '20 at 12:19
A minor gripe. The capture isn't of state, it is of variables. State tends to imply that values are captured, but it is the variables that are captured. — David Heffernan, Nov 02 '20 at 12:30
@DavidHeffernan: Good point - I have updated the answer accordingly... — HeartWare, Nov 02 '20 at 13:46
That excessive (and mixed) use of ALL CAPS is making me pull my hair out... — Jerry Dodge, Nov 02 '20 at 18:33
@JerryDodge: Then look away - we can't have you going bald :-) — HeartWare, Nov 03 '20 at 07:17

Andreas Rejbrand · Answer 2 · 2020-11-02T11:28:19.937

No, they are not identical.

The difference is that

TMathFn = function(A, B: Integer): Integer;

is an ordinary function,

TMathMethod = function(A, B: Integer): Integer of object;

is a method, and

TMathAnonMethod = reference to function(A, B: Integer): Integer;

is an anonymous method, but you can also assign an ordinary function or a method to a variable of this type.

So, for instance, if

type
  TMathFn = function(A, B: Integer): Integer;
  TMathMethod = function(A, B: Integer): Integer of object;
  TMathAnonMethod = reference to function(A, B: Integer): Integer;

function Test(A, B: Integer): Integer;
begin
  Result := A + B;
end;

type
  TTestClass = class
    function Test(A, B: Integer): Integer;
  end;

{ TTestClass }

function TTestClass.Test(A, B: Integer): Integer;
begin
  Result := A + B;
end;

then the following applies:

procedure TForm1.FormCreate(Sender: TObject);
var
  T: TTestClass;
  F: TMathFn;
  M: TMathMethod;
  AM: TMathAnonMethod;
begin

  T := TTestClass.Create;
  try

    F := Test; // compiles
    F := T.Test; // doesn't compile
    F := function(A, B: Integer): Integer
      begin
        Result := A + B;
      end; // doesn't compile

    M := Test; // doesn't compile
    M := T.Test; // compiles
    M := function(A, B: Integer): Integer
      begin
        Result := A + B;
      end; // doesn't compile

    AM := Test; // compiles
    AM := T.Test; // compiles
    AM := function(A, B: Integer): Integer
      begin
        Result := A + B;
      end; // compiles

  finally
    T.Free;
  end;

end;

Under the hood, as you probably already know, F is simply a (function) pointer and M is a method pointer. Anonymous methods, on the other hand, have a more involved interface-based implementation, which allows all their magic (like variable capture).

A MUCH better and more useful explanation than the accepted answer. I wonder if there is any downside to routinely using "reference to" (not that I'd be considering doing so). — stackmik, Nov 10 '20 at 15:47
@stackmik: Perhaps the most important downside with `reference to` is the performance penalty. All its magic does have a cost. In the vast majority of applications, this is negligible (because computers are really fast today), but in performance-critical parts, the additional cost is actually quite noticable. — Andreas Rejbrand, Nov 11 '20 at 21:31
And you also need regular procedure types when you interact with APIs such as the Windows API. (E.g. using functions from DLLs, callback procedures.) — Andreas Rejbrand, Nov 12 '20 at 00:02

What does "Reference to" do exactly in Delphi?

2 Answers2