Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:108528
Content-Type: text/plain;
	charset=utf-8
Mime-Version: 1.0 (Mac OS X Mail 12.4 \(3445.104.11\))
In-Reply-To: <ebc970d9-8c70-9563-1792-fd8c7ef67f2f@gmail.com>
Date: Wed, 12 Feb 2020 22:33:32 -0500
Cc: internals@lists.php.net
Content-Transfer-Encoding: quoted-printable
Message-ID: <DE2D0FCB-4C39-43F4-B6B6-B5796271EB0E@newclarity.net>
References: <CAD5P3=JwFK03L-DWJYaa0dbBj1chbef_=K-vyawLNeoAz7dHjA@mail.gmail.com>
 <CALSrLtYm+TSEwo+05JC6LXrQsfzb32pQ24Y7gDUmm-7+NwYi8w@mail.gmail.com>
 <CAOWwgpm43=hoCvsskq2qyhB3yVxntLAYC8hQjQwd9dnvQ=GKkg@mail.gmail.com>
 <CAD5P3=L8bQ4bp5i5f=SdOP-=Wmn6TSj6+4Jzw76WRwJ=89evtw@mail.gmail.com>
 <CAF+90c-myY2NeKcaTRH3zDcwxRC95RhKnm1MPTGN68WUq4RPAA@mail.gmail.com>
 <CAPKYkKy-NwDmpN_5Zet8Oz9JLVzu11PmODP6byBYuJry3TUvbg@mail.gmail.com>
 <CE981907-0CDD-421F-BC01-1B3F0E95B199@newclarity.net>
 <ebc970d9-8c70-9563-1792-fd8c7ef67f2f@gmail.com>
To: Rowan Tommins <rowan.collins@gmail.com>
Subject: Re: [PHP-DEV] [RFC]
From: mike@newclarity.net (Mike Schinkel)

> On Feb 12, 2020, at 5:47 PM, Rowan Tommins <rowan.collins@gmail.com> =
wrote:
>=20
> On 12/02/2020 03:58, Mike Schinkel wrote:
>> Returning a_closure_  instead of a string would be providing a =
feature we_already_  have instead of one we do_not_  have.
>=20
>=20
> Not really, because you still need a way to get the fully-qualified =
name of the function. This is not valid:
>=20
> namespace MyVendor\Something\Foo;
> function bar() {}
>=20
> \Closure::fromCallable('bar'); # Error: tries to resolve function =
'\bar'
>=20

Why would ::function return a short name instead of the fully-qualified =
name?=20

::function should return the fully-qualified name as does ::class.  Then =
the concern you state becomes a non-issue.

If ::function returns a fully qualified name developers can always use =
string functions to get the short name if they need it.

> So if we had ::function which returned the name, and ::callable that =
returned a closure, the following would be equivalent:
>=20
> namespace MyVendor\Something\Foo;
> function bar() {}
>=20
> \Closure::fromCallable('MyVendor\Something\Foo\bar');
> \Closure::fromCallable(bar::function);
> bar::callable;
>=20
> One combination would be ::function returning a string, and $() =
accepting one, which would give:
>=20
> $(bar::function)
>=20
> In practice, that would almost certainly be optimised into one =
instruction, so the main advantage would be consistency, unless there =
are use cases where a string rather than "any callable" is actually =
required.

Yes.


>> Or today just use fn() =3D> myfunc().
>=20
>=20
> That's not quite the same either: at the very least, you need to =
define it as fn(...$args) =3D> myfunc(...$args) to pass through the =
parameters.

Assuming there are parameters.

> But Closure::callable is able to copy the signature of the original =
function, including type information [1], so our hypothetical ::callable =
could do the same.

True.

-------

As an aside, I wish we had a new simpler form of metadata object that =
could provide the features of reflection quicker and easier and one that =
didn't need to be wrapped in a try{}catch{}.  Something like this:

- https://gist.github.com/mikeschinkel/78684d708358e1d101e319c7a2fdef9c

But this being PHP =E2=80=94 with its love of verbosity and complexity =
when adding classes, and disdain for adding something if a capability =
already exists, no matter how cumbersome it is =E2=80=94 chances of this =
becoming a thing is pretty much moot.  So I am just pontificating.

-Mike=