[RFC] Closures, Lambdas and use

On Sunday 04 January 2009 10:45:30 am Sebastian Bergmann wrote:

Marcus Boerger schrieb:

$f = function() { use $x; }

+1 for consistency.

+1 for consistency as well, which is why, as I recall, that syntax was
rejected.

$f = function() {
global $x; // By reference.
use $y; // By value or by reference?
}

If $y is by reference by default there was no obvious way to make it by value.
If by value, then it is inconsistent with the behavior of global, which is by
reference. It was determined that we definitely needed to be able to allow
both by value and by reference.

$f = function() use ($y, &$z) {
global $x; // By reference
}

$y is clearly by value, and $z clearly by reference, as that parallels the way
function parameters work right next to the lexical variables.

The way to increase consistency would be to allow the opposite:

$f = function($a, &$b) use ($y, &$z) global ($x, &$w) {

}

$x is pulled from global scope by value.
$w is pulled from global scope by reference.
$y is pulled from lexical scope by value.
$z is pulled from lexical scope by reference.
$a is pulled from calling scope by value.
$b is pulled from calling scope by reference.

Right now we have everything there except the global param list. I don't know
if we want to bother adding that in 5.3 at this point (as it would be a
syntax/feature change), but IMO that is the best way to improve consistency
while getting a little extra functionality (global by value) at the same time.

--
Larry Garfield
larry@garfieldtech.com

Hello Stanislav,

Monday, January 5, 2009, 6:03:56 AM, you wrote:

Hi!

some time back (August 08) I complained about 'use' being at a weird
position and not at the same place as 'global' or 'static' where I
expected it. Back then Dmitry asked me to provide a patch to check out
the alternative. Now during the holidays I finally found some time to
change from:
$f = function() use ($x) {}
to:
$f = function() { use $x; }

Patch is attached.

Comments?

I don't really see any "consistency" in it - this "use" syntax has
nothing to do with other "use" (namespace one) even if it looks almost
exactly like one in proposed patch. It also is subtly different from
global or static - different enough to make people think "ok, 'global'
is always by ref and 'use' looks like 'global' for consistency reasons -
does it mean it is consistently by-ref?" Not to mention questions like
"can I write 'use' in the middle of the code, since I can do it with
"consistent" constructs like 'static' or 'global'? What if I refer to
the variable before - will it be already bound?", etc. I think it would
not improve code readability and not really make it "consistent" anyway.

We have the same with global and static. Can you write them in the middle
of a funciton/method? So asking for what the consequence is, is irrelevant
unless you want to clean up that mess and correct the parser rules knowing
that it would break most PHP applications out there. Next, we chose 'use'
for the keyword, knowing that it was already used elsewhere, dciding that
it is the lesser evil opposed to creating yet another keyword with all
implications of that. So this part is irrelevant to my point as well.

What is left is moving something we decided upon so that it might look like
something that is similar already avoiding to create a pretty new syntax
that in my opinion is unnecessary different from anything we already have.

In fact 'use' means create a static variable from the surrounding context,
while 'static' means create a new static variable. Actually the executor
does not know the difference at all. Next 'global' means allow to use a
global variable.

So:
function () {
global $foo;
static $bar;
use $baz;
}

Is pretty clear to me, as all three statements have a defined keyword. And
I would really prefer if all I have to teach is the meaning of the keyword.
And not having to teach a completely new syntax:

function() use($baz) {
global $foo;
static $bar;
}

That simply contradicts the KISS approach because it requires one
additional level of understanding.

And to answer the other question. Obviously 'sttaic' and 'use' are executed
at compile time, so whereever you place them, they are executed before
anything else. Thus it doesn't matter where you place them.

So here consistency means placing a syntactical element at the same
syntactical location related syntactical elements are placed.

Best regards,
Marcus

I like how the current syntax forces you to define what your importing right
next to the function signature. It's easy to waste time debugging if your
assumptions about what's being imported into scope are wrong.

Erik Schulz - gradbot @ gmail, yahoo, aim
Software Engineer, Vulcan Inc.

Personally I like the current syntax more and don't see any reason to
change it.

Thanks. Dmitry.

Marcus Boerger wrote:

Hello Internals, Dmitry, Lukas, Johannes,

some time back (August 08) I complained about 'use' being at a weird
position and not at the same place as 'global' or 'static' where I
expected it. Back then Dmitry asked me to provide a patch to check out
the alternative. Now during the holidys I finally found some time to
change from:
$f = function() use ($x) {}
to:
$f = function() { use $x; }

Patch is attached.

Comments?

Best regards,
Marcus

Dmitry Stogov wrote:

Personally I like the current syntax more and don't see any reason to
change it.

Thanks. Dmitry.

Marcus Boerger wrote:

Hello Internals, Dmitry, Lukas, Johannes,

some time back (August 08) I complained about 'use' being at a weird
position and not at the same place as 'global' or 'static' where I
expected it. Back then Dmitry asked me to provide a patch to check out
the alternative. Now during the holidys I finally found some time to
change from:
$f = function() use ($x) {}
to:
$f = function() { use $x; }

Patch is attached.

Comments?

I think the current syntax may be clearer:

<?php
namespace blah;
include 'file/with/foo/namespace.php';
use foo/something;
$f = function() use ($x) {}
?>

<?php
namespace blah;
include 'file/with/foo/namespace.php';
use foo/something;
$f = function()
{
use $x;
}
?>

The second version requires a visual re-parsing, the first is clear at a
glance. In addition, if support for namespaced variables was ever
introduced, confusion would abound.

Thanks,
Greg

P.S. happy new year (I'm a bit slow)