On 03.03.2013 08:07, Vasiliy Kevroletin wrote:
If the "x" is really located in the FrameObject and that object exists
only once then it is rather likely that the output of 'Before 123: '
is different from the output of 'After 123: ', right? Again I think
this is a bad thing...
I was wrong. Local variables of anonymous function located where they
should be: on stack.
That's a relieve :)
So in my opinion an implementation with a stricter division between
the single instances of an anonymous function would be the better choice
Am I understand correctly that loop
for i := 1 to 5 do
procArr[i] := procedure begin
DoSmth();
end;
should create 5 separate instances?
Not the code should be seperate, but where the captured data is located.
In Delphi there will only be one FrameObject shared by all anonymous
functions, but in my opinion it would be better if we have each a
"Storage Object" for each "instance" of an anonymous function. So in the
above example there would indeed be 5 such instance (but the code would
only exist once).
It is as I thought about closures before. But this is useless without
capturing of variables by value. During creation of anonymous method you
*can not bind any values* to it. Anonymous method have only references
to captured variables. Pascal don't allows to create static variables
inside function like in c-like languages. So you also not able to create
unique static variable which available only to one instance of same
anonymous method. Even if implementation will create many separate
objects for one anonymous function then all instances will be
equivalent. Because all instances will refer to same data.
Little side note: You can create static variables in Pascal, it's just
not as you'd expect them ;)
=== example begin ===
procedure Test;
const
FooBar: Integer = 42;
begin
Writeln(FooBar);
{$push}
{$J+}
FooBar := 21;
{$pop}
end;
Test; // 42
Test; // 21
=== example end ===
This works since at least Turbo Pascal times (and the $J enables
writeable typed constants) and was used as the "poor man's visibility
handling"
But I don't understand what you continue to write: if we create a static
variable it would be shared by all instances and not be specific to each
instance.
Also in my proposal the instances would not be equivalent. Delphi seems
to create these anonymous functions
=== code begin ===
procedure Something;
var
x, y: Integer;
proc: reference to procedure;
func: reference to function(aX: Integer): Integer;
begin
x := 42;
y := 21;
proc := procedure
begin
Writeln(x);
end;
func := function(aX: Integer): Integer
begin
Result := aX * y;
end;
end;
=== code end ===
this way (note: not necessarily compileable code):
=== code begin ===
procedure Something;
type
FrameObjectClass = class(TInterfacedObject)
x, y: Integer;
procedure CallProc1;
function CallFunc1(aX: Integer): Integer;
end;
procedure FrameObjectClass.CallProc1;
begin
Writeln(x);
end;
function FrameObjectClass.CallFunc1(aX: Integer): Integer;
begin
Result := aX * y;
end;
var
FrameObject: FrameObjectClass;
proc: reference to procedure;
func: reference to function(aX: Integer): Integer;
begin
FrameObject := FrameObjectClass.Create;
FrameObject.x := 42;
FrameObject.y := 21;
proc := @FrameObject.CallProc1;
func := @FrameObject.CallFunc1;
end;
=== code end ===
Now I would like to see it done like this:
=== code begin ===
procedure Something;
type
StorageProc1 = class(TInterfacedObject)
x: Integer;
procedure Invoke;
end;
StorageFunc1 = class(TInterfacedObject)
y: Integer;
function Invoke(aX: Integer): Integer;
end;
var
x, y: Integer;
tmp: TInterfacedObject;
proc: reference to procedure;
func: reference to function(aX: Integer): Integer;
begin
x := 42;
y := 21;
tmp := StorageProc1.Create;
tmp.x := x;
proc := @tmp.Invoke;
tmp := STorageProc1.Create;
tmp.y := y;
func := @tmp.Invoke;
end;
=== code end ===
Note: I'm aware that one shouldn't use interfaces this way; this is only
an example that should illustrate my point.
So for each assignment to a "reference to" procvar a new such Storage
Object will be created and so a "arr[1] = arr[2]" would be false in case
of the loop.
Capturing variables by value will allow simple creation of parametrised
closures. Now you also can do parametrised anonymous method but you
should wrap generation of such method into other anonymous function. For
example like this:
=== example
for i := 1 to 5 do
procArr[i] := Call(
function: TProc
var stored: Integer;
begin
stored := i;
Result := procedure
begin
Writeln(stored);
end;
end );
===
This can be simplified by support of capturing by value (please don't
make many attention to syntax, it's not main part of my proposal).
=== example
for i := 1 to 5 do
procArr[i] := procedure
capture i: byValue;
begin
Writeln(i);
end;
end );
===
What do you think about extension which will allow to specify how to
capture. Either by value or by reference?
Maybe specifying how a variable should be captured would be a solution
that can satisfy both worlds...
Regards,
Sven
_______________________________________________
fpc-devel maillist - [email protected]
http://lists.freepascal.org/mailman/listinfo/fpc-devel