Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:129621
Feedback-ID: i8414410d:Fastmail
Precedence: list
MIME-Version: 1.0
Date: Tue, 16 Dec 2025 09:59:06 -0600
To: "php internals" <internals@lists.php.net>
Message-ID: <cf0dc177-cce8-4703-9195-b91408ba694c@app.fastmail.com>
In-Reply-To: 
 <CADK1yXJUt3OLExBT5462mHu_vaxyRuUTKcVYF_kbwY04_y8TJA@mail.gmail.com>
References: 
 <CAJp_myV9+kxx-eA+cja-Fu5dJhDZgzhgpBpiZFWqqW-_zrNreQ@mail.gmail.com>
 <70A79513-5503-467E-BC6F-2B0494A3EBB9@benramsey.com>
 <CADK1yXJgPsZJ5+qepDotrMMtRm8TtG95wS7UNpvd8D=Pm-+BOQ@mail.gmail.com>
 <D8927CEA-3D00-4ECF-807B-7C2C96C5B582@rwec.co.uk>
 <CADK1yXJUt3OLExBT5462mHu_vaxyRuUTKcVYF_kbwY04_y8TJA@mail.gmail.com>
Subject: Re: [PHP-DEV] [RFC] Context Managers
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: quoted-printable
From: larry@garfieldtech.com ("Larry Garfield")

On Tue, Dec 16, 2025, at 5:25 AM, Deleu wrote:
> On Tue, Dec 16, 2025 at 5:10=E2=80=AFAM Rowan Tommins [IMSoP]=20
> <imsop.php@rwec.co.uk> wrote:
>> (Replying to a few of you in one go, I hope the formatting is clear)=20
>>=20
>> >>> we have changed the RFC to use =3D> instead.  So the new syntax is
>> >>>
>> >>> using (new CM() =3D> $cVar) {
>> >>>   // Do stuff here.
>> >>> }
>> >>>
>> >>
>> >> Going to be controversial here, but this is confusing, because it =
operates
>> >> in the exact opposite of every other usage of =3D> we have.=20
>> >
>> > I agree with Matthew.
>> >
>> > I think it makes more sense to reverse them, like this:
>> >
>> >     using ($cVar =3D> new CM()) {
>> >         // Do stuff here.
>> >     }
>>=20
>>=20
>> It took me a long time to figure out what you were both saying here, =
because to me the direction of the arrow seems to consistently indicate =
data flow: you call the function, and data comes out; you enter the cont=
ext, and a variable comes out.
>>=20
>> But I think I see it now: you're treating the context variable like a=
n array key, that is somehow "bound to" the result. Except that's not wh=
at's happening, otherwise we could just use "=3D".
>>=20
>>=20
>> >I also agree with Matthew but the reversed proposed here looks very =
very
>> >awkward to me. I think the most natural thing is the =E2=80=9Cas=E2=80=
=9D but I may have
>> >missed the discussion on why it had to be changed.
>> >
>> >Thinking of foreach ($array as $value), an item from the array (left=
) is
>> >assigned to $value (right).
>>=20
>>=20
>> This is the way to read the "as" syntax, yes; as I've said in a few p=
laces, a Context Manager is like an iterator that goes around once.
>>=20
>>=20
>> > That seems symmetrical to using (new Manager as
>> >$manager) where the instance (left) is assigned to the variable (rig=
ht).
>>=20
>>=20
>> This, however, is why it was changed: that is *not* what is happening=
. The Context Manager is not assigned to the variable, it *produces a va=
lue* which is assigned to the variable.=20
>>=20
>> Again, look at the foreach equivalence: you wouldn't write "foreach(n=
ew MyIterator as $iterator)", because it's not the iterator that ends up=
 in the variable, it's the *items produced by* the iterator.=20
