Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:88516
Mailing-List: contact internals-help@lists.php.net; run by ezmlm
Received-SPF: pass (pb1.pair.com: domain gmail.com designates 209.85.212.170 as permitted sender)
To: internals@lists.php.net
References: <CAFMT4NrOsRm_6Qb11cbtsq0H-_OYugu-u-3Q+EC9J3Ze9BNAYg@mail.gmail.com>
Message-ID: <5606D0EB.3060106@gmail.com>
Date: Sat, 26 Sep 2015 18:07:55 +0100
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:38.0) Gecko/20100101
 Thunderbird/38.2.0
MIME-Version: 1.0
In-Reply-To: <CAFMT4NrOsRm_6Qb11cbtsq0H-_OYugu-u-3Q+EC9J3Ze9BNAYg@mail.gmail.com>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 7bit
Subject: Re: [PHP-DEV] Arrow function expressions in PHP
From: rowan.collins@gmail.com (Rowan Collins)

On 26/09/2015 17:17, Levi Morrison wrote:
> What concerns do you have about `fn($x) => $x * 2` or `function($x) =>
> $x * 2`? I will be writing a proper RFC later but I wanted to get
> discussion going now.

If a keyword is required next to the parameters, having the => as a 
separate token looks a bit weird. It no longer matches other languages, 
so how about thinking a bit further outside the box?

One of the random thoughts that popped into my head during the previous 
discussion was to base the syntax on the C for-loop, which would also 
give a place for bound variables without the "use" keyword. e.g. your 
example could become fn($x;; $x * 2)

I picked "lambda" as the keyword before, and gave these examples:

# lambda(params; bound vars; expression)
$double = lambda($a;; 2*$a)
$x=3; $triple = lambda($a; $x; $x * $a)

function sumEventScores($events, $scores) {
     $types = array_map(lambda($event;; $event['type']), $events);
     return array_reduce($types, lambda($sum, $type; $scores; $sum + 
$scores[$type]));
}


Adding in the type information, we'd get this:

lambda(int $sum, string $type; $scores; $sum + $scores[$type])
# or with fn() if you prefer:
fn(int $sum, string $type; $scores; $sum + $scores[$type])


If return typehints are also required, I'm not sure where they'd best be 
placed. If they're outside the parens, they end up after the expression, 
which might look odd:
fn(int $sum, string $type; $scores; $sum + $scores[$type]): int

A few other possibilities:
fn(int $sum, string $type; $scores; $sum + $scores[$type]; int)
fn(int $sum, string $type: int; $scores; $sum + $scores[$type])
fn:int(int $sum, string $type; $scores; $sum + $scores[$type])


All of this assumes that the shorthand is only available for simple 
expressions, not function bodies, but it seems a bit rendundant to allow 
both of these:
function($x) { foo(); bar(); baz(); }
fn($x) => { foo(); bar(); baz(); }

And only marginally more useful if variables are auto-captured, with all 
the downsides of that which have already been raised:
function($x) use ($y) { foo($x); bar($x, $y); }
fn($x) => { foo($x); bar($x, $y); }

Regards,

-- 
Rowan Collins
[IMSoP]