Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:126880
Precedence: bulk
MIME-Version: 1.0
References: <CALaXqqRWL8ygMGoA5xnMtt7w6rE-5WJJZ5P9oiO3vHgqvod=Fw@mail.gmail.com>
 <CAJF_ukXsyh9k+JTOiuJvYJ5Brq41vYBb-8+Cg6rfH9yE459Pbg@mail.gmail.com> <CALaXqqQDMKju=TmSR4hruG1dr4qb4MTKrmcyQdXqGa2j5B_joQ@mail.gmail.com>
In-Reply-To: <CALaXqqQDMKju=TmSR4hruG1dr4qb4MTKrmcyQdXqGa2j5B_joQ@mail.gmail.com>
Date: Thu, 20 Mar 2025 13:27:54 -0700
Message-ID: <CAJF_ukVCV-rP7XfK7BCWkb28M4DPAdWCF-J5_WAHhfP6SPS3oA@mail.gmail.com>
Subject: Re: [PHP-DEV] [RFC] [Discussion] Never parameters
To: Daniel Scherzer <daniel.e.scherzer@gmail.com>
Cc: internals@lists.php.net
Content-Type: multipart/alternative; boundary="000000000000a183cf0630cbfa00"
From: matthewfonda@gmail.com (Matt Fonda)

--000000000000a183cf0630cbfa00
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

On Thu, Mar 20, 2025 at 9:51=E2=80=AFAM Daniel Scherzer <daniel.e.scherzer@=
gmail.com>
wrote:

> On Sun, Mar 16, 2025 at 12:31=E2=80=AFPM Matt Fonda <matthewfonda@gmail.c=
om>
> wrote:
>
>> Hi Daniel,
>>
>> I believe this feature essentially amounts to "add methods which can
>> never be called", which in my mind makes no sense. If a method types
>> against an interface, and that interface uses a method with a never
>> parameter type, then we cannot actually call that method. We'd need to k=
now
>> the specific concrete type, which defeats the purpose of using an interf=
ace
>> in the first place.
>>
>
> First, I would point out that I tried to make this limited to methods tha=
t
> already cannot be called - only to interfaces and abstract methods. You
> already can't call those directly, you need to have a subclass. And you c=
an
> always type against the implementation with the actual methods that are n=
ot
> never-typed.
>

To clarify, what I mean by calling methods on an interface is typing
against the interface (for example, as a parameter to a method/function)
and then calling methods defined by the interface. As users of the
interface, we can call methods on it without knowing or caring which
specific subclass we're actually working with. In my mind, this is the
entire point of interfaces. We can write code like the following:

function foo(SomeInterface $i) {
    // ... call $i->someMethod();
}

Within foo, all we know is that $i is an instance of SomeInterface. We can
call any method on $i that SomeInterface defines. If one of those methods
had a never argument, then we could never call it.

If we did want to call the method with a never argument, then we'd need to
know a specific subclass and what type it overrides never with. At that
point, we're no longer using the interface; we're instead using the
specific subclass, entirely eliminating the need for the interface in the
first place.


> So I would ask - if not `never` parameters, then what should users do? It
> seems like, for the use case of "the interface adds a method but there ar=
e
> no promises about what parameters it accepts"
>

If an interface adds a method but makes no promises about what parameters
it accepts, then why is it part of the interface in the first place--why
add a method that can't be used?

Best regards,
--Matthew

--000000000000a183cf0630cbfa00
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><div dir=3D"ltr"><div dir=3D"ltr">On Thu, Mar 20, 2025 at =
9:51=E2=80=AFAM Daniel Scherzer &lt;<a href=3D"mailto:daniel.e.scherzer@gma=
il.com" target=3D"_blank">daniel.e.scherzer@gmail.com</a>&gt; wrote:</div><=
div class=3D"gmail_quote"><blockquote class=3D"gmail_quote" style=3D"margin=
:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"=
><div dir=3D"ltr"><div dir=3D"ltr">On Sun, Mar 16, 2025 at 12:31=E2=80=AFPM=
 Matt Fonda &lt;<a href=3D"mailto:matthewfonda@gmail.com" target=3D"_blank"=
>matthewfonda@gmail.com</a>&gt; wrote:</div><div class=3D"gmail_quote"><blo=
ckquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left=
:1px solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div><div><d=
iv dir=3D"ltr"></div></div><div><div dir=3D"ltr"><div dir=3D"ltr">Hi Daniel=
,</div></div></div></div><div><div><div dir=3D"ltr"><div class=3D"gmail_quo=
te"><div><br></div><div>I believe this feature essentially amounts to &quot=
;add methods which can never be called&quot;, which in my mind makes no sen=
se. If a method types against an interface, and that interface uses a metho=
d with a never parameter type, then we cannot actually call that method. We=
&#39;d need to know the specific concrete type, which defeats the purpose o=
f using an interface in the first place.</div></div></div></div></div></div=
></blockquote><div><br></div><div>First, I would point out that I tried to =
make this limited to methods that already cannot be called - only to interf=
aces and abstract methods. You already can&#39;t call those directly, you n=
eed to have a subclass. And you can always type against the implementation =
with the actual methods that are not never-typed.</div></div></div></blockq=
uote><div><br></div><div>To clarify, what I mean by calling methods on an i=
nterface is typing against the interface (for example, as a parameter to a =
method/function) and then calling methods defined by the interface. As user=
s of the interface, we can call methods on it without knowing or caring whi=
ch specific subclass we&#39;re actually working with. In my mind, this is t=
he entire point of interfaces. We can write code like the following:</div><=
div><br></div><div>function foo(SomeInterface $i) {</div><div>=C2=A0 =C2=A0=
 // ... call $i-&gt;someMethod();</div><div>}</div><div><br></div><div>With=
in foo, all we know is that $i is an instance of SomeInterface. We can call=
 any method on $i that SomeInterface defines. If one of those methods had a=
 never argument, then we could never call it.</div><div><br></div><div>If w=
e did want to call the method with a never argument, then we&#39;d need to =
know a specific subclass and what type it overrides never with. At that poi=
nt, we&#39;re no longer using the interface; we&#39;re instead using the sp=
ecific subclass, entirely eliminating the need for the interface in the fir=
st place.</div><div>=C2=A0</div><blockquote class=3D"gmail_quote" style=3D"=
margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-lef=
t:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote">So I would ask - if not =
`never` parameters, then what should users do? It seems like, for the use c=
ase of &quot;the interface adds a method but there are no promises about wh=
at parameters it accepts&quot;<br></div></div></blockquote><div><br></div><=
div>If an interface adds a method but makes no promises about what paramete=
rs it accepts, then why is it part of the interface in the first place--why=
 add a method that can&#39;t be used?</div><div><br></div><div>Best regards=
,</div><div>--Matthew</div></div></div>
</div>

--000000000000a183cf0630cbfa00--