Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:87973
Mailing-List: contact internals-help@lists.php.net; run by ezmlm
Received-SPF: pass (pb1.pair.com: domain gmail.com designates 209.85.217.171 as permitted sender)
MIME-Version: 1.0
In-Reply-To: <55E51FAA.8030106@gmail.com>
References: <BLU436-SMTP13020F8CE8795C628BDC665E26B0@phx.gbl>
	<55E4C19F.4060704@gmail.com>
	<op.x384rtfxc9evq2@nikita-pc>
	<55E4F029.10104@gmail.com>
	<BLU437-SMTP10528B092289CCAD9B4D8AFE26A0@phx.gbl>
	<7BCB36EE-56C8-441F-BF40-954D9FA912A9@lerdorf.com>
	<BLU436-SMTP233358BCED2144A24C749ABE26A0@phx.gbl>
	<55E51FAA.8030106@gmail.com>
Date: Tue, 1 Sep 2015 01:53:41 -0400
Message-ID: <CAAyV7nGykkBVvtFEA91Qtq6i0+1q_8EcA0zZZF5TxNTo05RMBg@mail.gmail.com>
To: Stanislav Malyshev <smalyshev@gmail.com>
Cc: Bob Weinand <bobwei9@hotmail.com>, 
	"internals@lists.php.net" <internals@lists.php.net>
Content-Type: text/plain; charset=UTF-8
Subject: Re: [PHP-DEV] [RFC] [Discussion] Short Closures
From: ircmaxell@gmail.com (Anthony Ferrara)

Stas,

On Mon, Aug 31, 2015 at 11:46 PM, Stanislav Malyshev
<smalyshev@gmail.com> wrote:
> Hi!
>
>> Here it is very obvious that we want to import a variable. Especially, I wonder how
>> $array = array_map(function ($x) use ($y) { return $x + $y; }, $array);
>> is making such simple applications more readable? And especially, what value does it add here?
>
> It is making it more readable by explicitly specifying that we're using
> function, that this function imports $y from parent scope and returns $x
> + $y. Of course, a seasoned programmer that has years of experience in
> functional languages would recognize this pattern, but that's not
> exactly the main target audience of PHP.

I think that's quite a bit hyperbolic of an argument.

Most programming languages today have a "short form" closure or lambda syntax

HackLang: ($x) ==> $x + 1;
C++: [](int x) -> int { return x + 1; }
Java: (int x) -> x + 1;
Python: lambda x: x+1
Ruby: lambda |x| { x + 1 }
Rust: |x| x + 1
JavaScript (ES6): x => x + 1
C#: x => x + 1
Objective C: ^(int x) { return x + 1; }

Note that not a single one of those is a "functional" language. That's
every language in the top 10 index except PERL, PHP and VB.NET (though
VB has a similar syntax: function (x as Integer) x + 1),

I agree that at first it will feel a little bit weird, especially
given that PHP in general lacks syntactic sugar (we still don't have a
short-hand to initialize stdclass objects). We introduced [] back in
5.4, and largely it has made readability FAR better (despite some
people saying it wouldn't at the time).

> And I do not think the argument "you don't have to use it" is a good one
> for adding language syntax constructs. If it's in the language, you'd
> have to deal with it, and you'd have to teach other people to deal with
> it. It's not some function sitting in the extension that may not even be
> loaded - it's part of language syntax. So if it would encourage
> write-only code, you'd have to deal with it even if you don't personally
> create write-only code.

I agree 100%. "you don't have to use it" sucks as an argument. However
I don't think that's what Bob meant. He was trying to convey that the
tool isn't always appropriate in all situations. You can craft code
that makes this new syntax look unreadable. But you can craft code
that makes this look far more readable.

Example:

function partial(callable $cb) {
    return function($left) use ($cb) {
        return function($right) use ($cb, $left) {
            return $cb($left, $right);
        };
    };
}

vs:

function partial(callable $cb) {
    return $left ~> $right ~> $cb($left, $right);
}

It may look weird at first, but consider that's because you're not
used to the syntax. To me, the top is far harder to follow because of
the shear number of tokens to follow, not to mention that I need to
pay attention to the use-blocks which may or may not be importing
certain variables. The bottom reads exactly how I would expect it to.

Both are completely explicit in what they do and how they behave.

That's my opinion anyway...

Anthony