>
> You're cheating again - you've put an extra pair of brackets around one
> expression and not the other, and assumed they'll work differently, but
that's
> not the grammar you proposed.
>
Why am I cheating?
> spawn (getClosure());
This is an honest statement, provided that the second parentheses are
optional. The full notation would be:
> spawn (getClosure())();
> Instead you'd have to write this:
> spawn (function() use(): string { return "string"; });
Exactly right, that's how it should be according to PHP syntax.
Therefore, if we want to get rid of double parentheses, we need a separate
rule for closures.
I would name these two cases as follows:
* spawn callable – the general usage case
* spawn closure – the special case for closures
I don't think these two rules make the language inconsistent because the
function keyword allows separating the first expression from the second
one.
spawn function means that a Closure definition follows.
Accordingly, there should be no additional parentheses () at the end.
The reverse meaning is that if spawn is not followed by the function
keyword, then it must be a valid expression that can be enclosed in
parentheses.
There are some doubts about whether all situations are correct, but so far,
this is how it works for me:
- call a standard PHP function
```php
spawn file_get_contents('file1.txt');
```
- call a user-defined function
```php
function example(string $name): void {
echo "Hello, $name!";
}
spawn example('World');
```
- call a static method
```php
spawn Mailer::send($message);
```
- call a method of an object
```php
$object = new Mailer();
spawn $object->send($message);
```
- self, static or parent keyword:
```php
spawn self::send($message);
spawn static::send($message);
spawn parent::send($message);
```
- call $class method
```php
$className = 'Mailer';
spawn $className::send($message);
```
- expression
```php
// Use result of foo()
spawn (foo())();
// Use foo as a closure
spawn (foo(...))();
// Use ternary operator
spawn ($option ? foo() : bar())();
```
- call array dereference
```php
$array = [fn() => sleep(1)];
spawn $array[0]();
```
- new dereference
```php
class Test {
public function wait(): void {
sleep(1);
}
}
spawn new Test->wait();
```
- call dereferenceable scalar:
```php
spawn "sleep"(5);
```
- call short closure
```php
spawn (fn() => sleep(1))();
```
> Sorry, what is exactly what we'd like to avoid?
Syntax ambiguities.
But it seems that avoiding them completely is impossible anyway because
I've already found an old case where a property and a method are used in
the same expression.