Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:114491
Content-Type: text/plain;
	charset=us-ascii
Mime-Version: 1.0 (Mac OS X Mail 13.4 \(3608.120.23.2.6\))
In-Reply-To: <CAEMvS4F+AbxPJQ5ctLONptECvmkdrzT42oU4rDOjtD2dC_jEJw@mail.gmail.com>
Date: Mon, 17 May 2021 00:58:39 -0400
Cc: php internals <internals@lists.php.net>
Content-Transfer-Encoding: quoted-printable
Message-ID: <09B663C3-E21D-432B-BB7F-78312F827C30@newclarity.net>
References: <f3d20496-c560-42b7-9a0d-8672b3cafa7d@www.fastmail.com>
 <1565EB81-57B7-49B0-A47C-342E0088A432@trowski.com>
 <CAN2symhHys1uADWnOfraEA3SiM8_57=JttWhgOJ0Kh7nwt4R+g@mail.gmail.com>
 <CAEMvS4FbtPqdeySsVWm=Gub1BNiv+OCiB2oGL-+aZvBH7hmisA@mail.gmail.com>
 <CAEMvS4F+AbxPJQ5ctLONptECvmkdrzT42oU4rDOjtD2dC_jEJw@mail.gmail.com>
To: Hossein Baghayi <hossein.baghayi@gmail.com>
Subject: Re: [PHP-DEV] [RFC] Partial function application
From: mike@newclarity.net (Mike Schinkel)


> On May 16, 2021, at 10:43 PM, Hossein Baghayi =
<hossein.baghayi@gmail.com> wrote:
>=20
> On Sat, 15 May 2021 at 09:03, Hossein Baghayi =
<hossein.baghayi@gmail.com>
> wrote:
>=20
>> Providing ? as a means of placeholder for some arguments and ignoring =
the
>> rest could complicate the readability in my opinion.
>> Maybe we should move (?) out of the arguments list as a means of =
creating
>> a partial.
>>=20
>> What I realized is that we need a way of signaling partial function
>> creation. Be it foo(?) or foo(?, ?, ?) or however many ? is added =
there,
>> which does not convey any meaning and also doesn't produce any sort =
of
>> error!
>>=20
>> Say instead of foo(?) we had ?foo().
>> Since we have named parameters it could help us in providing some of =
the
>> arguments and deferring the rest.
>>=20
>> For instance:
>> ```
>> function foo($x, $y, ...$z) {}
>>=20
>> ?foo(); // causes a partial
>> ?foo(y: '..'); // also causes a partial
>> ```
>>=20
>> This way we wouldn't need to worry about the number of ? added to
>> arguments list.
>> It may also help in avoiding future PSRs in telling us how many ? we
>> should put in there :)
>>=20
>=20
> In addition to these, I was thinking of 2 other cases in which =
changing the
> current proposal might be helpful.
>=20
> 1- When there is a parameterless function (an expensive operation =
maybe).
> 2- When all parameters are passed but the function is not expected to =
be
> called yet.
>=20
> In the case of a parameterless function, maybe it is an expensive =
function
> call and we need to defer calling it.
> Maybe all we need is to hold a reference to it and pass it around?
> With the current proposal, I do not know if it is possible or not. =
Since
> there are no parameters defined.
> ```
> function with_expensive_operations_lurking_inside() {...}
> ````
> Can we or should we call this function this way:
> ```
> $ref =3D with_expensive_operations_lurking_inside(?);
> ```
> It feels odd having to provide parameters when there is none needed.
>=20
>=20
> For the other use case where all parameters are passed but is not =
expected
> to be called yet:
> Maybe providing parameters and setting it up is not our =
responsibility.
> ```
> function expensive_or_not($a, $b, $c) {...}
> $do_not_get_called_please =3D expensive_or_not(1, 2, 3, ?); // with an =
extra
> parameter as to mark as partial!
> $do_not_get_called_please =3D expensive_or_not(?, 1, 2, 3); // or =
maybe this
> way?!
> ```
>=20
> Well, I was thinking that by changing the proposed syntax we could =
achieve
> what is proposed and a little bit more.
> Also we wouldn't need to worry about the number of ? needed as =
arguments.
> Since all we need is to mark the return type as partial (closure) on =
the
> fly and grab hold of what is passed as arguments.
>=20
> There are some different syntaxes that come to my mind:
> We could still use ? but outside of the arguments list?
> ```
> $partial =3D xyx?(..);
> $partial =3D ?xyx(..);
> ```
> or maybe different symbols:
> ```
> $partial =3D :xyz(..);
> ```
>=20
> We might be able to even cast the return type:
> ```
> $partial =3D (?) xyz(..);
> $partial =3D (partial) xyz(..);
> $partial =3D (fn) xyz(..);
> ```

Casting is another interesting approach that does feel more consistent =
with the existing language. =20

Since it *is* creating a closure, wouldn't this make the most sense?

$partial =3D (closure) abc();
$partial =3D (closure) xyz(?,24);

-Mike