Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:126585
Precedence: bulk
MIME-Version: 1.0
References: <CAMW7n8AJckEDzhGv9BdjNhq8zAdCqb4HsVr56vGi+izw50X6Dg@mail.gmail.com>
 <9964db8c-0ffe-43d5-8246-47fc76b07180@app.fastmail.com> <CAMW7n8CM7oBfXCDsKtV4hTFs40UmLCU3183WjYE2exLNqKDWLQ@mail.gmail.com>
 <78a03dd0-fd4a-4f4a-ad8a-37e5704f06fc@app.fastmail.com>
In-Reply-To: <78a03dd0-fd4a-4f4a-ad8a-37e5704f06fc@app.fastmail.com>
Date: Wed, 5 Mar 2025 23:10:15 +0200
Message-ID: <CAMW7n8C-Z18MKhyDX2+ofg70cRbwWOk=YWDAZpKtfLZsFVVRng@mail.gmail.com>
Subject: Re: [PHP-DEV] PHP True Async RFC
To: Larry Garfield <larry@garfieldtech.com>
Cc: php internals <internals@lists.php.net>
Content-Type: multipart/alternative; boundary="0000000000007c0d4b062f9ed1cc"
From: edmond.ht@gmail.com (Edmond Dantes)

--0000000000007c0d4b062f9ed1cc
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

>
>  Thinking aloud, perhaps we could cause `new Fiber` to create an
automatic async block?
>

The main issue with Fibers is their switching logic:
If you create Fiber A and call another Fiber B inside it, Fiber B can only
return to the Fiber that created it, not just anywhere. However, the
Scheduler requires entirely different behavior.

This creates a conflict with the Scheduler. Moreover, it can even break the
Scheduler if it operates based on Fibers. That's why all these strange
solutions in the RFC are just workarounds to somehow bypass this problem.
But it seems we've already found an alternative solution.

> I cannot speak for Derick.

Of course, I just mean that he probably won't be happy about it :)

> No, just those functions/objects that necessarily involve running async
control commands.  Most wouldn't.
> They would just silently context switch when they hit an IO operation
(which as noted above is transparency supported, which is what makes this
> work) and otherwise behave the same.

So it's something more like Go or Python.

>
>  $val =3D async(function(AsyncContext $ctx) use ($stuff, $fn) {
>  $result =3D [];
>  foreach ($stuff as $item) {
>   $result[] =3D $ctx->run($fn);
>}
>
>  // We block/wait here until all subtasks are complete, then the async()
call returns this value.
>  return $result;
> });

Do I understand correctly that at the point $val =3D
async(function(AsyncContext $ctx) use ($stuff, $fn) execution stops until
everything inside is completed?

If so, let me introduce a second semantic option (for now, I'll remove the
context and focus only on the function).

```php
$url1 =3D 'https://domain1.com/';
$url2 =3D 'https://domain2.com/';

$url_handle =3D fn(string $url) =3D> file_get_contents($url);

$res =3D Async\start(function() use ($url1, $url2, $url_handle) {
    $res1 =3D Async\run($url_handle, $url1);
    $res2 =3D Async\run($url_handle, $url2);

    Async\run(fn() =3D> sleep(5));

    // some logic here

    return $merged_result;
});
```
What's Happening Here:

   1. After calling $res =3D Async\start(), the code waits until the entire
   block completes.
   2. Inside Async\start, the code waits for all nested coroutines to
   finish.
   3. If a coroutine has other nested coroutines, the same rule applies.

Rules Inside an Asynchronous Block:

   1. I/O functions do not block coroutines within the block.
   2. Creating a new Fiber is not allowed =E2=80=94 an exception will be th=
rown:
   you cannot use Fiber.
   3. Unhandled exceptions will be thrown at the point of $res =3D
   Async\start().

Coroutine Cancellation Rules:

Canceling a coroutine cancels it and all its child coroutines (this cannot
be bypassed unless the coroutine is created in a different context).

How does this option sound to you?

Essentially, this is Kotlin, but it should also resemble Python. However,
unlike Kotlin, there are no special language constructs here=E2=80=94code b=
locks
naturally serve that role. Of course, syntactic sugar can be added later
for better readability.

And if you like this, I have good news: there are no implementation issues
at this level.

In terms of semantic elegance, the only thing that bothers me is that retur=
n
behavior is slightly altered =E2=80=94 meaning the actual "return" won=E2=
=80=99t happen
until all child functions complete. This isn=E2=80=99t very good, and Kotli=
n=E2=80=99s
style would fit better here.

But on the other hand =E2=80=94 can we live with this?

> I cannot speak to JS Symbols as I haven't used them.
> I am just vhemently opposed to globals, no matter how many layers they're
wrapped in. :-)  Most uses could be replaced by proper DI or partial
application.

