Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:88612
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: Nikita Nefedov <inefedor@gmail.com>, internals@lists.php.net
References: <CAFMT4NrOsRm_6Qb11cbtsq0H-_OYugu-u-3Q+EC9J3Ze9BNAYg@mail.gmail.com>
 <5606D0EB.3060106@gmail.com>
 <CAEYWF=7-=ToVrBK7y1NcOtSU9iB5BpK=3iuyX-5i3GkGvMow-A@mail.gmail.com>
 <CAFMT4NqA-ZrhUuGmhiCyzVAwd0s=ecQ3fz5EkhXv2F_q-w5h+g@mail.gmail.com>
 <560D0F94.8060009@gmail.com> <op.x5tqi5uhc9evq2@nikita-300e4c-300e5c-300e7c>
 <560D282F.6060202@gmail.com> <op.x5t07q2ic9evq2@nikita-300e4c-300e5c-300e7c>
Message-ID: <560D690C.8050606@gmail.com>
Date: Thu, 1 Oct 2015 18:10:36 +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: <op.x5t07q2ic9evq2@nikita-300e4c-300e5c-300e7c>
Content-Type: multipart/alternative;
 boundary="------------000501080406040500010004"
Subject: Re: [PHP-DEV] Arrow function expressions in PHP
From: rowan.collins@gmail.com (Rowan Collins)

--------------000501080406040500010004
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 7bit

Nikita Nefedov wrote on 01/10/2015 15:58:
> On Thu, 01 Oct 2015 15:33:51 +0300, Rowan Collins 
> <rowan.collins@gmail.com> wrote:
>> It is a tool for making them shorter, yes, but it is not the only 
>> way, and it comes with a cost of changing established behaviour. 
>> Again, look at C++'s lambda syntax - it is much shorter than PHP's, 
>> but requires a list of all variables from the outer scope being 
>> captured.
>
> C++11 doesn't *require* the list of all variables, but it does require 
> explicit "wildcard" ([=] for copy semantics, [&] for capturing by 
> reference).

I'm not actually that familiar with C++'s lambdas, and was basing my 
understanding on this page: 
https://msdn.microsoft.com/en-us/library/dd293608.aspx

I read this line as implying the same behaviour as PHP's:

 > An empty capture clause, *[ ]*, indicates that the body of the lambda 
expression accesses no variables in the enclosing scope.

But on closer inspection, the meaning of [=] on its own is just not 
terribly clear on that particular description, so I stand corrected.


> But C++ is not the best place for picking up syntax choices, quite 
> frankly it's one of the least readable languages in a way that it 
> allows you to write very cryptic code easily (but still allows to 
> write perfectly readable code as well).

Sure, short syntax leads to hard-to-read code. A good argument to stick 
to the existing PHP verbosity.

And, again, I was not advocating C++'s exact syntax (it conflicts with 
existing syntax anyway), merely showing that "short" and "explicitly 
listed captures" are not mutually exclusive.


> I don't think there was a dozen of different ideas, I could only find 
> those about `lambda(arg-list; use-list; expression)` and variations of 
> it with different keywords and different return-type syntax.

Fair enough. But there's no point me addressing bikeshedding details 
about semi-colon vs other punctuation, etc, etc, if you are 
fundamentally opposed to requiring an explicit list of used variables.


> And one thing that makes auto capture much better choice than explicit 
> capture (as it've been said a couple of times already) is partial 
> application:
>
>     $mul = fn($x) => fn($y) => fn($z) => $x * $y * $z;
>
> Looks simpler than:
>
>     $mul = fn($x) => fn($y; $x) => fn($z; $x, $y) => $x * $y * $z;

It looks simpler, but it's an illusion - there is actually a closure 
hidden in there that has argument ($z) and captures ($x, $y). To someone 
not used to chaining, and not expecting scopes to be inherited, it's far 
from simple to follow where $x and $y come from and end up.

Let's pick another syntax - again, completely off the top of my head, 
may not even be possible:

# { args|captures => return }
$double = { $x => $x * 2 }
$mul = {$x => {$y|$x => {$z|$x,$y => $x * $y * $z} } }

Note that the nesting is indicated explicitly, rather than via 
associativity, the captured variables are listed explicitly, but clearly 
separated from the argument list.

So my question is: if a short syntax was suggested which required 
explicit capture but otherwise seemed compact and elegant, would you be 
interested, or do you consider auto-capture a non-negotiable feature?

Regards,
-- 
Rowan Collins
[IMSoP]

--------------000501080406040500010004--