Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:88099
Mailing-List: contact internals-help@lists.php.net; run by ezmlm
Received-SPF: pass (pb1.pair.com: domain gmail.com designates 209.85.160.178 as permitted sender)
MIME-Version: 1.0
Sender: morrison.levi@gmail.com
In-Reply-To: <55ED817B.5030109@gmail.com>
References: <BLU436-SMTP13020F8CE8795C628BDC665E26B0@phx.gbl>
	<CAESVnVq9kBhK_uEH2-HvQN4Wv8DVSnwc9ukRjrQ0KNjUbaAD7g@mail.gmail.com>
	<55E77CA9.7050609@gmail.com>
	<CAB6YZux4uYG7u0XRc_56MWFo+8G_h_VZZbWhCDVqA7hdu5XSpg@mail.gmail.com>
	<55E81959.6040305@gmail.com>
	<CAB6YZuwimHWkh8ddvkagmXRQVCK-joUSmMYKKxxjx22BbktSRg@mail.gmail.com>
	<CAEU6NAdfF0w383CNF46B8-Ly2Me+nzwpDFUvjeR4ZHk3x1MoUQ@mail.gmail.com>
	<CAB6YZuwfGhh=EBJySNndtRjstpbvGxvHoWKV=5GUNrx8Prc1tA@mail.gmail.com>
	<CALLYd6TduOcvHW8Dr_0bg6eTLL6y-WTt2O6AstP3cXQxECi_uQ@mail.gmail.com>
	<CAFMT4NrCdc-mmBgaKDCartptkPAd=WLxM_ss4Rn-8teW4mNd6w@mail.gmail.com>
	<55ED817B.5030109@gmail.com>
Date: Mon, 7 Sep 2015 10:56:04 -0600
Message-ID: <CAFMT4Np7yLn6AqfGbUyibHxr8hrD9ds2s43tToifQV1wxck-Hw@mail.gmail.com>
To: Rowan Collins <rowan.collins@gmail.com>
Cc: internals <internals@lists.php.net>
Content-Type: text/plain; charset=UTF-8
Subject: Re: [PHP-DEV] [RFC] [Discussion] Short Closures
From: levim@php.net (Levi Morrison)

On Mon, Sep 7, 2015 at 6:22 AM, Rowan Collins <rowan.collins@gmail.com> wrote:
> Levi Morrison wrote on 04/09/2015 18:34:
>>
>> Hopefully I've been able to demonstrate that this style of coding is
>> powerful and that the chaining of closures was helpful.
>
>
> Sort of - the chaining is far from self-explanatory, and some of it is still
> rather artificial. For instance, surely map would in reality have been a
> named function:
>
> function map($fn) {
>         return $input ~> {
>                 foreach ($input as $key => $value) {
>                 yield $key => $fn($value);
>         }
> };

It's really bothering me that you have a mismatched curly brace. :D

> Reduce can also be simplified to a named function and a single closure:
>
> function reduce($initial, $fn)
>         return $input ~> {
>                 $accumulator = $initial;
>                 foreach ($input as $value) {
>                     $accumulator = $fn($accumulator, $value);
>                 }
>                 return $accumulator;
>         };
> }
>
>
> I realise you never claimed these functions were as simple as possible, or a
> perfect example of using higher-order functions, but right now I can't see
> why you'd write code like that other than as a coding exercise.

Sure, I didn't defend the choices too much because the post was
already lengthy. If you care only that the last argument in the chain
is the input then your definition would be just fine. You are right
that these functions would likely be named, but if we keep the
currying pattern the short-form closures are still helpful:

    function reduce($initial) {
        return $fn ~> $input ~> {
            $accumulator = $initial;
            foreach ($input as $value) {
                $accumulator = $fn($accumulator, $value);
            }
            return $accumulator;
        };
    }

If this RFC passes I'd like to see one that builds on it to remove the
{ return <expr> ;} boilerplate of the above definition:

    function reduce ($initial) ~> $fn ~> $input {
        $accumulator = $initial;
        foreach ($input as $value) {
            $accumulator = $fn($accumulator, $value);
        }
        return $accumulator;
    }

I'm not saying it would be that syntax exactly but something like that
would be nice if this RFC passes.

>> Some people have also suggested removing the block syntax for short
>> closures. The implementation of reduce as defined above is a
>> demonstration of why the block syntax is helpful:
>>
>>      $reduce = $initial ~> $fn ~> $input ~> {
>>          $accumulator = $initial;
>>          foreach ($input as $value) {
>>              $accumulator = $fn($accumulator, $value);
>>          }
>>          return $accumulator;
>>      };
>>
>> With the block syntax removed the last closure in the chain has to use
>> long-form like this:
>>
>>      $reduce = $initial ~> $fn ~> function($input) use($initial, $fn) {
>>          $accumulator = $initial;
>>          foreach ($input as $value) {
>>              $accumulator = $fn($accumulator, $value);
>>          }
>>          return $accumulator;
>>      };
>>
>> I hope you'll agree with me that this is just weird.
>
>
> Not really, no. The difference in behaviour of variable scope makes the
> use() statement look out of place, but the fact that there are two trivial
> functions and one complex one, and therefore two different pieces of syntax,
> seems perfectly reasonable.

I guess we just disagree there. I have no further comment on it.