[RFC] Callable Types

As mentioned on Reddit and in the future scope section of union types, we may want to introduce named type expressions: type IntReducer = callable(int, int): int; Which would also allow unions (if passed, of course): type Iterable = Array | Traversable; It would also allow for a general type-aliasing mechanism for single names. This feature has been asked for in the past but I can't remember the use-cases so this example is not very good: type Foo = SomeFoo; Then we just use the names where we would have put the expressions: function reduce(int $a, int $b, IntReducer $reducer): int { return $reducer($a, $b); }

On Sat, 23 Apr 2016 10:46:38 +0300, Jesse Schalken <me@jesseschalken.com> wrote:

Hey Jesse, Thanks for reading the RFC. First and foremost - no, the rules for compatibility between callables and method implementations are different at least because our inheritance model currently doesn't support variance for every case: if you have class B extends A {} interface Foo { function foo(B $b); } then implementation of `foo()` can never have `foo(A $a)` signature, which is crucial for callables for some cases. Note that callables have runtime variance, where classes would have compile-time variance). So, in this way, callables have it right (it is desirable for classes to have variance as well, but currently it's not possible as there is a need for another compilation phase for verifying variance). What about your case of variance with extra optional parameter, it is actually not type safe with the current way of how PHP works (it's covered in the end of "Variance and Signature Validation" part). The problem lies in the notion that passing extra arguments to the function (the ones it doesn't even expect nor use) is considered valid and doesn't throw an error. So if you have a function that accepts optional argument of type B and you pass this function as a parameter of type `callable() $cb`, then it would be perfectly valid to call it as `$cb(new A);` because you assume that $cb is of type `callable()` and that means if you pass anything extra - it shouldn't Fatal. But in this case it would. While I agree that your use case is legit and ideally should be supported, I don't think it is safe to support it until PHP deprecates passing extra args to functions that don't expect them (which is very troublesome to implement due to BC). Anyway, changing this behavior of callable type later on wouldn't break BC so the gates will still be open. I've just added a part about references to the RFC (and found a bug in the implementation, thanks for that =)), I'll just copy and paste it here: Reference parameters are supported: no variance is applied to the fact whether parameter is referential or not. Example: function foo(callable(&$byref) $cb) { } foo(function (&$bar) { }); // valid foo(function ($bar) { }); // TypeError: Argument 1 passed to foo() must be callable of compliant signature: callable(&$byref), callable($bar) given function bar(callable($byval) $cb) { } bar(function (&$bar) { }); // TypeError: Argument 1 passed to bar() must be callable of compliant signature: callable($byval), callable(&$bar) given Functions returning a reference are not different from functions returning a value in PHP, for the caller, hence both are interchangeable: function foo(callable(): A $cb) { } foo(function (): A { return new A; }); foo(function &(): A { static $a; $a = $a ?: new A; return $a; }); // both would pass the boundaries of a type check (the last one has error in the current implementation, I'll fix it later)

On Sat, 23 Apr 2016 14:18:56 +0300, Dan Ackroyd <danack@basereality.com> wrote:

Hey Dan, thanks for reviewing. I have just added a paragraph about nested callables, I'll copy paste it here: Nested callables can be used with no imposed limit on the nesting level. function foo(callable(callable(int)) $cb) { $cb(function (int $i) { var_dump($i); }); } foo(function (callable(int) $intPrinter) { $intPrinter(123); }); There's currently no way to reference callable signature from within itself, meaning there's no way to make recursive signatures like below: function bar(callable(int $number): callable(int $number): callable(int $number): parent_callable $recursiveCb) { // this wouldn't work currently } To add to that, nested callables can get pretty unreadable quickly, both of these problems would be best solved by a typedef feature of some kind, added to PHP later.