Hi Folks,
For the script optimization/compilation work I’ve been doing, I’ve
been looking into what it will take to compile lambdas (anonymous
functions). Currently, these use “reference” semantics when
referring to local variables. For example, this code:
function demo(): function()
{
local i = 3;
local f = function() { print i; };
i = 5;
return f;
}
event zeek_init()
{
demo()();
}
will print `5`, because the anonymous function assigned to `f` holds a
reference to `demo`’s local variable `i`, so reflects the change made
to `i` after the instantiation of the anonymous function. This
continues to work even after `demo` exits (which requires some extra
work internally to support).
Due to how the script compiler represents values, the above semantics
would require some fairly extensive support.
My proposal is to change the semantics to instead be shallow-copying,
which means that atomic values are copied, but aggregate values (tables,
records, and vectors) are shared. With this change, the above code
would print `3`. However, this code would still print `5`:
function demo(): function()
{
local r: record { i: count; };
r$i = 3;
local f = function() { print r$i; };
r$i = 5;
return f;
}
event zeek_init()
{
demo()();
}
This change also brings the functionality closer to that used in `when`
blocks, which use deep-copying. (Arguably, it could be a good idea to
change `when` to use shallow-copying, too, but that’s a different
discussion.) If one wants deep-copy semantics, that can be done with
explicit `copy()`s, like this:
function demo(): function()
{
local r: record { i: count; };
r$i = 3;
local r2 = copy(r);
local f = function() { print r2$i; };
r$i = 5;
return f;
}
event zeek_init()
{
demo()();
}
— Vern
_______________________________________________
zeek-dev mailing list -- zeek-dev@lists.zeek.org
To unsubscribe send an email to zeek-dev-le...@lists.zeek.org
