Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:126834
Precedence: bulk
MIME-Version: 1.0
References: <CAMW7n8DQqUhnb+U+WcA7bJ-APRDTtzuJC4m8s-q_2LH7bEuH+A@mail.gmail.com>
 <72bd5401-53a9-409f-ad45-687333401961@rwec.co.uk> <CAMW7n8De15X4xDNOBULKeKkpeCeNo-tDWVWZ+Zer8vMa3U-vQg@mail.gmail.com>
 <d50b892b-9372-45c0-81ad-1ce818385b75@rwec.co.uk> <CAMW7n8C16d14earerxvCPe_kyym09GOa8mh4qwPz8AKVKQjHsw@mail.gmail.com>
 <e05cee9d-7901-4b18-b71c-24ad56266534@rwec.co.uk>
In-Reply-To: <e05cee9d-7901-4b18-b71c-24ad56266534@rwec.co.uk>
Date: Wed, 19 Mar 2025 09:07:36 +0200
Message-ID: <CAMW7n8AtLZOof54uJNFG+P4VVwbq65i79x-JDFKPJocDj-w91Q@mail.gmail.com>
Subject: Re: [PHP-DEV] PHP True Async RFC - Stage 2
To: "Rowan Tommins [IMSoP]" <imsop.php@rwec.co.uk>
Cc: internals@lists.php.net
Content-Type: multipart/alternative; boundary="000000000000b9f0c70630acad2f"
From: edmond.ht@gmail.com (Edmond Dantes)

--000000000000b9f0c70630acad2f
Content-Type: text/plain; charset="UTF-8"

Continuing the discussion from [[PHP-DEV] PHP True Async RFC - Stage 2](
https://discourse.thephp.foundation/t/php-dev-php-true-async-rfc-stage-2/1573/24
):

[quote="Rowan_Tommins_IMSoP, post:24, topic:1573"]
I'm still confused why you started talking about how to implement "defer".
Are you saying that "onExit" and "defer" are different things? Or that
giving it dedicated syntax changes the implementation in some fundamental
way?
[/quote]

I meant that the `defer` operator is needed in the language not only in the
context of coroutines but in functions in general. In essence, `defer` is a
shortened version of `try-finally`, which generates more readable code.

Since that's the case, I shouldn't describe this operator in this RFC.
However, `onExit()` and `defer` are essentially almost the same.

[quote="Rowan_Tommins_IMSoP, post:24, topic:1573"]
As with any other callable, it would be called with no arguments. It was
just an illustration, because the function_name(...) syntax is one of many
ways of creating a callable in PHP.
[/quote]

I think I understand your point.
`spawn <callable>`, where `callable` is literally any expression that is
considered callable.
OK. Let's transform that to rules:

The general syntax of the `spawn` operator:

```php
spawn [with <scope>] <callable>[(<parameters>)];
```

**where:**

- **callable** a valid expression whose result can be invoked.

Examples:

```php
spawn "function_name";

// With variable
$callable = fn() => sleep(5);
spawn $callable;

// With array expression
spawn ([$this, "method"]);
// With condition
spawn ($condition ? $fun1 : $fun2);
// As function result
spawn (getClosure());

// Closures:
spawn (function() use(): string { return "string"; });
spawn (fn() => sleep(5));
// with closure expression
spawn (sleep(...))(5);

// Simplified forms
spawn sleep(5);
spawn function() use(): string { return "string"; };
```

- **parameters** a list of parameters that will be passed to the callable
expression.
- **scope** an expression that should resolve to an object of class
`Async\Scope`.

Examples:

```php
spawn with $scope file_get_contents("http://localhost");
spawn with $this->scope file_get_contents("http://localhost");
spawn with $this->getScope() file_get_contents("http://localhost");
spawn with getScope() file_get_contents("http://localhost");
spawn with ($flag ? $scope1 : $scope2) file_get_contents("http://localhost
");
```

As you may have noticed, there is still a special form to avoid using
`"()"`. However, overall, this syntax looks quite cohesive. Did I get the
idea right?

[quote="Rowan_Tommins_IMSoP, post:24, topic:1573"]
The only caveat is that calls using the nullsafe ?-> operator are forbidden
- for reasons directly related to the feature, not because Nikita thought
they were ugly.
[/quote]

Yes, that's exactly what we'd like to avoid.

[quote="Rowan_Tommins_IMSoP, post:24, topic:1573"]
But most likely you'd still want a separate syntax for a direct function
call, however you want to spell it:
[/quote]

**Exactly!** It turns out that the expression `spawn something();`
can be interpreted as if `something` is a PHP constant rather than a
function.

This creates an ambiguous situation in the language:
```php
const MY_CONST = "somefunction";
spawn MY_CONST(); // What happens here??? :)
```

With your help, we seem to have identified all the pitfalls. Now we can put
them together and come up with the best solution.

