Re: Examples comparing Block Scoped RAII and Context Managers

On 15/01/2026 09:03, Tim Düsterhus wrote:

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).

There's a jump here. In a grouped "const", "global", or "static" statement, the expansion is to a *series of statements* with a common prefix. In your proposed syntax, the expansion is to a *nested set of blocks*. That makes the semantics more complicated, and in my opinion more surprising... Rather than "const", a better example is probably "static", where this is legal:

$bar = 42;
static $foo=$bar + 1, $bar = 1;
echo "$foo,$bar";

It desugars to a series of separate statements:

$bar = 42;
static $foo=$bar + 1;
static $bar = 1;
echo "$foo,$bar";

The static $bar silently shadows the local one, and you get an output of 43,1 Interestingly, this is *not* legal PHP:

static $foo=$bar + 1, $bar = 1, $foo = -1;

"Fatal error: Duplicate declaration of static variable $foo" Note that these are two largely arbitrary design decisions: - A static variable with the same name as a local one shadows the previous variable, with no hoisting or dead zone - A static variable with the same name as an existing static variable is forbidden

This is exactly matching the proposed semantics of let().

Not quite. It works for this:

$bar = 42;
let($foo=$bar + 1, $bar = 1) {
    echo "$foo,$bar";
}

The block-scoped $bar shadows the function-local $bar, and the output is 43,1 just like with "static". But what if we declare the same variable twice:

$bar = 42;
let($foo=$bar + 1, $bar = 1, $foo=-1) {
    echo "$foo,$bar";
}

My intuition from "static", and from every other language I've used, is that this would be an Error: there's a single block, and you're trying to declare two different local variables called "$foo" inside that block. Instead, what happens is that the second declaration of $foo shadows the first. The justification is that this is not actually one block at all, it's secretly a whole set of nested blocks:

$bar = 42;
{
    let($foo=$bar + 1) {
        let($bar = 1) {
            let($foo=-1) {
                echo "$foo,$bar";
           }
       }
   }
}

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.

I suspect this is where we've been talking past each other a bit: looking at the syntax, I interpreted the comma-separated list as defining a set of variables in the same scope. That leaves all the same options as the "traditional" syntax: $bar = 42; let($foo=$bar+1, $bar=1) {

    echo $foo;

} - You could treat $bar as "hoisted" within the let() construct, giving $foo==2 - You could treat $bar as creating a Dead Zone within the let() construct, giving an Error - You could treat the declarations as sequential, and shadow the value, giving $foo==43 What I completely missed, and seemed obvious to you, is that there are actually two separate scopes being declared, nested inside each other. (Even so, there is another possibility: variable shadowing could be forbidden, as in C#, making the "$bar=1" declaration an error). So I guess it all comes down to the same thing: the syntax just doesn't seem intuitive to me, because I keep expecting it to behave like JS, C, Java, Perl, etc. I can't get past the fact that copying from one of those languages would be so much more obvious. -- Rowan Tommins [IMSoP]