Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:128886
Precedence: list
MIME-Version: 1.0
References: <CAMW7n8DGbFnQzjt3s9CcOBwhp+MUOV+K3U=yY=ULOTdUXaOLHQ@mail.gmail.com>
 <0e4e39d6-9cc9-4970-92e0-2463143b4011@app.fastmail.com> <CAMW7n8AgHnO0rBjqBkHNhfvV5PBNxwgHBJ762N3FtVxoh5WnOQ@mail.gmail.com>
 <E8D4A549-79EA-48E9-9D20-3608F357F227@trowski.com>
In-Reply-To: <E8D4A549-79EA-48E9-9D20-3608F357F227@trowski.com>
Date: Tue, 21 Oct 2025 20:11:42 +0300
Message-ID: <CAMW7n8D0wMNQE0zuMhbHstyZsDw=e7ryPPZERn11UFV7knmR-g@mail.gmail.com>
Subject: Re: [PHP-DEV] PHP True Async RFC Stage 4
To: Aaron Piotrowski <aaron@trowski.com>
Cc: Rob Landers <rob@bottled.codes>, PHP Internals <internals@lists.php.net>
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
From: edmond.ht@gmail.com (Edmond Dantes)

Hi

> Awaitables should always represent a single value. Awaiting multiple time=
s should never result in a different value.
Where did this rule come from?

In programming languages (except Rust), there is no explicit
restriction on the behavior of the await operation, nor a specific
requirement that it must always return the same value. However, from a
usability perspective, such a rule would make the code simpler. But...

On the other hand, if we restrict the behavior of await, we fail to
cover the full range of possible cases =E2=80=94 and that=E2=80=99s also ba=
d.

> AMPHP has a pipeline library, https://github.com/amphp/pipeline,

That=E2=80=99s not quite the same.
The general case of interacting with Awaitable objects looks like this:

```php

// Waiting for the first event from any object in the set.
// The objects in the set are of different types.
awaitAny(obj1, obj2, obj3); // or All ...

```

But, programming languages don=E2=80=99t always implement this **general
case**, and sometimes even try to avoid it altogether.
And working with a data stream is implemented differently through
`await foreach`.

There is another way to solve this problem (all Futures only) =E2=80=94
through a method that always returns a new Future. For example:
```php
// $queue->whenReady() returns Future object
awaitAll($future, $queue->whenReady());
```
Downside: each time we create a new object in memory, while the loop
still remains.

At the moment, I don=E2=80=99t see any compelling reason to impose artifici=
al
restrictions on behavior.
* Future objects are a special case of Awaitable objects,
* while Awaitable objects represent the general case.

> I think you should consider additional time beyond only two more weeks fo=
r discussion of this RFC before bringing it to a vote.
> PHP 8.6 or 9 is some time away. This is definitely not an RFC to rush to =
voting.

I have no objections.

Thank you, Ed