--000000000000b9f0c70630acad2f
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr">Continuing the discussion from [[PHP-DEV] PHP True Async R=
FC - Stage 2](<a href=3D"https://discourse.thephp.foundation/t/php-dev-php-=
true-async-rfc-stage-2/1573/24">https://discourse.thephp.foundation/t/php-d=
ev-php-true-async-rfc-stage-2/1573/24</a>):<br><br>[quote=3D&quot;Rowan_Tom=
mins_IMSoP, post:24, topic:1573&quot;]<br>I&#39;m still confused why you st=
arted talking about how to implement &quot;defer&quot;. Are you saying that=
 &quot;onExit&quot; and &quot;defer&quot; are different things? Or that giv=
ing it dedicated syntax changes the implementation in some fundamental way?=
<br>[/quote]<br><br>I meant that the `defer` operator is needed in the lang=
uage not only in the context of coroutines but in functions in general. In =
essence, `defer` is a shortened version of `try-finally`, which generates m=
ore readable code. =C2=A0<br><br>Since that&#39;s the case, I shouldn&#39;t=
 describe this operator in this RFC. However, `onExit()` and `defer` are es=
sentially almost the same. =C2=A0<br><br>[quote=3D&quot;Rowan_Tommins_IMSoP=
, post:24, topic:1573&quot;]<br>As with any other callable, it would be cal=
led with no arguments. It was just an illustration, because the function_na=
me(...) syntax is one of many ways of creating a callable in PHP.<br>[/quot=
e]<br><br>I think I understand your point. =C2=A0<br>`spawn &lt;callable&gt=
;`, where `callable` is literally any expression that is considered callabl=
e. =C2=A0<br>OK. Let&#39;s transform that to rules:<br><br>The general synt=
ax of the `spawn` operator:<br><br>```php<br>spawn [with &lt;scope&gt;] &lt=
;callable&gt;[(&lt;parameters&gt;)];<br>```<br><br>**where:**<br><br>- **ca=
llable** a valid expression whose result can be invoked.<br><br>Examples:<b=
r><br>```php<br>spawn &quot;function_name&quot;;<br><br>// With variable<br=
>$callable =3D fn() =3D&gt; sleep(5);<br>spawn $callable;<br><br>// With ar=
ray expression<br>spawn ([$this, &quot;method&quot;]);<br>// With condition=
<br>spawn ($condition ? $fun1 : $fun2);<br>// As function result<br>spawn (=
getClosure());<br><br>// Closures:<br>spawn (function() use(): string { ret=
urn &quot;string&quot;; });<br>spawn (fn() =3D&gt; sleep(5));<br>// with cl=
osure expression<br>spawn (sleep(...))(5);<br><br>// Simplified forms<br>sp=
awn sleep(5);<br>spawn function() use(): string { return &quot;string&quot;=
; };<br>```<br><br>- **parameters** a list of parameters that will be passe=
d to the callable expression.<br>- **scope** an expression that should reso=
lve to an object of class `Async\Scope`.<br><br>Examples:<br><br>```php<br>=
spawn with $scope file_get_contents(&quot;<a href=3D"http://localhost">http=
://localhost</a>&quot;);<br>spawn with $this-&gt;scope file_get_contents(&q=
uot;<a href=3D"http://localhost">http://localhost</a>&quot;);<br>spawn with=
 $this-&gt;getScope() file_get_contents(&quot;<a href=3D"http://localhost">=
http://localhost</a>&quot;);<br>spawn with getScope() file_get_contents(&qu=
ot;<a href=3D"http://localhost">http://localhost</a>&quot;);<br>spawn with =
($flag ? $scope1 : $scope2) file_get_contents(&quot;<a href=3D"http://local=
host">http://localhost</a>&quot;);<br>```<br><br>As you may have noticed, t=
here is still a special form to avoid using `&quot;()&quot;`. However, over=
all, this syntax looks quite cohesive. Did I get the idea right?<br><br>[qu=
ote=3D&quot;Rowan_Tommins_IMSoP, post:24, topic:1573&quot;]<br>The only cav=
eat is that calls using the nullsafe ?-&gt; operator are forbidden - for re=
asons directly related to the feature, not because Nikita thought they were=
 ugly.<br>[/quote]<br><br>Yes, that&#39;s exactly what we&#39;d like to avo=
id.<br><br>[quote=3D&quot;Rowan_Tommins_IMSoP, post:24, topic:1573&quot;]<b=
r>But most likely you&#39;d still want a separate syntax for a direct funct=
ion call, however you want to spell it:<br>[/quote]<br><br>**Exactly!** It =
turns out that the expression `spawn something();` =C2=A0<br>can be interpr=
eted as if `something` is a PHP constant rather than a function. =C2=A0<br>=
<br>This creates an ambiguous situation in the language: =C2=A0<br>```php<b=
r>const MY_CONST =3D &quot;somefunction&quot;;<br>spawn MY_CONST(); // What=
 happens here??? :)<br>```<br><br>With your help, we seem to have identifie=
d all the pitfalls. Now we can put them together and come up with the best =
solution.</div>

--000000000000b9f0c70630acad2f--