You won=E2=80=99t be able to use DI because you have only *one service (ins=
tance of
class)* for the entire application, not a separate service for each
coroutine. This service is shared across the application and can be called
from any coroutine. As a result, the service needs memory slots to store or
retrieve data. DI is a mechanism used once during service initialization,
not every time a method is called.

The only question is whether to use open text keys in the context, which is
unsafe and can lead to collisions, or to use a unique key-object that is
known only to the one who created it. (If PHP introduces object constants,
this syntax would also look elegant.)

There is, of course, another approach: making Context any arbitrary object
defined by the user. But this solution has a known downside =E2=80=94 lack =
of a
standard interface.

> (Or even just $ch->inPipe and $ch->outPipe, now that we have nice
property support.)

Just a brilliant idea. :)

Have a good day!

Ed.

--0000000000007c0d4b062f9ed1cc
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr">&gt;=C2=A0<br>&gt;=C2=A0

Thinking aloud, perhaps we could cause `new Fiber` to create an automatic a=
sync block?<br>&gt;<br><br><p>The main issue with Fibers is their switching=
 logic:<br>If you create Fiber A and call another Fiber B inside it, Fiber =
B can only return to the Fiber that created it, not just anywhere. However,=
 the Scheduler requires entirely different behavior.</p><p>This creates a c=
onflict with the Scheduler. Moreover, it can even break the Scheduler if it=
 operates based on Fibers. That&#39;s why all these strange solutions in th=
e RFC are just workarounds to somehow bypass this problem. But it seems we&=
#39;ve already found an alternative solution.</p><p>&gt; I cannot speak for=
 Derick.<br><br>

Of course, I just mean that he probably won&#39;t be happy about it :)=C2=
=A0</p><p>&gt; No, just those functions/objects that necessarily involve ru=
nning async control commands.=C2=A0 Most wouldn&#39;t.=C2=A0 <br>&gt; They =
would just silently context switch when they hit an IO operation (which as =
noted above is transparency supported, which is what makes this <br>&gt; wo=
rk) and otherwise behave the same.=C2=A0<br><br>So it&#39;s something more =
like Go or Python.</p><p>&gt;<br>&gt;=C2=A0

