Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:125427
Feedback-ID: ifab94697:Fastmail
Precedence: bulk
MIME-Version: 1.0
Date: Wed, 04 Sep 2024 22:45:48 +0200
To: "John Bafford" <jbafford@zort.net>
Cc: internals@lists.php.net
Message-ID: <420bb5cb-5fca-4f2e-8c68-0ca327cd3392@app.fastmail.com>
In-Reply-To: <F9C739E2-2FA3-4CAF-9A9B-CE343F84B461@zort.net>
References: 
 <CAPbW5OMLM=0k_WkL1K556O3+cq06X3iQ7OwgPWyjcUzBJ7opRA@mail.gmail.com>
 <27c3909f-05f4-4256-a447-10e8d8760fff@app.fastmail.com>
 <F9C739E2-2FA3-4CAF-9A9B-CE343F84B461@zort.net>
Subject: Re: [PHP-DEV] Local constants
Content-Type: multipart/alternative;
 boundary=a4c48f8a28254d4882bfa26035891a0f
From: rob@bottled.codes ("Rob Landers")

--a4c48f8a28254d4882bfa26035891a0f
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: quoted-printable

On Wed, Sep 4, 2024, at 22:17, John Bafford wrote:
> On Sep 4, 2024, at 15:23, Rob Landers <rob@bottled.codes> wrote:
> >=20
> > On Tue, Sep 3, 2024, at 05:20, HwapX wrote:
> >> Hello internals!
> >>=20
> >> I was wondering, has there been any discussion about supporting loc=
al constants (variables that cannot be reassigned, perhaps even function=
 parameters)?
> >=20
> > Out of curiosity, what value would this bring to PHP? In my experien=
ce, modern php methods and functions tend to fit on a single screen, at =
most being a few hundred lines for complex logic.
> >=20
> > =E2=80=94 Rob
>=20
> This is about semantic clarity. If you define a variable as a constant=
, then, not only do you know for certain that it cannot change, you are =
also stating "it is my intent to not change this variable after setting =
it", and so if someone later tries to do so, they (should) have to answe=
r the question, "*why* do I need to make this variable change?".
>=20
> If it's useful to be able to annotate class members as being "readonly=
", it is likewise useful to do that on a local scope.
>=20
> With sufficient compiler support, *typed* constant variable declaratio=
ns might also allow for this:
>=20
> let SomeType $foo; //or readonly, or writeonce, or whatever
>=20
> if($something) {
> $foo =3D ...;
> } else if($somethingElse) {
> $foo =3D getSomeString(); //Error, type mismatch; possibly catchable a=
t compile time, definitely with static analysis
> } else if($thirdCondition) {
> $foom =3D ...; //oops, typo
> } else {
> throw new Exception(...)
> }
>=20
> doSomething($foo); //Compiler error: $foo not initialized on all call =
paths.
> }
>=20
> You might also tighten scoping with such variables:
>=20
> foreach(...) {
> let $foo =3D //local working variable; possibly even shadowing a varia=
ble in the parent scope
> }
>=20
> //$foo is undefined; you can't access the last-set value from the loop=
 outside of the loop
>=20
> Static analysis can catch all these errors, but it'd be nicer to be ab=
le to do it without requiring docblocks. The language providing tools fo=
r being more explicit about intent in code is never bad.
>=20
> -John

I think, conceptually, this makes sense, but maybe I'm the only one who =
writes

$arr =3D doSomething();
$arr =3D array_map(fn($x) =3D> $x->prop, $arr);
$arr =3D array_filter($arr, $filterFunc);

instead of

$arr =3D array_filter(array_map(fn($x) =3D> $x->prop, doSomething()), $f=
ilterFunc);

And I feel like having constant variables would result in more of the la=
tter, which I feel is more unreadable. Though I do note that my opinion =
of what is readable might be different from other people's.

That being said, I would much rather see block-scoped variables than loc=
al variables via let or var or something:

var $aNumber =3D 12;

foreach($arr as var $item) {
  echo $item; // item exists here
}

echo $item; // item doesn't exist here

PHP is simply too verbose to really benefit from local constants, but wo=
uld benefit from block-scope far more. For example, with local constants=
, you couldn't write that foreach because that variable exists in the sc=
ope of the function and can only be defined once.

=E2=80=94 Rob
--a4c48f8a28254d4882bfa26035891a0f
Content-Type: text/html; charset=utf-8
Content-Transfer-Encoding: quoted-printable

