Feature announcement: Function References and Anonymous Functions

[Martin_fr]

Code: Pascal  [Select][+][-]

1. {$ModeSwitch anonymousfunctions}

[beria2]

Code: Pascal  [Select][+][-]

1. {$ModeSwitch anonymousfunctions}

It's not that simple. Here are my compiler directives:
 {$mode objfpc}// Основной режим Object Pascal
{$ASMMODE INTEL}           // Синтаксис Intel для ассемблерных блоков
{$COPERATORS ON}           // Операторы C-style (+=, -= и т.д.)
{$GOTO ON}                 // Разрешает использование меток и goto
{$INLINE ON}               // Включение инлайнинга функций
{$MACRO ON}                // Поддержка макросов препроцессора
// Мод-свитчи:
{$MODESWITCH ADVANCEDRECORDS}  // Методы в records
{$MODESWITCH ANONYMOUSFUNCTIONS} // Анонимные функции  (sic!)
{$MODESWITCH ARRAYOPERATORS}   // Перегрузка операторов для массивов
{$MODESWITCH CLASS}           // Полная поддержка классов
{$MODESWITCH CLASSICPROCVARS} // Классические процедурные переменные
{$MODESWITCH DUPLICATELOCALS} // Разрешение дублирования имен переменных
{$MODESWITCH NESTEDPROCVARS}  // Вложенные процедурные переменные
{$MODESWITCH OUT}             // Параметры out
{$MODESWITCH POINTERTOPROCVAR} // Преобразование указателей в procvar
{$MODESWITCH RESULT}          // Использование Result в функциях
{$MODESWITCH TYPEHELPERS}     // Хелперы для типов
{$PACKENUM 4}            // Минимальный размер перечислений
{$PACKRECORDS C}         // C-совместимое выравнивание записей
{$PACKSET 4}             // Минимальный размер множеств
{$Q-}                    // Проверка переполнения
{$R-}                    // Проверка диапазона
{$T-}                    // Проверка типизированных указателей                                                       
{$H+}                    // Режим расширенного диапазона для типа integer
{$S+}                    // Выравнивание полей


type
  TProc = reference to procedure;




Компиляция проекта, режим: Default, цель: z:\Number\number.exe: Код завершения 1, ошибок: 3, подсказок: 3
Hint: Start of reading config file Z:\fpcupdeluxe\fpc\bin\x86_64-win64\fpc.cfg
Hint: End of reading config file Z:\fpcupdeluxe\fpc\bin\x86_64-win64\fpc.cfg
Verbose: Free Pascal Compiler version 3.3.1-17788-gc6d3e42129-dirty [2025/04/12] for x86_64
Verbose: Copyright (c) 1993-2025 by Florian Klaempfl and others
Note: Switching assembler to default source writing assembler
Verbose: Target OS: Win64 for x64
Verbose: Compiling number.lpr
Verbose: Compiling Bit.pas
Bit.pas(187,14) Error: Identifier not found "reference"
Bit.pas(187,24) Error: Error in type definition
Bit.pas(187,24) Error: Syntax error, ";" expected but "TO" found
Verbose: Compilation aborted
Verbose: Z:\fpcupdeluxe\fpc\bin\x86_64-win64\ppcx64.exe returned an error exitcode

[TRon]

Code: Pascal  [Select][+][-]

1. {$ModeSwitch anonymousfunctions}

It's not that simple. Here are my compiler directives:
...
{$MODESWITCH ANONYMOUSFUNCTIONS} // Анонимные функции  (sic!)
...

Code: Pascal  [Select][+][-]

1. type
2.   TProc = reference to procedure;
3.  

It is actually that simple because anonymous function <> function reference.

Code: Pascal  [Select][+][-]

1. {$modeswitch functionreferences}
2.  

Two different concepts, two different modeswitches.

[Thaddy]

@TRon
@beria2
Yes TRon, indeed, let's illustrate the different concepts with two more simple examples:
1. anonymous functions:

Code: Pascal  [Select][+][-]