$val =3D async(function(AsyncContext $ctx) use ($stuff, $fn) {<br>&gt;=C2=
=A0 $result =3D [];<br>&gt;=C2=A0 foreach ($stuff as $item) {<br>&gt;=C2=A0=
 =C2=A0$result[] =3D $ctx-&gt;run($fn);<br>&gt;}<br>&gt;<br>&gt;=C2=A0 // W=
e block/wait here until all subtasks are complete, then the async() call re=
turns this value.<br>&gt;=C2=A0 return $result;<br>&gt; });<br><br>Do I und=
erstand correctly that at the point <code>$val =3D async(function(AsyncCont=
ext $ctx) use ($stuff, $fn)</code> execution stops until everything inside =
is completed?</p><p>If so, let me introduce a second semantic option (for n=
ow, I&#39;ll remove the context and focus only on the function).=C2=A0=C2=
=A0</p><p>```php<br>$url1 =3D &#39;<a href=3D"https://domain1.com/">https:/=
/domain1.com/</a>&#39;;<br>$url2 =3D &#39;<a href=3D"https://domain2.com/">=
https://domain2.com/</a>&#39;;<br><br>$url_handle =3D fn(string $url) =3D&g=
t; file_get_contents($url);<br><br>$res =3D Async\start(function() use ($ur=
l1, $url2, $url_handle) {<br>=C2=A0 =C2=A0 $res1 =3D Async\run($url_handle,=
 $url1);<br>=C2=A0 =C2=A0 $res2 =3D Async\run($url_handle, $url2);<br><br>=
=C2=A0 =C2=A0 Async\run(fn() =3D&gt; sleep(5));<br><br>=C2=A0 =C2=A0 // som=
e logic here<br><br>=C2=A0 =C2=A0 return $merged_result;<br>});<br>```<br><=
/p><h3>What&#39;s Happening Here:</h3><ol><li>After calling <code>$res =3D =
Async\start()</code>, the code waits until the entire block completes.</li>=
<li>Inside <code>Async\start</code>, the code waits for all nested coroutin=
es to finish.</li><li>If a coroutine has other nested coroutines, the same =
rule applies.</li></ol><h3>Rules Inside an Asynchronous Block:</h3><ol><li>=
I/O functions do not block coroutines within the block.</li><li>Creating a =
new <code>Fiber</code> is not allowed =E2=80=94 an exception will be thrown=
: you cannot use <code>Fiber</code>.</li><li>Unhandled exceptions will be t=
hrown at the point of <code>$res =3D Async\start()</code>.</li></ol><h3>Cor=
outine Cancellation Rules:</h3><p>Canceling a coroutine cancels it and all =
its child coroutines (this cannot be bypassed unless the coroutine is creat=
ed in a different context).</p><p>How does this option sound to you?</p><p>=
Essentially, this is Kotlin, but it should also resemble Python. However, u=
nlike Kotlin, there are no special language constructs here=E2=80=94code bl=
ocks naturally serve that role. Of course, syntactic sugar can be added lat=
er for better readability.=C2=A0=C2=A0</p><p>And if you like this, I have g=
ood news: there are no implementation issues at this level.</p><p>In terms =
of semantic elegance, the only thing that bothers me is that <code>return</=
code> behavior is slightly altered =E2=80=94 meaning the actual &quot;retur=
n&quot; won=E2=80=99t happen until all child functions complete. This isn=
=E2=80=99t very good, and Kotlin=E2=80=99s style would fit better here.</p>=
<p>But on the other hand =E2=80=94 can we live with this?</p><p>&gt; I cann=
ot speak to JS Symbols as I haven&#39;t used them.=C2=A0 <br>&gt; I am just=
 vhemently opposed to globals, no matter how many layers they&#39;re wrappe=
d in. :-)=C2=A0 Most uses could be replaced by proper DI or partial applica=
tion.</p><p>You won=E2=80=99t be able to use DI because you have only <b>on=
e service (instance of class)</b>=C2=A0for the entire application, not a se=
parate service for each coroutine. This service is shared across the applic=
ation and can be called from any coroutine. As a result, the service needs =
memory slots to store or retrieve data. DI is a mechanism used once during =
service initialization, not every time a method is called.</p><p>The only q=
uestion is whether to use open text keys in the context, which is unsafe an=
d can lead to collisions, or to use a unique key-object that is known only =
to the one who created it. (If PHP introduces object constants, this syntax=
 would also look elegant.)</p><p>There is, of course, another approach: mak=
ing <code>Context</code> any arbitrary object defined by the user. But this=
 solution has a known downside =E2=80=94 lack of a standard interface.</p><=
p>&gt; (Or even just $ch-&gt;inPipe and $ch-&gt;outPipe, now that we have n=
ice property support.)</p><p>Just a brilliant idea. :)</p><p>Have a good da=
y!</p><p>Ed.=C2=A0=C2=A0</p></div>

--0000000000007c0d4b062f9ed1cc--