Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:126895
Precedence: bulk
MIME-Version: 1.0
References: <CAMW7n8DQqUhnb+U+WcA7bJ-APRDTtzuJC4m8s-q_2LH7bEuH+A@mail.gmail.com>
 <CAMW7n8BTCzYxmOBpjkCW-pis29O=WLhbL-oM1VMo-gDNTm7xeQ@mail.gmail.com> <0A5443F7-6C29-474A-A286-42A76FF9CB33@gmail.com>
In-Reply-To: <0A5443F7-6C29-474A-A286-42A76FF9CB33@gmail.com>
Date: Fri, 21 Mar 2025 13:50:33 +0200
Message-ID: <CAMW7n8Ag=mGk-jHN6z=brcTuMVyzn5Vvjn=LNdbSJSQSqjw+-g@mail.gmail.com>
Subject: Re: [PHP-DEV] PHP True Async RFC - Stage 2
To: Daniil Gentili <daniil.gentili@gmail.com>
Cc: internals@lists.php.net
Content-Type: multipart/alternative; boundary="0000000000005dff6d0630d8dd6d"
From: edmond.ht@gmail.com (Edmond Dantes)

--0000000000005dff6d0630d8dd6d
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

>
>  You already explicitly await all fibers spawned in the generateReport
function, you get all the data you need, any extra spawned fibers should
not interest you for the purpose of the logic of generateReport.
>

In this specific code, it only awaits the tasks it has launched itself.
So, if another function mistakenly starts a coroutine in the current
`Scope`, that coroutine will be cancelled when the scope is destroyed.

On the other hand, code that does `await $scope` assumes that the
programmer *intends* to wait for everything and understands the
implications.
This usually means that the functions being called are part of the same
module and are designed with this in mind.

As for library functions =E2=80=94 **library functions MUST understand what=
 they
are doing**.
If a library function creates resources indiscriminately and doesn=E2=80=99=
t clean
them up, the language cannot be held responsible.
If library functions don=E2=80=99t manage resource ownership properly, the =
language
cannot take responsibility for that either.

>
>  This is because again, the main use case listed of making sure all
fibers are done after a request is a footgun is a non-business-logic
requirement,
> an exercise in functional purity that also reduces caching and
concurrency opportunities, as mentioned before.
>

In this RFC, there is no such primary use case.
There is the `await $scope` construct, but it can no longer be used as the
default.
There used to be a `await currentScope()` construct, which was a footgun =
=E2=80=94
but it will no longer exist.

I also removed `globalScope`, because in 99% of cases it=E2=80=99s an anti-=
pattern
and can be easily replaced with code that creates a coroutine in a separate
`Scope`.
Through writing examples, this became clear.

>
>  A (somewhat bikesheeding, but this has been the vast majority of the
posts on this thread anyway) note is that await could also be made to
accept an iterable of futures, avoiding the use of Async\all combinators.
>

I considered this option =E2=80=94 it looks nice with an array =E2=80=94 bu=
t for some
reason, it's not implemented in any language.

And here's why.

When you allow await to work with an array, it leads to significant
complications.
Because once you support arrays, you naturally want to add more variants,
like:

   - await first
   - await any
   - await ignore
   and so on.

And with additions like await until or await limit, it becomes a very large
and complex statement.

After exploring different options, I also came to the conclusion that using
a function which returns a `Future` from parameters is more flexible and
better than having a multitude of options.

The only unresolved question is until, because it could be convenient.
But it doesn=E2=80=99t exist in any other language.

--0000000000005dff6d0630d8dd6d
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><div dir=3D"ltr">&gt;<br>&gt;=C2=A0

You already explicitly await all fibers spawned in the generateReport funct=
ion, you get all the data you need, any extra spawned fibers should not int=
erest you for the purpose of the logic of generateReport.<br>&gt;</div><div=
 dir=3D"ltr"><br></div><div dir=3D"ltr">In this specific code, it only awai=
ts the tasks it has launched itself. =C2=A0<br>So, if another function mist=
akenly starts a coroutine in the current `Scope`, that coroutine will be ca=
ncelled when the scope is destroyed.<br><br>On the other hand, code that do=
es `await $scope` assumes that the programmer *intends* to wait for everyth=
ing and understands the implications. =C2=A0<br>This usually means that the=
 functions being called are part of the same module and are designed with t=
his in mind.<br><br>As for library functions =E2=80=94 **library functions =
MUST understand what they are doing**. =C2=A0<br>If a library function crea=
tes resources indiscriminately and doesn=E2=80=99t clean them up, the langu=
age cannot be held responsible. =C2=A0<br>If library functions don=E2=80=99=
t manage resource ownership properly, the language cannot take responsibili=
ty for that either.<br></div><div dir=3D"ltr"><br></div><div dir=3D"ltr">&g=
t;=C2=A0<br>&gt;=C2=A0

This is because again, the main use case listed of making sure all fibers a=
re done after a request is a footgun is a non-business-logic requirement, <=
br>&gt; an exercise in functional purity that also reduces caching and conc=
urrency opportunities, as mentioned before.<br>&gt;</div><div dir=3D"ltr"><=
br></div><div dir=3D"ltr">In this RFC, there is no such primary use case. =
=C2=A0<br>There is the `await $scope` construct, but it can no longer be us=
ed as the default. =C2=A0<br>There used to be a `await currentScope()` cons=
truct, which was a footgun =E2=80=94 but it will no longer exist.<br><br>I =
also removed `globalScope`, because in 99% of cases it=E2=80=99s an anti-pa=
ttern and can be easily replaced with code that creates a coroutine in a se=
parate `Scope`. =C2=A0<br>Through writing examples, this became clear.<br><=
br>&gt;<br>&gt;=C2=A0

A (somewhat bikesheeding, but this has been the vast majority of the posts =
on this thread anyway) note is that await could also be made to accept an i=
terable of futures, avoiding the use of Async\all combinators.<br>&gt;</div=
><div dir=3D"ltr"><br></div><div dir=3D"ltr">I considered this option =E2=
=80=94 it looks nice with an array =E2=80=94 but for some reason, it&#39;s =
not implemented in any language.</div><div dir=3D"ltr"><p>
And here&#39;s why.</p>
<p>When you allow <code>await</code> to work with an array, it leads to sig=
nificant complications.<br>
Because once you support arrays, you naturally want to add more variants, l=
ike:</p>
<ul>
<li><code>await first</code></li>
<li><code>await any</code></li>
<li><code>await ignore</code><br>
and so on.</li>
</ul>
<p>And with additions like <code>await until</code> or <code>await limit</c=
ode>, it becomes a very large and complex statement.</p><p>After exploring =
different options, I also came to the conclusion that using a function whic=
h returns a `Future` from parameters is more flexible and better than havin=
g a multitude of options.<br></p><p>The only unresolved question is <code>u=
ntil</code>, because it could be convenient.<br>
But it doesn=E2=80=99t exist in any other language.=C2=A0=C2=A0</p></div></=
div>

--0000000000005dff6d0630d8dd6d--