1. {$mode objfpc}{$H+}{$modeswitch anonymousfunctions}
2. begin
3.   writeln(function:string
4.              begin
5.                 result := 'hello, World';
6.              end());
7. end.

2. function references:

Code: Pascal  [Select][+][-]

1. {$mode objfpc}{$modeswitch functionreferences}
2. Type
3.   THelloWorld = reference to function:string;
4.  
5.   function hello:string;
6.   begin
7.     Result := 'hello';
8.   end;
9.  
10.   function world:string;
11.   begin
12.     Result := ', world';
13.   end;
14.  
15. var
16.   hw:THelloWorld;
17. begin
18.   hw :=@hello;
19.   write(hw());
20.   hw :=@world;
21.   writeln(hw());
22. end.

1. demonstrates an anonymous function, uses no outer variables and executes the function inline.
2. demonstrates function references, a variable of the type of the function reference can point to and execute different functions with the same prototype.

Note that in these examples I use no parameters but in both cases you can use parameters for the functions or procedures.

I could not come up with simpler examples.

Wait Uhhhh,
-----------------------------------------------
warning: just because we can code follows
-----------------------------------------------
A contrived example that combines the two  :

Code: Pascal  [Select][+][-]

1. {$mode objfpc}
2. {$modeswitch functionreferences}
3. {$modeswitch anonymousfunctions}
4. begin
5.   writeln(function:string
6.          Type
7.             THelloWorld = reference to function:string;
8.             function hello:string;
9.             begin
10.               Result := 'hello';
11.             end;
12.  
13.             function world:string;
14.             begin
15.               Result :=', world';
16.             end;
17.            
18.             var hw:THelloWorld;
19.           begin
20.             hw := @hello;
21.             result:=hw();
22.             hw := @world;
23.             result := result+hw();
24.           end());
25. end.

I hope the latter will not add to the confusion..
@cdbc
Beyond cool innit? 

[beria2]

  for I := 0 to function: integer
  begin
    if StrLen < TypeBits then Result := StrLen
    else
      Result := TypeBits;
  end() - 1 do


 

[Thaddy]

  That won't work.(I hope... )
Loop variables need to be known at compile time.

[Marc]

The loop variable (I) is known. The terminating expression is evaluated before the loop starts so my guess is that this is valid (not that I ever will use it)

[cdbc]

Hi

@cdbc
Beyond cool innit? 

Yup  ...and to think, all of this magic happens via interfaces behind the scenes... 
Regards Benny

[beria2]

That won't work.(I hope... )
Loop variables need to be known at compile time.

It's working 

[Thaddy]

My point was 1 and 2, which are educational. The third was a joke..

[cdbc]

Hi
Ofc. Thaddy 
I wouldn't want to see 3) in any codebase, anytime soon  ...or later for that matter 
Regards Benny

[PascalDragon]

Yup  ...and to think, all of this magic happens via interfaces behind the scenes... 

You need some mechanism to track the lifetime of the function reference. And once the capturer object implementing the interface is instantiated it's not that expensive: the increments/decrements of the reference count while passing the interface around and an indirect method call for each invocation of the function reference.

[wfbhappy]

fpc4.0  release time ？

[Thaddy]

fpc4.0  release time ？

If you have read the whole thread: Unknown. When it is ready and when enough resources are available for release manament. This is complex and time consuming for such a small core team. The next release will be a point release and will not contain many of the new features. 3.2.4.
4.0 contains many new features, but there are also quite some outstanding bugs.
If you want to use the new features, simply use trunk/main.
That is also highly educational and you may even help to find and solve any bug or write examples.

Patience,.

[munair]

That won't work.(I hope... )
Loop variables need to be known at compile time.

Not necessarily. A for loop needs two numeric expressions. If an expression like a := b + myfunc(); is allowed, then why not for i := b + func1() to c + func2() do ...? The compiler generates the code for each expression before commencing the loop, so there is no reason why that shouldn't work, unless the compiler explicitly forbids it.