On Fri, Jul 26, 2024, at 23:54, Bilge wrote:
> Hi Internals,
>
> New RFC idea just dropped. When writing a function, we can specify defaults
> for its parameters, and when calling a function we can leverage those
> defaults *implicitly* by not specifying those arguments or by "jumping over"
> some of them using named parameters. However, we cannot *explicitly* use the
> defaults. But why would we want to?
>
> Sometimes we want to effectively *inherit* the defaults of a function we're
> essentially just proxying. One way to do that is copy and paste the entire
> method signature, but if the defaults of the proxied method change, we're now
> overriding them with our own, which is not what we wanted to do. It is
> possible, in a roundabout way, to avoid specifying the optional parameters by
> filtering them out (as shown in the next example). The final possibility is
> to use reflection and literally query the default value for each optional
> parameter, which is the most awkward and verbose way to inherit defaults.
>
> Let's use a concrete example for clarity.
>
> function query(string $sql, int $limit = PHP_INT_MAX, int $offset = 0);
>
>
>
> function myQuery(string $sql, ?int $limit = null, ?int $offset = null) {
> query(...array_filter(func_get_args(), fn ($arg) => $arg !== null));
> }
>
>
> In this way we are able to filter out the null arguments to inherit the
> callee defaults, but this code is quite ugly. Moreover, it makes the
> (sometimes invalid) assumption that we're able to use `null` for all the
> optional arguments.
>
> In my new proposal for *explicit *callee defaults, it would be possible to
> use the `default` keyword to expressly use the default value of the callee in
> that argument position. For example, the above implementation for myQuery()
> could be simplified to the following.
>
>
>
> function myQuery(string $sql, ?int $limit = null, ?int $offset = null) {
> query($sql, $limit ?? default, $offset ?? default);
> }
>
>
> Furthermore, it would also be possible to "jump over" optional parameters
> *without* using named parameters.
>
> json_decode($json, true, default, JSON_THROW_ON_ERROR);
>
> This proposal is built on the assumption that it is possible to specify that
> PHP should only accept the `default` expression in method and function call
> contexts. For example, it would not be valid to return `default` from a
> function and substitute it that way; my proposal is to only permit `default`
> in literal function calling contexts. My knowledge of internals is
> insufficient (read: non-existent) to know whether or not this restriction is
> possible to implement, but if it is, I think this is a good idea. What do you
> think?
>
>
>
> Cheers,
> Bilge
>
>
This seems like a case for code generation — and an RFC that provides hooks for
code generation would probably be better IMHO.
There are a couple of neat tools out there doing this and hooking into
composer, like
https://packagist.org/packages/olvlvl/composer-attribute-collector
There are many things that could benefit from this, such as DI containers,
scanning for attributes, generating efficient serializers/deserializers, etc.
— Rob
