Re: Examples comparing Block Scoped RAII and Context Managers

Hi On 12/18/25 10:16, Rowan Tommins [IMSoP] wrote:

The point though is that any answer you give is just a design decision you've made; and the exact same decision could be made with more traditional syntax, and apply to the original example.

That is true from a purely technical perspective, since syntax is independent from semantics. But the choice of syntax influences users' expectations with regard to semantics and as I've outlined, we believe that the semantics we've chosen fits PHP best and that the syntax we've chosen hints at the semantics best.

To me the syntax of the let() construct very strongly suggests (3)

I don't really see why. As I said above, the comma-separated list made me think of "simultaneous" action, which I think would imply (1), because accessing a variable "while it's being declared" would make no sense.

Part of it probably is probably a subconscious feeling, but I'll try with an explanation that you may or may not be able to agree with. Existing constructs in PHP that take a list of multiple “items” behave equivalent to consecutive single-item entries. Or in less abstract terms:

    const FOO = 1, BAR = 2;

is equivalent to:

    const FOO = 1;
    const BAR = 2;

So to me it is only natural to extend that logic to the let() construct, which only leaves the let($a) let ($b) desugaring which then implies (3). In fact, the following works:

    const FOO = 1, BAR = FOO + 1;
    var_dump(FOO, BAR);

and defines BAR = 2 and

    const FOO = BAR + 1, BAR = 1;

throws, because BAR is undefined when defining FOO. This is exactly matching the proposed semantics of let().

Option 3 is not necessarily a "wrong" choice, but it's a choice you have made, and you could equally use more traditional syntax and make that same choice.

Yes, but the “more traditional syntax” would also leave the possibility of (1) or (2) - unless restricted to the start of the block as in C90. However it would compose less well with the existing control structures, e.g. by requiring the dedicated syntax for declarations that should live for a single if() construct.

The only thing that using commas automatically does is forbids jump targets (goto labels or switch cases) in between the declarations.

It also forbids nested blocks and any other “arbitrarily complex code” in-between declarations. Yes, I understand that folks can use arbitrary expressions on the right side of the declaration (including assignments), but that is more unlikely compared to a more “free-form” syntax that allows arbitrary statements, including arbitrary control flow. I also believe that the explicit separation of declaration and usage provides for a nice visual barrier of "before declaration, definitely old variable", "after declaration, definitely new variable" and "declaration phase, a small chance of ambiguity when declaring a variable that is used in the declaration of an earlier one". Best regards Tim Düsterhus