Hello Internals,
I want to request making possible to catch functions with wrong signature
when passed as callable. In other words, when a function or a method is
passed as callable value, PHP will first confirm whether the function is of
the write callable type that the function being executed requires. It will
help catch silent errors.
Currently, PHP does following:
- Confirms whether a callable is valid.
- Passes the callable value to a function, and the execution starts.
- If the passed function receives values which's type is different than
function signature, PHP throws an error. - If passed function returns nothing, the variable that wanted a value from
the passed function receives null. - As a result, the unexpected results emerge.
To resolve this issue, I propose to introduce a mechanism that allows to
hint callable signatures. To understand the spirit of this request, look at
the similar functionality that Angel Script Project provides with. - One defines a function definition.
- Use its name to hint the same signature.
- The compiler alerts about the incorrect signature before passing this to
a function.
If I could do this in PHP, I would write like following:
funcdef preg_replace_callback_hint(array $matches) : string;
If I accidently pass a callable which's signature is different than desired
function call, the error is caught earlier.
This message does not suggests syntax; it only points to a problem and
suggests a solution. Any volunteers that would love to come up with syntax
and implement this?
I am curious to see the feedback.
Regards
Hamza Ahmad
Hello Hamza,
I think this is something that has been discussed here before.
function types already exist in HackLang: https://docs.hhvm.com/hack/functions/introduction#function-types,
And, if we would follow the same syntax (function(T, T): T) or (callable(T, T): T), PHP needs to first support parentheses in
type declaration ( grouping ), which currently it doesn't ( i.e: function baz((string|bar) $foo): void {} becomes valid ).
And just to note, function types are also supported by static analysis tools such as Psalm ( https://psalm.dev/docs/annotating_code/type_syntax/callable_types/ ) and PHPStan ( https://phpstan.org/writing-php-code/phpdoc-types#callables ), so i suppose if PHP is to support typed callables, it should take inspiration from these tools.
There's also an alternative syntax that was proposed back in 2016 for PHP 7.1, but it seems like the RFC was abandoned: https://wiki.php.net/rfc/typesafe-callable
Cheers,
Saif.
‐‐‐‐‐‐‐ Original Message ‐‐‐‐‐‐‐
Hello Internals,
I want to request making possible to catch functions with wrong signature
when passed as callable. In other words, when a function or a method is
passed as callable value, PHP will first confirm whether the function is of
the write callable type that the function being executed requires. It will
help catch silent errors.
Currently, PHP does following:
- Confirms whether a callable is valid.
- Passes the callable value to a function, and the execution starts.
- If the passed function receives values which's type is different than
function signature, PHP throws an error.
- If passed function returns nothing, the variable that wanted a value from
the passed function receives null.
- As a result, the unexpected results emerge.
To resolve this issue, I propose to introduce a mechanism that allows to
hint callable signatures. To understand the spirit of this request, look at
the similar functionality that Angel Script Project provides with.
- One defines a function definition.
- Use its name to hint the same signature.
- The compiler alerts about the incorrect signature before passing this to
a function.
If I could do this in PHP, I would write like following:
funcdef preg_replace_callback_hint(array $matches) : string;
If I accidently pass a callable which's signature is different than desired
function call, the error is caught earlier.
This message does not suggests syntax; it only points to a problem and
suggests a solution. Any volunteers that would love to come up with syntax
and implement this?
I am curious to see the feedback.
Regards
Hamza Ahmad
-- To unsubscribe, visit: https://www.php.net/unsub.php
Hello,
I thanks Saif for adding to my argument and providing with the list of
other languages/tools that support such a functionality.
As Saif has mentioned about "typesafe callables" RFC that is now
inactive, I want to also point out toward another rfc that was
declined.
It was Callable Prototype RFC that had sought for the similar
functionality. https://wiki.php.net/rfc/callable-types
Python also provides with a library ever since 3.5:
https://docs.python.org/3/library/typing.html
After looking at the prior RFCs, I feel like that it requires a fresh
discussion. Because there are several syntax to choose from, a
separate vote will only be held for this.
Best
Hamza Ahmad
Hello Hamza,
I think this is something that has been discussed here before.
function types already exist in HackLang:
https://docs.hhvm.com/hack/functions/introduction#function-types,And, if we would follow the same syntax
(function(T, T): T)or
(callable(T, T): T), PHP needs to first support parentheses in
type declaration ( grouping ), which currently it doesn't ( i.e:function baz((string|bar) $foo): void {}becomes valid ).And just to note, function types are also supported by static analysis tools
such as Psalm (
https://psalm.dev/docs/annotating_code/type_syntax/callable_types/ ) and
PHPStan ( https://phpstan.org/writing-php-code/phpdoc-types#callables ), so
i suppose if PHP is to support typed callables, it should take inspiration
from these tools.There's also an alternative syntax that was proposed back in 2016 for PHP
7.1, but it seems like the RFC was abandoned:
https://wiki.php.net/rfc/typesafe-callableCheers,
Saif.
‐‐‐‐‐‐‐ Original Message ‐‐‐‐‐‐‐
On Wednesday, April 7, 2021 11:58 AM, Hamza Ahmad
office.hamzaahmad@gmail.com wrote:Hello Internals,
I want to request making possible to catch functions with wrong signature
when passed as callable. In other words, when a function or a method is
passed as callable value, PHP will first confirm whether the function is
of
the write callable type that the function being executed requires. It
will
help catch silent errors.
Currently, PHP does following:
- Confirms whether a callable is valid.
- Passes the callable value to a function, and the execution starts.
- If the passed function receives values which's type is different than
function signature, PHP throws an error.
- If passed function returns nothing, the variable that wanted a value
from
the passed function receives null.
- As a result, the unexpected results emerge.
To resolve this issue, I propose to introduce a mechanism that allows
to
hint callable signatures. To understand the spirit of this request,
look at
the similar functionality that Angel Script Project provides with.
- One defines a function definition.
- Use its name to hint the same signature.
- The compiler alerts about the incorrect signature before passing this
to
a function.
If I could do this in PHP, I would write like following:
funcdef preg_replace_callback_hint(array $matches) : string;
If I accidently pass a callable which's signature is different than
desired
function call, the error is caught earlier.
This message does not suggests syntax; it only points to a problem
and
suggests a solution. Any volunteers that would love to come up with
syntax
and implement this?
I am curious to see the feedback.
Regards
Hamza Ahmad-- To unsubscribe, visit: https://www.php.net/unsub.php