Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:122932
Content-Type: multipart/alternative;
 boundary="------------mM2TByyy1BaVBiGC0YHKdpkz"
Message-ID: <67221462-6c9f-48d7-8c59-e7262a744ff5@uzy.me>
Date: Thu, 4 Apr 2024 15:26:50 +0200
Precedence: bulk
MIME-Version: 1.0
User-Agent: Mozilla Thunderbird
Subject: Re: [PHP-DEV] RFC idea: using the void type to control maximum arity
 of user-defined functions
To: Mark Trapp <mark@itafroma.com>
Cc: internals@lists.php.net
References: <6299b649-c19b-4172-9632-2ef0a55d256d@uzy.me>
 <CA+pig-JBkZip5bEM0gSwcwNRO9NDKuRO2vu=iHnx2diBTv9Bng@mail.gmail.com>
Content-Language: fr, en-US
In-Reply-To: <CA+pig-JBkZip5bEM0gSwcwNRO9NDKuRO2vu=iHnx2diBTv9Bng@mail.gmail.com>
From: r@uzy.me (Pablo Rauzy)

This is a multi-part message in MIME format.
--------------mM2TByyy1BaVBiGC0YHKdpkz
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit

Le 04/04/2024 à 15:03, Mark Trapp a écrit :
> On Thu, Apr 4, 2024 at 5:43 AM Pablo Rauzy<r@uzy.me>  wrote:
>> Hello all,
>>
>> First, I'm new here, so let me start by warmly thanking everyone
>> involved in PHP development. I've started programming 22 years using it
>> as my first programming language, and still enjoy using it a lot :).
>>
>> I've read the rfc:howto and the first step is to get feedback from this
>> mailing list about the intended proposal, so here is a short description
>> of what I have in mind:
>>
>> Currently PHP does not warn when user-defined functions are called with
>> too many arguments. Changing this could break a lot of existing code,
>> but it would also be a very good verification to catch potential bugs.
>>
>> I have an idea allowing this feature without breaking any existing code:
>> using the void keyword in a function arguments list to strictly limit
>> the number of arguments a user-defined function can receive, stopping it
>> on the void, which could only be used once and in the last position.
>>
>> Currently, void is a return-only type so it isn't used in arguments list
>> in existing code, so I believe the new behavior would only concern newly
>> written code that explicitly wants to take advantage of this feature.
>>
>> A few examples using functions (the same would apply to class methods,
>> callbacks, closures, etc.) :
>>
>>       function foo (void) {}
>>       foo(42); // warning: foo() expects exactly 0 arguments, 1 given
>>
>>       function bar ($a, $b, void) {}
>>       bar(1, 2, 3); // warning: bar() expects exactly 2 arguments, 3 given
>>
>>       function baz ($a, $b=null, void) {}
>>       baz(1, 2, 3); // warning: baz() expects at most 2 arguments, 3 given
>>
>> I have no knowledge of the PHP internals: would that be feasible without
>> breaking things? And, as importantly, would it be a welcome change?
>>
>> Cheers,
> Hi Pablo,
>
> I like this concept, but instead of introducing a new syntax, have you
> considered leveraging attributes in the same way that PHP 8.3
> introduced #[Override]?
>
> #[Nonvariadic]
> function foo () {}
> foo(42); // warning: foo() expects exactly 0 arguments, 1 given
>
> I think the intent would be clearer and it would avoid introducing a new syntax.

Hello Mark,

I never used attributes so I didn't even think of it, but that would 
work too, yes :).

I would personally prefer the void syntax, but that's really because 
attributes look odd to me due to lack of habits (and also because it 
avoids an additional line of code… which is probably not a solid enough 
reason when it comes to language design decisions).

Regards,

-- 
Pablo

--------------mM2TByyy1BaVBiGC0YHKdpkz
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: 8bit

<!DOCTYPE html>
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  </head>
  <body>
    <div class="moz-cite-prefix">Le 04/04/2024 à 15:03, Mark Trapp a
      écrit :<br>
    </div>
    <blockquote type="cite"
cite="mid:CA+pig-JBkZip5bEM0gSwcwNRO9NDKuRO2vu=iHnx2diBTv9Bng@mail.gmail.com">
      <pre class="moz-quote-pre" wrap="">On Thu, Apr 4, 2024 at 5:43 AM Pablo Rauzy <a class="moz-txt-link-rfc2396E" href="mailto:r@uzy.me">&lt;r@uzy.me&gt;</a> wrote:
</pre>
      <blockquote type="cite">
        <pre class="moz-quote-pre" wrap="">
Hello all,

First, I'm new here, so let me start by warmly thanking everyone
involved in PHP development. I've started programming 22 years using it
as my first programming language, and still enjoy using it a lot :).

I've read the rfc:howto and the first step is to get feedback from this
mailing list about the intended proposal, so here is a short description
of what I have in mind:

Currently PHP does not warn when user-defined functions are called with
too many arguments. Changing this could break a lot of existing code,
but it would also be a very good verification to catch potential bugs.

I have an idea allowing this feature without breaking any existing code:
using the void keyword in a function arguments list to strictly limit
the number of arguments a user-defined function can receive, stopping it
on the void, which could only be used once and in the last position.

Currently, void is a return-only type so it isn't used in arguments list
in existing code, so I believe the new behavior would only concern newly
written code that explicitly wants to take advantage of this feature.

A few examples using functions (the same would apply to class methods,
callbacks, closures, etc.) :

     function foo (void) {}
     foo(42); // warning: foo() expects exactly 0 arguments, 1 given

     function bar ($a, $b, void) {}
     bar(1, 2, 3); // warning: bar() expects exactly 2 arguments, 3 given

     function baz ($a, $b=null, void) {}
     baz(1, 2, 3); // warning: baz() expects at most 2 arguments, 3 given

I have no knowledge of the PHP internals: would that be feasible without
breaking things? And, as importantly, would it be a welcome change?

Cheers,
</pre>
      </blockquote>
      <pre class="moz-quote-pre" wrap="">
Hi Pablo,

I like this concept, but instead of introducing a new syntax, have you
considered leveraging attributes in the same way that PHP 8.3
introduced #[Override]?

#[Nonvariadic]
function foo () {}
foo(42); // warning: foo() expects exactly 0 arguments, 1 given

I think the intent would be clearer and it would avoid introducing a new syntax.
</pre>
    </blockquote>
    <p>Hello Mark,</p>
    <p>I never used attributes so I didn't even think of it, but that
      would work too, yes :).</p>
    <p>I would personally prefer the void syntax, but that's really
      because attributes look odd to me due to lack of habits (and also
      because it avoids an additional line of code… which is probably
      not a solid enough reason when it comes to language design
      decisions).</p>
    <p>Regards,<br>
    </p>
    <pre class="moz-signature" cols="72">-- 
Pablo</pre>
  </body>
</html>

--------------mM2TByyy1BaVBiGC0YHKdpkz--