Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:88613
Mailing-List: contact internals-help@lists.php.net; run by ezmlm
Received-SPF: pass (pb1.pair.com: domain gmail.com designates 209.85.212.179 as permitted sender)
MIME-Version: 1.0
Reply-To: bishop@php.net
Sender: bishop.bettini@gmail.com
In-Reply-To: <CAAyV7nE=LdG==0n0XLS0mSzWO+ZC=-CVBoFht4CYpS6r4RMgeA@mail.gmail.com>
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>
	<CAAyV7nE=LdG==0n0XLS0mSzWO+ZC=-CVBoFht4CYpS6r4RMgeA@mail.gmail.com>
Date: Thu, 1 Oct 2015 13:12:19 -0400
Message-ID: <CAEYWF=7+BW6yi5QGQwTCGLZxdbO-z=qRsKJ+oJ00_dYsf-w2RA@mail.gmail.com>
To: Anthony Ferrara <ircmaxell@gmail.com>
Cc: Nikita Nefedov <inefedor@gmail.com>, "internals@lists.php.net" <internals@lists.php.net>, 
	"rowan.collins@gmail.com" <rowan.collins@gmail.com>
Content-Type: multipart/alternative; boundary=047d7bb040584a123e05210e26df
Subject: Re: [PHP-DEV] Arrow function expressions in PHP
From: bishop@php.net (Bishop Bettini)

--047d7bb040584a123e05210e26df
Content-Type: text/plain; charset=UTF-8

On Thu, Oct 1, 2015 at 12:28 PM, Anthony Ferrara <ircmaxell@gmail.com>
wrote:

> Nikita and all,
>
> > 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.
> > I do understand that this is quite subjective, but neither this syntax
> nor
> > `fn(arg-list; use-list) expression` look obvious and easily readable to
> me.
>
> The problem is that semicolons are non-obvious, especially in a
> context where commas are used (and traditionally used).
>
> Example, tell the difference quickly between
>
> fn($a, $b; $c) => $a + $b + $c;
>
> and
>
> fn($a; $b, $c) => $a + $b + $c.
>
> At a glance, they are identical. You have to actually look at each
> item to realize that there's a difference. At least with use() there's
> a syntactical separator there to draw your eye to the contextually
> relevant information.


True.  But a developer can mitigate with judicious white-space:

fn($a, $b ; $c) => $a+$b+$c

Or we can figure out some other such symbol. Worse casing no white space,
brain storming:

fn($a,$b:$c) => $a+$b+$c // not much better
fn($a,$b!$c) => $a+$b+$c // better, but looks like not
fn($a,$b&$c) => $a+$b+$c // lost in the noise, looks like bitwise
fn($a,$b%$c) => $a+$b+$c // perl jibberish, looks modulo
fn($a,$b--$c) => $a+$b+$c // multi-char, looks like decrement
fn($a,$b::$c) => $a+$b+$c // maybe, kinda confusing

// my favorite
fn($a, $b @ $c) => $a + $b + $c;

// vs.
function ($a, $b) use ($c) { return $a + $b + $c; }

// a space savings of 100%
// unambiguous parsing
// no backtracing
// no new rules to learn about scope pulling
// works if we later support '*' for scope pulling

--047d7bb040584a123e05210e26df--