Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:120089
MIME-Version: 1.0
References: <6b5de716-d769-4f0b-b3e6-5a5a211f035a@app.fastmail.com>
In-Reply-To: <6b5de716-d769-4f0b-b3e6-5a5a211f035a@app.fastmail.com>
Date: Thu, 20 Apr 2023 22:26:30 +0200
Message-ID: <CABdc3Wow2WsYwHSbpxPh+Dc+duzPAE2MvuNAEKEDgpYJoedg2Q@mail.gmail.com>
To: Larry Garfield <larry@garfieldtech.com>
Cc: php internals <internals@lists.php.net>
Content-Type: multipart/alternative; boundary="000000000000bba25105f9ca5b52"
Subject: Re: [PHP-DEV] [Discussion] Callable types via Interfaces
From: michal.brzuchalski@gmail.com (=?UTF-8?Q?Micha=C5=82_Marcin_Brzuchalski?=)

--000000000000bba25105f9ca5b52
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

Hi

> There is one loophole, in that an interface may require an __invoke()
> method:
>
> interface TwoInts
> {
>     public function __invoke(int $a, int $b): int;
> }
>
>
I was playing around with the code and parser for this in 2020 but my idea
was to introduce a new syntax that is inspired by C# - Delegates [1]

delegate Reducer (?int $sum, int $item =3D 0): int;

class Foo implements Reducer {
    public function __invoke(?int $sum, int $item =3D 0): int { }
}
function reduce(Reducer $reducer) {
    var_dump($reducer(0, 5));
}
reduce(new Foo());
reduce(fn(?int $sum, int $item =3D 0): int =3D> 8);

At the same time, I assumed structural typing for closures would be used.
I assumed the delegate will resolve into
interface Reducer {
    public function __invoke(?int $sum, int $item =3D 0): int {}
}

I also noticed that once checked closure doesn't have to be checked against
the argument types and return type because it won't change which gives some
possibility to cache this type check.


> The usual discussion has involved a way to specify a callable type's
> signature, like so:
>
> function takeTwo(callable(int $a, int $b): int $c)
> {
>   return $c(1, 2);
> }
>
> But that runs quickly into the problem of verbosity, reusability, and typ=
e
> aliases, and the discussion usually dies there.
>
>
This is why initially I thought about Delegates as in C# there are not type
aliases.
The delegate essentially resolves to an interface with `__invoke(?int $sum,
int $item =3D 0): int` method.


> ### Structural typing for closures
>
> The third option would necessitate having similar logic in the engine to
> the first.  In this case, we take a "structural typing" approach to
> closures; that is, "if the types match at runtime, it must be OK."  This =
is
> probably closest to the earlier proposals for a `callable(int $x, int $y)=
:
> int` syntax (which would by necessity have to be structural), but
> essentially uses interfaces as the type alias.
>
> function takeTwo(TwoInts $c): int
> {
>     return $c(1, 2);
> }
>
> $result =3D takeTwo(fn(int $x, int $y): int =3D> $x + $y);
>

I'd love to see this happening.

[1]
https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/delegates=
/

Cheers,
Micha=C5=82 Marcin Brzuchalski

--000000000000bba25105f9ca5b52--