<!DOCTYPE html><html><head><title></title><style type=3D"text/css">p.Mso=
Normal,p.MsoNoSpacing{margin:0}</style></head><body><div>On Wed, Sep 4, =
2024, at 22:17, John Bafford wrote:<br></div><blockquote type=3D"cite" i=
d=3D"qt" style=3D""><div>On Sep 4, 2024, at 15:23, Rob Landers &lt;<a hr=
ef=3D"mailto:rob@bottled.codes">rob@bottled.codes</a>&gt; wrote:<br></di=
v><div>&gt;&nbsp;<br></div><div>&gt; On Tue, Sep 3, 2024, at 05:20, Hwap=
X wrote:<br></div><div>&gt;&gt; Hello internals!<br></div><div>&gt;&gt;&=
nbsp;<br></div><div>&gt;&gt; I was wondering, has there been any discuss=
ion about supporting local constants (variables that cannot be reassigne=
d, perhaps even function parameters)?<br></div><div>&gt;&nbsp;<br></div>=
<div>&gt; Out of curiosity, what value would this bring to PHP? In my ex=
perience, modern php methods and functions tend to fit on a single scree=
n, at most being a few hundred lines for complex logic.<br></div><div>&g=
t;&nbsp;<br></div><div>&gt; =E2=80=94 Rob<br></div><div><br></div><div>T=
his is about semantic clarity. If you define a variable as a constant, t=
hen, not only do you know for certain that it cannot change, you are als=
o stating "it is my intent to not change this variable after setting it"=
, and so if someone later tries to do so, they (should) have to answer t=
he question, "*why* do I need to make this variable change?".<br></div><=
div><br></div><div>If it's useful to be able to annotate class members a=
s being "readonly", it is likewise useful to do that on a local scope.<b=
r></div><div><br></div><div>With sufficient compiler support, *typed* co=
nstant variable declarations might also allow for this:<br></div><div><b=
r></div><div>let SomeType $foo; //or readonly, or writeonce, or whatever=
<br></div><div><br></div><div>if($something) {<br></div><div>$foo =3D ..=
.;<br></div><div>} else if($somethingElse) {<br></div><div>$foo =3D getS=
omeString(); //Error, type mismatch; possibly catchable at compile time,=
 definitely with static analysis<br></div><div>} else if($thirdCondition=
) {<br></div><div>$foom =3D ...; //oops, typo<br></div><div>} else {<br>=
</div><div>throw new Exception(...)<br></div><div>}<br></div><div><br></=
div><div>doSomething($foo); //Compiler error: $foo not initialized on al=
l call paths.<br></div><div>}<br></div><div><br></div><div>You might als=
o tighten scoping with such variables:<br></div><div><br></div><div>fore=
ach(...) {<br></div><div>let $foo =3D //local working variable; possibly=
 even shadowing a variable in the parent scope<br></div><div>}<br></div>=
<div><br></div><div>//$foo is undefined; you can't access the last-set v=
alue from the loop outside of the loop<br></div><div><br></div><div>Stat=
ic analysis can catch all these errors, but it'd be nicer to be able to =
do it without requiring docblocks. The language providing tools for bein=
g more explicit about intent in code is never bad.<br></div><div><br></d=
iv><div>-John<br></div></blockquote><div><br></div><div>I think, concept=
ually, this makes sense, but maybe I'm the only one who writes<br></div>=
<div><br></div><div>$arr =3D doSomething();</div><div>$arr =3D array_map=
(fn($x) =3D&gt; $x-&gt;prop, $arr);<br></div><div>$arr =3D array_filter(=
$arr, $filterFunc);<br></div><div><br></div><div>instead of<br></div><di=
v><br></div><div>$arr =3D array_filter(array_map(fn($x) =3D&gt; $x-&gt;p=
rop, doSomething()), $filterFunc);<br></div><div><br></div><div>And I fe=
el like having constant variables would result in more of the latter, wh=
ich I feel is more unreadable. Though I do note that my opinion of what =
is readable might be different from other people's.<br></div><div><br></=
div><div>That being said, I would much rather see block-scoped variables=
 than local variables via let or var or something:<br></div><div><br></d=
iv><div>var $aNumber =3D 12;</div><div><br></div><div>foreach($arr as va=
r $item) {<br></div><div>&nbsp; echo $item; // item exists here<br></div=
><div>}<br></div><div><br></div><div>echo $item; // item doesn't exist h=
ere<br></div><div><br></div><div>PHP is simply too verbose to really ben=
efit from local constants, but would benefit from block-scope far more. =
For example, with local constants, you couldn't write that foreach becau=
se that variable exists in the scope of the function and can only be def=
ined once.<br></div><div><br></div><div id=3D"sig121229152">=E2=80=94 Ro=
b<br></div></body></html>
--a4c48f8a28254d4882bfa26035891a0f--