Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:114492
To: internals@lists.php.net
References: <f3d20496-c560-42b7-9a0d-8672b3cafa7d@www.fastmail.com>
Message-ID: <2d7fb03a-addb-f22b-e3fd-957f758569f9@gmail.com>
Date: Mon, 17 May 2021 09:28:09 +0100
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
 Thunderbird/78.10.1
MIME-Version: 1.0
In-Reply-To: <f3d20496-c560-42b7-9a0d-8672b3cafa7d@www.fastmail.com>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 7bit
Content-Language: en-GB
Subject: Re: [PHP-DEV] [RFC] Partial function application
From: rowan.collins@gmail.com (Rowan Tommins)

On 25/04/2021 20:25, Larry Garfield wrote:
> Greetings, Internalians!
>
> I would like to offer for your consideration another RFC, specifically syntax for partial function application.
>
> https://wiki.php.net/rfc/partial_function_application


During off-list discussions, it's become clear that there are two 
different ways of modelling what this feature does, which is leading to 
a bit of misunderstanding and frustration (and some plain disagreement 
on which is the *better* model). At risk of getting it wrong and 
confusing things more, I'd like to attempt to describe the two models.


The first model is that a partial application starts with an empty 
signature, and adds arguments to it based on placeholders. You could 
picture the steps like this:

function foo(int $a, int $b, int $c) { /* whatever */ }
$partial = foo(?, ?, 42);
Step 1 - empty closure: $partial = fn() => foo();
Step 2 - 1st argument is a ? so copy that parameter from the original: 
$partial = fn(int $a) => foo($a);
Step 3 - 2nd argument is a ? so copy from the original: $partial = 
fn(int $a, int $b) => foo($a, $b);
Step 4 - 3rd argument is a fixed value, so don't add to signature, only 
to the call: fn(int $a, int $b) => foo($a, $b, 42);


The second model is that a partial application starts with a *complete* 
signature, and splices in the *fixed* values. The steps go more like this:

function foo(int $a, int $b, int $c) { /* whatever */ }
$partial = foo(?, ?, 42);
Step 1 - copy original signature: $partial = fn(int $a, int $b, int $c) 
=> foo($a, $b, $c);
Step 2 - 1st argument is a ? so skip over it
Step 3 - 2nd argument is a ? so skip over it
Step 4 - 3rd argument is a fixed value, so splice a value into the 
signature at that location: $partial = fn(int $a, int $b, 42) => foo($a, 
$b, 42);
Step 5 - fixed values don't actually belong on the left-hand side: 
$partial = fn(int $a, int $b) => foo($a, $b, 42);


For simple examples like the above, the two models are essentially 
equivalent, but they lead to different expectations for some features; 
for instance, trailing arguments and placeholders:

- In the model where you're building from empty, writing foo(42, ?, ?) 
to mean "copy exactly two arguments" feels natural. To say "copy all 
arguments", or "copy all remaining arguments", you'd then need a 
different syntax, like foo(42, ...) or foo(42, ??). In this model, the 
trailing "?" in the current proposal is magic: it changes from meaning 
"copy exactly one argument" to "copy all remaining arguments".

- In the model where you're splicing arguments into a full signature, 
foo(42, ?, ?) is pointless: the action is to splice in the 42, then 
"skip over" two arguments; but nothing happens *after* skipping over 
them, so you could just not mention them. No extra token is needed to 
copy all remaining arguments, because that already happened at the 
start. The only reason to use a trailing "?" at all is because foo(42) 
would just be a normal function call, and adding a redundant "skip over" 
marker in foo(42, ?) tells the compiler it's a partial.


Regards,

-- 
Rowan Tommins
[IMSoP]