Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:126371
Precedence: bulk
MIME-Version: 1.0
References: <CAJWOiuNQ+ue-ZyY3EfnEQGo9JJ5mjf=tByxp31M__N71_ODy6A@mail.gmail.com>
 <CALWFqqBFJr2E-8s7eGsZ=MOFGpaa7rsgcqrSU0QB5g6zs_yRdQ@mail.gmail.com>
In-Reply-To: <CALWFqqBFJr2E-8s7eGsZ=MOFGpaa7rsgcqrSU0QB5g6zs_yRdQ@mail.gmail.com>
Date: Tue, 11 Feb 2025 18:02:36 +0500
Message-ID: <CAJWOiuOHbD8CCEz8scjFH0soVyg5wvjRRb6o0L5jj9_H=1v3DQ@mail.gmail.com>
Subject: Re: [PHP-DEV] RFC: Not Null Assertion Operator
To: MrMeshok <ilyaorlov124@gmail.com>
Cc: internals@lists.php.net
Content-Type: multipart/alternative; boundary="0000000000000e1b36062ddd71a2"
From: 91liahim@gmail.com (Mihail Liahimov)

--0000000000000e1b36062ddd71a2
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

HI!

I was referring to this particular scenario of using this operator.
Constantly writing checks and nullsafes seems like something superfluous.
If we have an opportunity at the language level to throw a domain exception
or something like that, it will be convenient. Besides, it will also be
useful for static analysis. There will be no null pointers in the code.

=D0=BF=D1=82, 7 =D1=84=D0=B5=D0=B2=D1=80. 2025=E2=80=AF=D0=B3. =D0=B2 14:21=
, MrMeshok <ilyaorlov124@gmail.com>:

> >
> > Examples of potentially using in PHP:
> > Without this operator we writing this code:
> >
> > $foo =3D ...
> >
> > if ($foo =3D=3D=3D null) {
> >     throw new FooIsNullException();
> > }
> >
> > $foo->bar.
> >
> > With this operator:
> >
> > $foo!->bar
> > $foo!->someProperty->method();
> > $foo!->someProperty->anotherProperty!->method();
>
> I see where you're coming from, in my code I had to deal with a lot of
> APIs with models which have nullable properties, but they shouldn't be
> null if some conditions are met.
> So I work with them in this way
> ```php
> if ($response->code =3D=3D=3D ResponseCode::Success) {
>     // order and quantity are nullable
>     return $response->data->order->quantity ?? throw new
> UnexpectedResponseException($response);
>
>     // With method calls you would need to add nullsafe operators
>     // order and date are nullable
>     return $response->data->order?->date?->format('Y-m-d') ?? throw
> new UnexpectedResponseException($response);
> }
> ```
> UnexpectedResponseException is just an exception that keeps faulty
> response, so I can catch it and act on it, or it just gets logged and
> I can show producers of API that they have a problem.
>
> I see a point in !-> operator if it would work just like that. Throws
> a specific error that has an object that triggered this error.
>

--0000000000000e1b36062ddd71a2
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><div>HI!<br><br>I was referring to this particular scenari=
o of using this operator. Constantly writing checks and nullsafes seems lik=
e something superfluous. If we have an opportunity at the language level to=
 throw a domain exception or something like that, it will be convenient. Be=
sides, it will also be useful for static analysis. There will be no null po=
inters in the code.<br></div><br><div class=3D"gmail_quote gmail_quote_cont=
ainer"><div dir=3D"ltr" class=3D"gmail_attr">=D0=BF=D1=82, 7 =D1=84=D0=B5=
=D0=B2=D1=80. 2025=E2=80=AF=D0=B3. =D0=B2 14:21, MrMeshok &lt;<a href=3D"ma=
ilto:ilyaorlov124@gmail.com">ilyaorlov124@gmail.com</a>&gt;:<br></div><bloc=
kquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:=
1px solid rgb(204,204,204);padding-left:1ex">&gt;<br>
&gt; Examples of potentially using in PHP:<br>
&gt; Without this operator we writing this code:<br>
&gt;<br>
&gt; $foo =3D ...<br>
&gt;<br>
&gt; if ($foo =3D=3D=3D null) {<br>
&gt;=C2=A0 =C2=A0 =C2=A0throw new FooIsNullException();<br>
&gt; }<br>
&gt;<br>
&gt; $foo-&gt;bar.<br>
&gt;<br>
&gt; With this operator:<br>
&gt;<br>
&gt; $foo!-&gt;bar<br>
&gt; $foo!-&gt;someProperty-&gt;method();<br>
&gt; $foo!-&gt;someProperty-&gt;anotherProperty!-&gt;method();<br>
<br>
I see where you&#39;re coming from, in my code I had to deal with a lot of<=
br>
APIs with models which have nullable properties, but they shouldn&#39;t be<=
br>
null if some conditions are met.<br>
So I work with them in this way<br>
```php<br>
if ($response-&gt;code =3D=3D=3D ResponseCode::Success) {<br>
=C2=A0 =C2=A0 // order and quantity are nullable<br>
=C2=A0 =C2=A0 return $response-&gt;data-&gt;order-&gt;quantity ?? throw new=
<br>
UnexpectedResponseException($response);<br>
<br>
=C2=A0 =C2=A0 // With method calls you would need to add nullsafe operators=
<br>
=C2=A0 =C2=A0 // order and date are nullable<br>
=C2=A0 =C2=A0 return $response-&gt;data-&gt;order?-&gt;date?-&gt;format(=
9;Y-m-d&#39;) ?? throw<br>
new UnexpectedResponseException($response);<br>
}<br>
```<br>
UnexpectedResponseException is just an exception that keeps faulty<br>
response, so I can catch it and act on it, or it just gets logged and<br>
I can show producers of API that they have a problem.<br>
<br>
I see a point in !-&gt; operator if it would work just like that. Throws<br=
>
a specific error that has an object that triggered this error.<br>
</blockquote></div></div>

--0000000000000e1b36062ddd71a2--