Hello.
> I think there's a lot of confusion in this thread because different people are talking
> about different scenarios. Perhaps it would be useful to introduce some User Stories
Yesterday I briefly reviewed the WordPress code to estimate the
refactoring effort.
The amount of global state accessed through global and static is
quite large.
However, it seems technically possible to switch global and static
variables per coroutine.
I’m not sure how this will affect performance (maybe 1–2% on
switches?), but the task looks realistic.
At first I thought this was a bad approach, because if such a feature
were added to PHP,
everyone would start using global as a way to exchange data inside a
coroutine. However, this situation can be viewed from a completely
different perspective:
```php
function myFunction(): void {
global $x;
}
// This code is equivalent to:
function myFunction(): void {
effect ?string $x = null; // <-- function effect, external dependency
}
// This code is equivalent to:
function myFunction(): void in ?string $x {
}
// Then calling the function:
with ($x = "string") {
myFunction();
}
```
In other words, this is a function effect that turns previously
unmanaged and unsafe code into a function with an explicit
external-dependency contract.
And in the future, it could be improved by adding proper effect
support to the language. It turns out that a feature previously seen
as an antipattern can actually be framed as a modern concept from
functional programming.
Of course, these statements need to be validated with code and testing,
and they also require a separate RFC.