Brainstorming idea: inline syntax for lexical (captured) variables

Hey Rowan

Hi all,

I have been pondering for a while how to improve the anonymous class
syntax to allow "capturing" of values from the outer scope, and came up
with the idea of a special variable marker for "lexically captured
variable" - instead of $foo, you would write $!foo or $^foo (I quite
like the "upwardness" of $^).

To give a simple example, values can only pass into the anonymous class
via its constructor, like this:

function foo(int $outer) {
return new class($outer) {
public function __construct(
private int $myProp
) {}
public function getIt() {
return $this->myProp;
}
};
}

The idea is that you would instead be able to reference an outer
variable directly anywhere in the declaration, removing a lot of
boilerplate:

function foo(int $outer) {
return new class {
public function getIt() {
return $^outer;
}
};
}

One thing to note is that, as I've learned recently, anonymous classes
can actually be instantiated at a later point with some tricks.

https://3v4l.org/2OcmP

This could be avoided by adding the value to the constructor, but that
fully defeats the purpose of your proposal. Holding the value
indefinitely would create a leak and also doesn't really work as
createAnonymousClass could be called multiple times and thus
capturing multiple $values. We could also decide to disallow
instantiations of anonymous classes in other places, that would
probably make most sense. This way the captured value could be
attached somewhere in the object and $^foo could access that instead.

That being said, I am indeed very skeptical if the added complexity is worth it.

// Lexical values could be used to initialse private, protected, or
public properties
// The same lexical value can be used any number of times
$x = 1;
$example = new class {
    private $x = $^x;
    protected $sharedX = $^x;
    public $alsoX = $^x;
}

This could also prove technically challenging. Currently, property
defaults are constant ASTs and unique per class (not object). For your
case, they would need to be different per instance, which might
require quite a bit of refactoring.

As for the syntax in closures, that seems a bit more useful to me
personally, although I dislike the multi-nesting. Moving code, it
might be easy to miss that the number of "^" needs adjustments. I'd
personally prefer the previously proposed approach of capturing just
by name. Good naming should minimize the risk of clashing variables.

Regards,
Ilija

Hi all,

I have been pondering for a while how to improve the anonymous class
syntax to allow "capturing" of values from the outer scope, and came up
with the idea of a special variable marker for "lexically captured
variable" - instead of $foo, you would write $!foo or $^foo (I quite
like the "upwardness" of $^).

To give a simple example, values can only pass into the anonymous class
via its constructor, like this:

function foo(int $outer) {
    return new class($outer) {
        public function __construct(
            private int $myProp
        ) {}
        public function getIt() {
            return $this->myProp;
        }
    };
}

The idea is that you would instead be able to reference an outer
variable directly anywhere in the declaration, removing a lot of
boilerplate:

function foo(int $outer) {
    return new class {
        public function getIt() {
            return $^outer;
        }
    };
}

The outer variable would be captured by value, and carried around with
the instance, like existing closures.

I suggest it is also treated as readonly, and visible strictly in the
lexical definition, not generally in private scope (it couldn't be
referenced from an applied trait, for instance).

Using it to initialise a property or local variable would allow you to
give it an explicit scope, while still avoiding the constructor:

function foo(int $outer) {
    private $inner = $!outer;
    return new class {
        public function getIt() {
            $this->inner++;
            return $this->inner;
        }
    };
}

It then occurred to me that the same syntax could be used in
multi-statement anonymous functions instead of an explicit use()
statement. This strikes a different balance between conciseness and
explicitness than full automatic capture:

$before = function($x) use ($y, $z) {
    $a = $x * $y;
    return do_something($a, $z);
}
$after = function($x) {
    $a = $x * $^y;
    return do_something($a, $^z);
}

To keep this message short, I've put some more examples and thoughts
into a GitHub Gist here:
https://gist.github.com/IMSoP/4157af05c79b3df4c4853f5a58766341

I'd be interested to hear anyone's thoughts - is this a promising idea
to explore, or have I gone completely off the rails?

Pourque no los dos?

Ilija's point about implementation challenges concerns me, but my initial thought is that I quite like it. I've run into the same issue with capturing into anon classes and wished for something like this.

As you were describing it, I was also thinking of the potential implications for closures, too. That sounds... kinda fun. :-) However, I agree with Ilija that the original proposal to just do it automatically would be better; and if that didn't pass, I have no expectation that an alternate with a funky new syntax would do any better.

The other concern is that this introduces a whole new realm of possible behaviors; like, what does $^foo mean in a non-anon-class context? Does it? Could it be made to mean something in the future? Does it become an alternate syntax for global? What else could we do with it? This rabbit hole goes very deep very quickly, and pursuing this for anon classes without considering the longer-term implications seems both impossible (because people will ask) and unwise.

--Larry Garfield

Hi Rowan,

I have been pondering for a while how to improve the anonymous class

syntax to allow "capturing" of values from the outer scope, and came up
with the idea of a special variable marker for "lexically captured
variable" - instead of $foo, you would write $!foo or $^foo (I quite
like the "upwardness" of $^).

To overcome the issues spotted in the thread, what about doing some sort of
CPP instead of autocapture?

new class (...$arguments) use ($outer) extends Foo {
public function getIt() {
return $this->outer;
}
}

This would be the equivalent of this:

new class ($outer, ...$arguments) extends Foo {
public function __construct(public mixed $outer, ...$arguments) {
parent::__construct(...$arguments);
}
public function getIt() {
return $this->outer;
}
}

And we could also allow this for better type expressivity:
new class (...$arguments) use (private int $outer) extends Foo {
// ...
}

Nicolas