>>=20
>> So you have "foreach(new MyIterator as $item)" and "using(new MyConte=
xtManager as $contextVar)".=20
>>=20
>> But evidently that is not obvious to readers.
>
> My conclusion here is exactly the opposite of yours because this=20
> explanation makes `as` even more symmetrical now. As you've mentioned=20
> `foreach(new MyIterator as $iterator)` is not how it works. An iterato=
r=20
> *produces a value* that is assigned to the variable after `as`.=20
> Symmetrically, `using(new ContextManager as $context)` the=20
> ContextManager is also producing a value that is assigned to the=20
> variable after `as`. The only difference is in the keyword: foreach=20
> will loop, but using will not loop since ContextManager is not an=20
> iterator.
>
> I'm assuming this would also be a valid syntax: `using ($manager =3D n=
ew=20
> ContextManager as $context)` which gives us a shot at capturing the=20
> context manager.
>
> I wrote a little snippet to try and see (using GitHub Gist Syntax=20
> Highlighter) how some of the options would look like once IDE support =
/=20
> syntax highlighting is baked in:
>
> image.png
>
> Ultimately, people will take a quick reading in a Context Manager=20
> documentation and the parallels to explain how it works seems to be=20
> very well in place for `as`, imo.
>
> In the image above I tried adding `for using` because I was trying=20
> really hard to come up with a word that could replace `each` in=20
> `foreach` to make it even more symmetrical, but I could not find=20
> anything decent.
>
> - `for context(new ContextManager as $context)`=20
> This one reads well, but the fact its two words (and a long word for=20
> that matter) doesn't sit well.
>
> - `for with(new ContextManager as $context)`
> I'm not a native English speaker, but I think this doesn't read at all
>
> - `for one(new ContextManager as $context)`
> Kind of implies it works with iterators (similar to each), which is no=
t=20
> exactly the case and the language has very little motivation to create=20
> an iterator that loops only once just to make this work.
>
> - `for using(new ContextManager as $context)`
> Similar thoughts as `for context`, the only difference that makes me=20
> like this one more is because `for context` doesn't sit well with `try=20
> context` while `for using` could go well with `try using`.
>
> In any case, the longer I sit with this the more I dislike `=3D>` for =
this.=20
>
> In an array, `=3D>` is an assignment of key/value pairs.=20
> For foreach ($iterator as $key =3D> $value), the =3D> is a destructing=20
> instruction that aligns with how the array was originally assigned.
> For the arrow function, it's kind of implied in the name ARROW functio=
n=20
> that we would need a syntax in the lines of `fn () =3D>`. I don't thin=
k=20
> this relates well with arrays, but it works well to me because of how=20
> universal arrow functions are in Javascript.=20
> For match ($value), it reads as `WHEN ($value) MATCH '' THEN. The arro=
w=20
> here `=3D>` is the THEN.
>
> My conclusion is that `=3D>` is either a value placement (for arrays) =
or=20
> an instruction execution (for arrow function and match). As such, If =3D=
>=20
> were to be incorporated into Context Managers, I think it would make=20
> much more sense like this:
>
> `using (new ContextManager as $context) =3D> [single line expression]`=20
> where the arrow creates a symmetry with how arrow functions work.
>
>
> --=20
> Marco Deleu

First, yeesh, where were y'all 2 weeks ago? :-P

Second, I find it fascinating that there's so many different mutually-in=
compatible spins on what =3D> means.  As argued in the short-functions a=
nd auto-capture-closure RFCs from a few years ago, =3D> in nearly all ca=
ses currently means "evaluates to."

$arr =3D [
  'a' =3D> 'A",
  'b' =3D> 'B',
];

$arr['a'] // This "evaluates to" A

match ($foo) {
  'a' =3D> 'A',
  'b' =3D> 'B', // The 'b' case "evaluates to" B
};

fn($foo) =3D> 'bar'; // This function "evaluates to" bar

foreach ($arr as $k =3D> $v) {}

The last is a little bit inconsistent, but can still be read as "$k, and=
 the thing that $k evaluates to."

So given that, and as Rowan noted the context manager is *NOT* the conte=
xt variable:

using ($cm evaluates to $cv) {}

That's the meaning we're going for.

If there's some better word than =3D>, we're still open to it, but I am =
going to insist on left-to-right reading.  $cm is created first, then it=
 produces $cv.

'as' is what we had originally, since that's what Python used.  However,=
 it was pointed out that it was confusing as it implied the CM and CV we=
re the same thing, or rather the expression on the left gets assigned to=
 $cv, which is not the case.  Hence the change.

A symbol does have the (dis?)advantage of a somewhat squishier meaning t=
han a keyword.

--Larry Garfield