Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:109035
Date: Sun, 15 Mar 2020 14:28:32 -0400
To: tyson andre <tysonandre775@hotmail.com>
Cc: Internals <internals@lists.php.net>
Message-ID: <fb548f2a-0f0d-4dbe-8b69-b4c94501ecc4@Mikes-iPad-Pro>
In-Reply-To: <DM5PR07MB3067D2DEAD4B3C85FBDFD559F9F80@DM5PR07MB3067.namprd07.prod.outlook.com>
MIME-Version: 1.0
Content-Type: multipart/alternative; boundary="5e6e73d0_66334873_12dfd"
Subject: Re: [PHP-DEV] RFC idea: Block scoped variables with "let $x
 =?utf-8?Q?=3D_?= expr"
From: mike@newclarity.net (Mike Schinkel)
References: <DM5PR07MB3067D2DEAD4B3C85FBDFD559F9F80@DM5PR07MB3067.namprd07.prod.outlook.com>

--5e6e73d0_66334873_12dfd
Content-Type: text/plain; charset="utf-8"
Content-Transfer-Encoding: quoted-printable
Content-Disposition: inline

     =20
 =20

 Hi Tyson,
 =20

 =20
Normally I would be one to advocate for new features, but in the case I a=
m against the proposed feature.
 =20

 =20
I know it is a feature from Javascript, but I think it is maybe the natur=
e of Javascript prototypes   makes it more useful though I am not sure as=
 I do   not specialize in   JS.    OTOH   the nature of PHP coding minimi=
zes the need.
 =20

 =20
More specifically regarding PHP, the purpose of your proposed   feature a=
ppears   to be to allow   longer and more complex functions and methods a=
nd more deep nesting. However, I think we should not be encouraging peopl=
e to write longer and more functions and methods and nest more deeply. An=
d I have unfortunately have had to refactor too   many   long and complex=
 functions and methods and deep nesting written by others that I   active=
ly   want   try to discourage such approaches to coding, in PHP at least.=

 =20

 =20
What I would rather see are new features in PHP that encourage developer =
to break functionality into shorter   and simpler functions and methods, =
and to minimize nesting.
 =20

 =20
The Software Engineering StackExchange seems to share my view:
 =20

 =20
https://softwareengineering.stackexchange.com/a/200712/9114
 =20

 =20
There is also an issue with block scoping that is reasonably well-known a=
mong the GoLang community called   variable shadowning   and that is a de=
veloper seeming a variable in block scoping and thinking they are accessi=
ng or assigning the function-scoped variable.  =20
 =20

 =20
In GoLang it is more of a problem because of lack of explicit declaration=
 required for variable shadowing =E2=80=94 and the language designers hav=
e lamented that they wish they never included block scoping =E2=80=94 but=
 even though the original PHP developer might not get confused as they wo=
uld be writing the =60let's declaration another developer trying to maint=
ain the code could easily introduce errors in the code if they don't noti=
ce the block declaration.
 =20

 =20

 =20
 =20
https://rpeshkov.net/blog/golang-variable-shadowing/   (https://rpeshkov.=
net/blog/golang-variable-shadowing/)
 =20

 =20
=46or these reasons   I would definitely not want to see block-scoping of=
 variables in PHP.   =20
 =20

 =20
=23jmtcw
 =20
=23fwiw  =20
 =20

 =20
-Mike
 =20
P.S. If you really   need   block scope within a long function or method =
  you can already create a closure and call it in the same expression:
 =20
 =20

 =20
function =46oo()=7B
 =20
 =20
> =24var =3D =22I am a function scoped var=21=5Cn=22;
 =20
>  =20
> (function()=7B
>  =20
 =20
>  =20
> >  =20
> > =24var =3D =22I am a block-scoped var=21=5Cn=22;
> >  =20
> > echo =24var;
> >  =20
>  =20
 =20
>  =20
> =7D)();
>  =20
> echo =24var;
>  =20
 =20
=7D
 =20

 =20
// Prints:
 =20
// I am a block-scoped var=21
 =20
// I am a function scoped var=21
 =20
=46oo();   =20
 =20

 =20

 =20
>  =20
> On Mar 15, 2020 at 12:47 PM,  <tyson andre (mailto:tysonandre775=40hotm=
ail.com)>  wrote:
>  =20
>  =20
>  =20
>  Hi internals, In PHP, variables are currently scoped to the function s=
cope, and can't be scoped to a block scope. This makes it difficult to re=
ason about how a variable will actually be used at a glance, especially i=
n long functions, or top-level statement lists of a file. (or how the var=
iable was originally intended to be used) The function scope lifetime of =
variables in PHP is similar to how JavaScript treated variables with =60v=
ar=60, before the introduction of the =60let=60 statement in JS: https://=
developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let =
Would there be any interest in adding something similar to this in PHP=3F=
 (Or have similar ideas been proposed in the past=3F I didn't see any.) C=
orrectness would be enforced as a best-effort at compile-time - the varia=
bles would continue to only be freed at the end of the function call. (e.=
g. =5F=5Fdestruct() only gets called when the variable gets reassigned or=
 the function call ends) - =46reeing it immediately would likely require =
the equivalent of a try=7B=7D finally=7B=7D to handle exceptions. try sta=
tements prevent opcache from optimizing a function, the last time I check=
ed. =60=60=60 =7B let =24myObject =3D new MyClass(), =24flag =3D true; =24=
myObject->process(=24flag); =7D // Accessing or setting =24myObject or =24=
flag outside a different let is an E=5FCOMPILE=5FERROR // because it was =
declared anywhere else in the function body // as a let statement =24myOb=
ject->doSomething(); // E=5FCOMPILE=5FERROR to access =24key or =24value =
after, outside of a separate =60let=60 scope foreach (=24arr as let =24ke=
y =3D>  let =24value) =7B // It would be a compile error to declare a got=
oLabel: inside of a scope of a let statement. =7D // E=5FCOMPILE=5FERROR =
to access =24key or =24value after echo =24=24var; // E=5FCOMPILE=5FERROR=
 to use variable variables in the same scope, to enforce this as much as =
possible. =7B let =24outer =3D 1; =7B let =24outer =3D 2; // E=5FCOMPILE=5F=
ERROR to declare in a different scope, can only reassign =24outer =3D 3; =
// this is allowed =7D =7D =7B let =24myRef =3D&=24other; =7D =7B let =24=
myRef =3D true; // This removes myRef from the reference group before ass=
igning a new value to myRef - =24other is unmodified. =7D =60=60=60 I say=
 =22best-effort=22 because require() and =24GLOBALS and get=5Fdefined=5Fv=
ariables() can still read or modify or make references to variables outsi=
de of a =60let=60, depending on what's in the function body or top-level =
statements. - Tyson -- PHP Internals - PHP Runtime Development Mailing Li=
st To unsubscribe, visit: http://www.php.net/unsub.php =20
>
>  =20
 =20
 =20
     
--5e6e73d0_66334873_12dfd--