Continuing the discussion from [[PHP-DEV] PHP True Async RFC - Stage 2](
https://discourse.thephp.foundation/t/php-dev-php-true-async-rfc-stage-2/1573/16
):
[quote="Crell, post:16, topic:1573"]
// Creates an async scope, in which you can create coroutines.
[/quote]
Yes, I understand what this is about.
Here’s a more specific example: launching two coroutines and waiting for
both.
```php
$scope = new Scope();
$scope->spawn(fn() => ...);
$scope->spawn(fn() => ...);
await $scope;
```
The downside of this code is that the programmer might forget to write
await $scope.
Additionally, they constantly need to write $scope->.
This code can be replaced with syntactic sugar:
```
async {
spawn ...
spawn ...
};
```
Am I understanding this correctly? Does it look nice? I think yes.
And at the same time, if the closing bracket is missing, the compiler will
throw an error, meaning you can't forget to await.
That is the only advantage of this approach.
Now, let's talk about the downsides.
```
function task(): void {
spawn function() {
echo "What?";
};
async {
spawn ...
spawn ...
};
}
```
Let me explain.
You can write the spawn operator **outside** the async block. Why?
Because **nothing** can prevent you from doing so. It’s simply impossible.
After all, the function might already be executing inside another async
block outside its scope.
That’s exactly what happens an async block is essentially always present
as soon as index.php starts running.
It is necessary to determine whether this syntax truly provides enough
benefits compared to the direct implementation.
I will think about it.