Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:129128
Precedence: list
MIME-Version: 1.0
References: <e30d3b54-7e6f-4932-b48a-d97b104da44c@gmail.com>
In-Reply-To: <e30d3b54-7e6f-4932-b48a-d97b104da44c@gmail.com>
Date: Fri, 7 Nov 2025 11:45:10 +0200
Message-ID: <CAMW7n8DSVJ65ZVZgsSkMMY6yiuOh0B_BBFeJ0sfHhSE3D95g-Q@mail.gmail.com>
Subject: Re: [PHP-DEV] Re: PHP True Async RFC Stage 5
To: =?UTF-8?Q?Lu=C3=ADs_Vin=C3=ADcius_Santos_da_Costa_Barros?= <luisvscbarros@gmail.com>
Cc: internals@lists.php.net
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
From: edmond.ht@gmail.com (Edmond Dantes)

Hello, Lu=C3=ADs.

> Maybe keep the base Awaitable internal and expose two userland interfaces=
 that match the two cases described in the RFC:

Yes, that option is possible, but I want to share my current line of thinki=
ng:
1. I=E2=80=99d really like to keep the name `Future` for the `Future` class=
,
which is planned for upcoming RFCs.
2. I have some doubts that the name `Streamable` precisely conveys the
intended meaning (example Signals). However, if our colleagues who are
native English speakers say it=E2=80=99s a good choice, I have no objection=
s.

> Questions (self-cancellation) 1. What happens here?

Here=E2=80=99s what happens:
1. The coroutine continues running successfully until completion.
2. The code that calls `await()` receives a
`CancellationError("Self-cancelled")` exception.

Originally, the idea was to throw an exception directly from
`cancel()`, but that would require adding an extra `try-catch` block.
So I decided to keep it silent instead.

> Can a cancelled coroutine suspend?

Nothing will happen.
When `cancel()` is called, PHP detects that it=E2=80=99s the current corout=
ine
and only sets the exception as its result.
Later, when `suspend()` is invoked, it creates a new waker object that
has no exception, so after resuming, no exception occurs.

Do you think this case should be additionally described in the RFC?
So, that would give developers a better understanding.
Sometimes a coroutine doesn=E2=80=99t cancel itself but its own Scope,
and the developer should understand that if they cancel a Scope that
includes the current coroutine, they need to finish its work properly
from within.

> Which error does await() throw in this case =E2=80=94 CancellationError o=
r RuntimeException?

`RuntimeException`, because this exception will override the previous one.
There is more logic here than described in the RFC, because there is
an =E2=80=9Coverride=E2=80=9D rule.
Exceptions of the `CancellationError` class do not override each
other. The first cancellation reason is always visible.
However, if an unhandled exception of another class occurs, it will
replace the `CancellationError`.

In other words, the logic follows these rules:
1. The first cancellation reason takes precedence over subsequent ones.
2. Unexpected errors take precedence over `CancellationError`.

So, when a developer tries to cancel a coroutine more than once, it
has no effect.

> It=E2=80=99d be great to clarify that in the docs, since it affects where=
 people put cleanup, logging, etc.

This case should be described in more detail in the RFC.
Thank you for noticing it!

> Again, thanks for the work, especially on such an important feature for P=
HP=E2=80=99s future.
Thank you for your excellent feedback, it=E2=80=99s very inspiring.

---
Best Regards, Ed