[RFC] [DRAFT]: Consistent callables

Dan Ackroyd wrote on 29/09/2015 15:25:

To break the silence: I really like the sentiment behind this, and it seems very thorough. I've been caught out several times by the fact that this appears to work: $callback = [self, 'some_method']; Because of the legacy "feature" of treating undefined constants as strings (which IMHO should be deprecated anyway, and removed in 8.0), it becomes this: $callback = ['self', 'some_method']; ... and the 'self' is only evaluated when you come to run it, at which point it will either fatal error, or do something completely irrelevant, depending if that name happens to exist in the class context it finds itself in. The only part I have a slight concern over is the behaviour of private/protected methods, but if some form of constructor is available to neatly wrap them into closures, I think it's acceptable to require its use. The way I see it is that currently is_callable($foo) means "is $foo callable in the current context", whereas the proposal makes it "is $foo a valid value of type callable". My only other thought is that deprecation should happen in 7.1, not "7.last", because a) we should give people as much warning as possible (as soon as the replacement functionality is available to move to) rather than leaving until the last minute; and b) we won't necessarily know that a particular release is 7.last, e.g. the decision against releasing a 5.7 happened 6 months after the release of 5.6.0 Regards,

Hi Dan. Had this email in the "need-to-read" pile for over a week and finally got the time to go though the RFC. Seems like this is something that we need to address. Inconsistencies are never good. The only thing I want to point out is that is_callable as well as method_exists don't state in the manual that the functions or methods referred is visible. To make this function implied I think the manual should be updated to state it. For instance public class A { private function foo() {} } method_exists(new A(), "foo") is technically true. The method exist but is not visible from your context. For instance when you use reflection you might want to find any method that exists? Or should that be handled by the pure reflection API? Either way I think the manual needs to state this clearly. Best regards Daniel On Tue, Sep 29, 2015 at 4:25 PM, Dan Ackroyd <danack@basereality.com> wrote:

On 29 September 2015 at 14:25, Dan Ackroyd <danack@basereality.com> wrote:

Hello again, I'd like to give everyone an update on the 'Consitent Callables RFC' https://wiki.php.net/rfc/consistent_callables It was brought to my attention that the main piece of work for this RFC that would need to target PHP 7.1 was actually already implemented in PHP 5.5, and that self::class, and parent::class already resolve to the correct classnames, i.e. the code below already works. As it won't be feasible to introduce the main change before PHP 8, I plan to wait to formally propose the RFC until closer to the time when we are thinking of starting PHP 8 development, or probably around June 2017 - whichever comes first. cheers Dan class A { public static function whoAreYou() { echo "I am A!\n"; } } class B extends A { public static function whoAreYou() { echo "I am B!\n"; } public static function test() { $fn = [parent::class, 'whoAreYou']; $fn(); $fn = [self::class, 'whoAreYou']; $fn(); } } B::test();