Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:108514
MIME-Version: 1.0
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> <CA+kxMuTgqjs-=rBA+_fwFQDxZD5uv+dnSShri-NS=Mq-spB1kw@mail.gmail.com>
In-Reply-To: <CA+kxMuTgqjs-=rBA+_fwFQDxZD5uv+dnSShri-NS=Mq-spB1kw@mail.gmail.com>
Date: Wed, 12 Feb 2020 19:40:40 +0100
Message-ID: <CAD5P3=Kbc-LTXiAmpGtM871MrXJjQsPVfsb5n1ZWMEFPtp3YEg@mail.gmail.com>
To: Dan Ackroyd <Danack@basereality.com>
Cc: Nikita Popov <nikita.ppv@gmail.com>, Nicolas Grekas <nicolas.grekas+php@gmail.com>, 
	Diogo Galvao <diogo86@gmail.com>, PHP Internals List <internals@lists.php.net>
Content-Type: multipart/alternative; boundary="000000000000e1b426059e654f46"
Subject: Re: [PHP-DEV] [RFC]
From: manuelcanga@gmail.com (Manuel Canga)

--000000000000e1b426059e654f46
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

On Wed, 12 Feb 2020 at 15:08, Dan Ackroyd <Danack@basereality.com> wrote:

> On Tue, 11 Feb 2020 at 13:19, Nikita Popov <nikita.ppv@gmail.com> wrote:
> >
> > https://wiki.php.net/rfc/consistent_callables.
> >
>
> btw it's probably worth mentioning the other reason I didn't pursue
> https://wiki.php.net/rfc/consistent_callables.
>
> By itself, the callable type isn't much use. It only allows you to
> specify that a type can be called, but it doesn't allow you to specify
> what parameters the callable should take, or what the return type
> should be.
>
> Just making the callable type be consistent would be a lot of work,
> and possibly cause a lot of BC breaks and still not do the useful
> thing.
>
> Instead what would be far more useful would be allow people to define
> the callable signature, and use that as a type.
>
> callable some_callback(int $x, string $y) : int;
>
> function bar(some_callback $fn) {  }
>
> $fn_correct =3D function (int $x, string $y) : int {}
> $fn_wrong =3D function (int $x, string $y) : int {}
>
> Calling bar with $fn_correct should work.
> Calling bar with $fn_wrong should give a type error.
>
> In my opinion, pursuing that idea would be a lot more valuable than
> breaking BC for callables without much gain.
>
> cheers
> Dan
> Ack
>


Hi, internals,

I think, we are taking this very far. In Spain, we usually say: "Quien
mucho abarca, poco aprieta". In English, I think is similar to: "don=E2=80=
=99t bite
off more than you can chew" or KISS/YAGNI in development. IMO, we should
limit RFC to '::function'( scope and accept/reject ). After this, other RFC
can be added/checked like Short closures( of Michal ) or other purposes
with other variation like :interface and ::trait: ( of  Mike )

Respect to ::function:

<function_name>::function,  it should return a string like ::class. This is=
:

Case 1: <function_name>::function =3D=3D=3D \namespace\function_name ( when
function_name is imported )
Case 2: <function_name>::function =3D=3D=3D \current_namespace\function_nam=
e(
when <function_name>::function is below a namespace )
Case 3: <function_name>::function =3D=3D=3D \function_name( when
<function_name>::function is not below a namespace )
Case 4: \namespace\<function_name>::function =3D=3D=3D \namespace\function_=
name
Case 5: \<function_name>::function =3D=3D=3D \function_name ( equal of 4 bu=
t in
global context )

Examples:

1.
namespace my_project;
use function \vendor\I18n\translate;

$mapped_array =3D array_map(translate::function, $array);
//=3D $mapped_array =3D array_map('\vendor\I18n\translate', $array);

2.
namespace my_project;

$mapped_array =3D array_map(translate::function, $array);
//=3D $mapped_array =3D array_map('\my_project\translate' $array);

3.
$mapped_array =3D array_map(translate::function, $array);
//=3D $mapped_array =3D array_map('\translate' $array);

4.
$mapped_array =3D array_map(\vendor\I18n\translate::function, $array);
//=3D $mapped_array =3D array_map('\vendor\I18n\translate' $array);

5.
$mapped_array =3D array_map(\translate::function, $array);
//=3D $mapped_array =3D array_map('\translate' $array);

Although, cases 3, 4 or 5, can appear useless, however editors could
distinguish
when is a function( and not a ordinary string ) and validate if function
exists or not.

Regards

--000000000000e1b426059e654f46--