Introduce the abiltiy to use the first-call-callable syntax on non-static methods, statically

Hello all, I've created a feature request issue on GitHub (here: https://github.com/php/php-src/issues/10414), but I have been advised that it's best to post here. What I would like to introduce/suggest, is the ability to create a closure from a method using the first-class-callable syntax (eg: MyClass::aMethod(...)), for a non-static method, statically. Currently, the following code causes an error. ``` class Test { public function test(): string { return 'test'; } } $closure = Test::test(...); ``` I understand why the error is thrown, but, and I'm unsure of the specifics regarding this, I think we could delay the error until the closure was called. The reason for this, is that closures can be bound, so if you followed on from the code above, you could do the following: ``` $closure->bindTo(new Test); $closure(); ``` The above would bind the closure in $closure to the scope of an object, which in this case, is the class that the method belongs to. The best example I can think, for this, would be when filter a collection of instances. If you were using a collection library, you would currently have something like the following: ``` $collection->filter(function (Str $string) { return !$string->empty(); }); ``` Whereas it would be much nicer to have the following: ``` $collection->filter(Str::empty(...)); ``` In this situation, the collection library would be responsible for binding the closure to the value it is iterating. I have limited experience with PHPs source, and C in general, but my understanding would be that if we were creating a closure, we would skip the check for the static method. The code responsible for handling the closure call would most require some additional functionality to check if it was bound to a valid instance, returning an error if it isn't, and then returning an error if it isn't bound at all and the method isn't static. The more I think about it, the more I think this may require a new type of Closure, or at least a runtime applied interface, to help developers determine whether a closure was created using first-class-callable syntax. I'm interested in feedback on this, and if anyone could point me towards the correct part of the codebase that handles this, I can investigate further. I am happy to create an RFC if others think this viable. --- Best Regards, *Ollie Read*