Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:114487
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: <912F2203-FCEF-441E-9272-65624F4C0FDB@gmail.com>
Date: Sun, 16 May 2021 09:46:22 -0400
Cc: internals@lists.php.net
Content-Transfer-Encoding: quoted-printable
Message-ID: <F5A02A0E-F15C-4443-A3B1-E6E06B9051C0@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>
 <912F2203-FCEF-441E-9272-65624F4C0FDB@gmail.com>
To: Rowan Tommins <rowan.collins@gmail.com>
Subject: Re: [PHP-DEV] [RFC] Partial function application
From: mike@newclarity.net (Mike Schinkel)


> On May 15, 2021, at 4:20 AM, Rowan Tommins <rowan.collins@gmail.com> =
wrote:
>=20
> On 15 May 2021 00:09:41 BST, Paul Crovella <paul.crovella@gmail.com> =
wrote:
>> I think this highlights where the misunderstanding of this feature =
is.
>=20
>=20
> I think the fact that there is so much confusion highlights why it is =
worth considering different designs.

Exactly this.

I have been debating whether to comment on this thread, but seeing =
Rowen's comments mean I am not alone in my opinion so here goes.

I too have been bothered with the inconsistent usage of the single =
question mark ('?').  While it makes perfect sense once it is explained, =
it is possibly not intuitive for those who have learned how to use a =
command line shell where a single question mark indicates a single =
"thing" (where "thing" is a single character in the shell.) =20

Using it in PHP to mean "one, or more" seems like it would cause =
needless confusion given that intuition derived from command line =
experience might lead developers to be confused.  Better to use =
something which would not be likely to lead developers astray I would =
think.

>=20
>> Partial application is about binding arguments. ? isn't an argument,
>> it's an argument placeholder. It does two things: signals to create a
>> closure wrapping the function rather than calling it immediately, and
>> holds a position in the argument list so that an argument further to
>> the right can be fixed (bound) at that time.
>=20
>=20
> This is not a correct description of the current syntax. Currently, =
"?" represents a *required* argument in the argument list, but *only* if =
there is a fixed value to its right. If it appears at the end of the =
argument list, or with only other ? tokens to its right, it *only* =
signals that a partial should be created, and doesn't create a required =
argument, even though it looks the same.
>=20
> foo(?, 42) creates a closure with one required argument; foo(42, ?) =
creates a closure with no required arguments
>=20
>> Requiring additional trailing argument placeholders or adding an
>> additional token `...?` unnecessarily complicates things, burdens the
>> user, and only serves to further promote misunderstanding.
>=20
>=20
> On the contrary, saying that "?" always means exactly one argument =
massively simplifies the description of the feature. Why persist with a =
version of the syntax that is so easy to misunderstand when we have a =
really simple fix available?
>=20
> I acknowledge the need for a syntax to say "accept zero or more =
further arguments", but this doesn't need to overload the syntax for =
"create a required argument here".
>=20
> If the suggestion of ...? is too long, we could look at other options =
like ... or ?? The syntax for "just make a closure and pass all =
arguments through" would then be "foo(...)" or "foo(??)".

Yes! =20

Since we need a sigil to indicate a function be wrapped in a closure I =
was actually planning to propose `??` so I was pleasantly surprised to =
see Rowan's suggestion.  Ellipses would work too, but as I think `??` =
would be easier to see in dense code, so I would prefer them.

Which gives us::

function foo($a,$b,$c) {}

$x =3D foo(??);				// Wrap foo() in a closure which =
expects 3 parameters
$x =3D foo(?, 24);			// Wrap foo() in a closure which =
expects 2 parameters with `24` binding to `$b`
$x =3D foo(?, 24, ??);			// Same as foo(?, 24);


> There is a *separate* question of whether arguments that weren't =
*required* are passed along anyway. I'm less sure there's a right answer =
there, and would be happy with a version where foo(?, 42) and foo(?, 42, =
...) were equivalent - that is, the trailing "all other arguments" token =
would only be needed if there wasn't already a placeholder.

Ditto, but with `??` preferred.

Said another way, I am arguing exactly what Rowan arged except that I =
have a preference for one sigil over the other.

>=20
-Mike