Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:122985
Precedence: bulk
MIME-Version: 1.0
References: <CAMrTa2Geo1XHFxfa1Mj6tXcYC-gVwQeUK+Wk0h11d1fELUyZJQ@mail.gmail.com>
 <46B14427-44B2-4665-BC14-6018AC34B0CF@sakiot.com>
In-Reply-To: <46B14427-44B2-4665-BC14-6018AC34B0CF@sakiot.com>
Date: Fri, 5 Apr 2024 13:01:28 -0700
Message-ID: <CAMrTa2E7r1eXPCD-=s1Wgg47b=eODqqY9LR1oLHH2LyYdGS_3A@mail.gmail.com>
Subject: Re: [PHP-DEV] [RFC] [Discussion] Support object type in BCMath
To: Saki Takamachi <saki@sakiot.com>
Cc: =?UTF-8?Q?Tim_D=C3=BCsterhus?= <tim@bastelstu.be>, Lynn <kjarli@gmail.com>, 
	Aleksander Machniak <alec@alec.pl>, php internals <internals@lists.php.net>
Content-Type: multipart/alternative; boundary="000000000000e1e23f06155eec3a"
From: jordan.ledoux@gmail.com (Jordan LeDoux)

--000000000000e1e23f06155eec3a
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

On Fri, Apr 5, 2024 at 12:42=E2=80=AFPM Saki Takamachi <saki@sakiot.com> wr=
ote:

>
> The only solution I can think of at the moment is to impose the constrain=
t
> that when computing operator overloading, if the operands are both object=
s,
> they must be of the exact same class.
>
> When calculating using a method, it is clear which object should be
> prioritized, so there is no risk of breaking down even if the method
> accepts objects of different classes as arguments. It would be possible t=
o
> unify the behavior of the methods with operator overloading, but this wou=
ld
> be undesirable because the arguments would be contravariant.
>
>
This is something that there are established solutions for actually. It's
called Polymorphic Handler Resolution. This essentially means that when you
have two objects used with operators, if they share a parent class or a
class structure, the newest descendant is given priority. For example, if
you have class A as the parent, then class B and class C as children:

A + B =3D B, because it is a child class of A
B + A =3D B, because it is a child class of A
B + C =3D B, because neither are direct descendants
C + B =3D C, because neither are direct descendants

If we add the requirement that they must either be the same class as you
suggested, OR one must be a descendant of the other, then we eliminate the
B + C issue entirely, which makes sense for a BCMath object. How this would
actually be implemented in C is that both operands would be checked for
inheritance. If they are different classes and one is not the descendant of
the other, it would error. If they are different classes and one IS the
descendant of the other, then the handler for the descendant would be
called, and that handler would always return an instance of itself.

Jordan

--000000000000e1e23f06155eec3a
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><div dir=3D"ltr"><br></div><br><div class=3D"gmail_quote">=
<div dir=3D"ltr" class=3D"gmail_attr">On Fri, Apr 5, 2024 at 12:42=E2=80=AF=
PM Saki Takamachi &lt;<a href=3D"mailto:saki@sakiot.com">saki@sakiot.com</a=
>&gt; wrote:<br></div><blockquote class=3D"gmail_quote" style=3D"margin:0px=
 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><di=
v dir=3D"auto"><div dir=3D"ltr"><div dir=3D"ltr"><div dir=3D"ltr"></div><br=
><div>The only solution I can think of at the moment is to impose the const=
raint that when computing operator overloading, if the operands are both ob=
jects, they must be of the exact same class.</div><div><br></div><div>When =
calculating using a method, it is clear which object should be prioritized,=
 so there is no risk of breaking down even if the method accepts objects of=
 different classes as arguments. It would be possible to unify the behavior=
 of the methods with operator overloading, but this would be undesirable be=
cause the arguments would be contravariant.</div><br></div></div></div></bl=
ockquote><div><br></div><div>This is something that there are established s=
olutions for actually. It&#39;s called Polymorphic Handler Resolution. This=
 essentially means that when you have two objects used with operators, if t=
hey share a parent class or a class structure, the newest descendant is giv=
en priority. For example, if you have class A as the parent, then class B a=
nd class C as children:</div><div><br></div><div>A + B =3D B, because it is=
 a child class of A</div><div>B + A =3D B, because it is a child class of A=
</div><div>B + C =3D B, because neither are direct descendants</div><div>C =
+ B =3D C, because neither are direct descendants</div><div><br></div><div>=
If we add the requirement that they must either be the same class as you su=
ggested, OR one must be a descendant of the other, then we eliminate the B =
+ C issue entirely, which makes sense for a BCMath object. How this would a=
ctually be implemented in C is that both operands would be checked for inhe=
ritance. If they are different classes and one is not the descendant of the=
 other, it would error. If they are different classes and one IS the descen=
dant of the other, then the handler for the descendant would be called, and=
 that handler would always return an instance of itself.</div><div><br></di=
v><div>Jordan<br></div></div></div>

--000000000000e1e23f06155eec3a--