RFC: Anonymous Class Lexical Scope

Morning Internals,

 Please review the following RFC:

 https://wiki.php.net/rfc/lexical-anon

 A look at the patch from those of you that do that would be good :)

Hey Joe,

The syntax and semantics proposed in this RFC don't sit quite well with me.
Especially the fact that a use($foo) on the class is then used as
$this->foo in methods is non-intuitive to me, as it differs from how the
same syntax behaves on closures. I'd like to suggest an alternative syntax:

$foo = 42;
return new class {
private $bar = $foo;
public function getBar() { return $this->bar; }
}

That is, allow properties inside the anonymous class to be initialized
based on values from the surrounding scope. This is more explicit (clearly
shows that a property is being created), it allows explicit control over
the visibility and, depending on implementation, might be more flexible
with regards to the values it accepts. It probably doesn't make sense to
restrict this to specific expressions, so all of

return new class {
private $a = $var;
private $b = $obj->prop;
private $d = $obj->prop ?? 'default';
// ...
}

could be fine.
I could not express better than you, so big +1 for your proposal so far.

Morning Internals,

 Please review the following RFC:

 https://wiki.php.net/rfc/lexical-anon

 A look at the patch from those of you that do that would be good :)

Hey Joe,

The syntax and semantics proposed in this RFC don't sit quite well with me.
Especially the fact that a use($foo) on the class is then used as
$this->foo in methods is non-intuitive to me, as it differs from how the
same syntax behaves on closures. I'd like to suggest an alternative syntax:

$foo = 42;
return new class {
private $bar = $foo;
public function getBar() { return $this->bar; }
}

This syntax is definitely better, less magic and more powerful.

That is, allow properties inside the anonymous class to be initialized
based on values from the surrounding scope. This is more explicit (clearly
shows that a property is being created), it allows explicit control over
the visibility and, depending on implementation, might be more flexible
with regards to the values it accepts. It probably doesn't make sense to
restrict this to specific expressions, so all of

return new class {
private $a = $var;
private $b = $obj->prop;
private $d = $obj->prop ?? 'default';
// ...
}

could be fine.

Is this for anonymous classes only?
Only for property default values or something else?

Also, instead of lexical scoping, we may use generic approach.

return new class<A=&$var,B=$obj->prop,C=$obj->prop ?? 'default'> {
private $a = A;
private $b = B;
private $d = C;
};

But good design of generics would take a lot of ...

Thanks. Dmitry.

Thanks,
Nikita

Nikita Popov wrote on 19/04/2016 15:18:

I'd like to suggest an alternative syntax:

$foo = 42;
return new class {
private $bar = $foo;
public function getBar() { return $this->bar; }
}

That is, allow properties inside the anonymous class to be initialized
based on values from the surrounding scope.

The problem with this is that it violates PHP's normal scoping rules,
because the variable is crossing scopes "uninvited". It makes it more
explicit where the variable is going to, but hides where it is coming
from.

Perhaps a Trait-like syntax might work?

$foo = 42;
return new class {
use $foo as private $bar;
public function getBar() { return $this->bar; }
}

This makes it clear both that $foo is being imported from somewhere, and
that it is being saved to a particular private member.

Regards,

Rowan Collins
[IMSoP]

Hi Nikita,

I was thinking some more about your suggestion:

Nikita Popov wrote on 19/04/2016 15:18:

$foo = 42;
return new class {
private $bar = $foo;
public function getBar() { return $this->bar; }
}

If we allowed this, would it make sense to also allow it in named
classes? This is currently illegal [https://3v4l.org/Kp0ep]:

$foo = 42;
class X {
private $bar = $foo;
public function getBar() { return $this->bar; }
}

It probably doesn't make sense to
restrict this to specific expressions, so all of

return new class {
private $a = $var;
private $b = $obj->prop;
private $d = $obj->prop ?? 'default';
// ...
}

could be fine.

We don't allow importing expressions into closures, nor are any of those
property initialisations valid in the definitions of named classes, so I
think allowing them here would be odd.

Regards,

Rowan Collins
[IMSoP]

Hi everyone,

having worked a bit with anonymous classes these days, the current
boilerplate is really high to inject some local context into them.
So big +1 from me for the target.

On the proposed syntax, I really prefer Nikita's proposal:

return new class {

private $a = $var;
private $b = $obj->prop;
private $d = $obj->prop ?? 'default';
// ...

}

The "functional equivalent" wording in the RFC has a big drawback: it looks
like the parent constructor is overridden, which would be a really nasty
side effect. It may not be the case in the implementation, but the the RFC
needs to be clarified IMHO.

If we were to need more closure-like syntax, we may even use "use" like
this:

return new class use ($var, $obj) {
private $a = $var;
private $b = $obj->prop;
private $d = $obj->prop ?? 'default';
// ...
}

I really hope this new syntax (which ever raises the consensus) can be
ready soon :)

Nicolas

One important thing I'd like to have here is importing the "outer" $this.
e.g.:

public function bar(){
return new class use($this as $that){
public function test(){
return $this->that;
}
};
}

And I dislike how this would look with NikiC's proposal:

return new class{
private $that = $this;
};

Especially because "constant expressions" could change in the future and
allow operations with $this, eg:

An option could be what Joe proposed new class use($this as $that) (which
I would particularly like if it allowed any kind of expression new class use($this->foo->baz() + 10 as $that){})

Or introduce a scope resolution keyword that works similarly to parent::.
E.g.:

public function bar(){
$foo = $this->getFoo();
return new class{
private $that = outer::$this;
private $foo = outer::$foo;
private $fooCall = outer::$this->getFoo();
};
}

Thoughts?

2016-05-01 16:30 GMT+02:00 Björn Larsson bjorn.x.larsson@telia.com:

Hi,

Nice and clear-cut RFC! One reflection is if the usage of use
to "import" variables could have an impact on a proposal
for a short form of Lambda functions in the future?

Cheers //Björn

PS I liked the Short Closure RFC btw.

Den 2016-04-26 kl. 10:25, skrev Joe Watkins:

Morning internals,

Just to be clear, the implementation is now in good shape, the

discussion may continue.

Attached is message from a confused contributor ... sorry about the

confusion :)

Cheers
Joe

---------- Forwarded message ----------
From: Yasuo Ohgaki yohgaki@ohgaki.net
Date: Tue, Apr 26, 2016 at 9:13 AM
Subject: Re: [PHP-DEV] RFC: Anonymous Class Lexical Scope
To: Joe Watkins pthreads@pthreads.org

Hi Joe,

Since you seem to pause this RFC activity for now, I'm sending this
mail only to you.

On Wed, Apr 20, 2016 at 3:01 PM, Joe Watkins pthreads@pthreads.org
wrote:

I must say that of all the suggestions made so far for syntax, I still
prefer use().

I strongly support "use()".
It's the way PHP imports other scope variables :)

Regards,

--
Yasuo Ohgaki
yohgaki@ohgaki.net