Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:88053
Mailing-List: contact internals-help@lists.php.net; run by ezmlm
Received-SPF: pass (pb1.pair.com: domain gmail.com designates 209.85.213.51 as permitted sender)
MIME-Version: 1.0
Sender: morrison.levi@gmail.com
In-Reply-To: <CALLYd6TduOcvHW8Dr_0bg6eTLL6y-WTt2O6AstP3cXQxECi_uQ@mail.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>
Date: Fri, 4 Sep 2015 11:34:04 -0600
Message-ID: <CAFMT4NrCdc-mmBgaKDCartptkPAd=WLxM_ss4Rn-8teW4mNd6w@mail.gmail.com>
To: Daniel Persson <mailto.woden@gmail.com>
Cc: =?UTF-8?Q?Pavel_Kou=C5=99il?= <pajousek@gmail.com>, 
	PHP 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)

(This post is fairly lengthy so I have copied it into a gist if you
would prefer to read it that way:
https://gist.github.com/morrisonlevi/8323125182ca3b5e2124)

Here's a practical example of chaining closures together that allows
us to easily implement versions of `array_map` and `array_reduce` that
are highly generic, meaning they can be used with various kinds of
input and output types instead of just arrays. These new versions can
also easily be chained together to form a "pipe" of transformations.
While the short-form closures are not required for this to work it
does make it much simpler.

Also, I know this is a fair bit of code to dump at once; it's really
hard to give meaningful examples that don't have some length to them.
Please don't skip this code!

    $map = $fn ~> $input ~> {
        foreach ($input as $key => $value) {
            yield $key => $fn($value);
        }
    };

    $reduce = $initial ~> $fn ~> $input ~> {
        $accumulator = $initial;
        foreach ($input as $value) {
            $accumulator = $fn($accumulator, $value);
        }
        return $accumulator;
    };

    // this is just a helper function
    // can skip reading it if you want
    function chain(callable $fn, callable ...$callables) {
        $functions = func_get_args();
        return (...$params) ~> {
            $count = count($functions);
            $carry = $functions[0](...$params);
            for ($i = 1; $i < $count; $i++) {
                $carry = $functions[$i]($carry);
            }
            return $carry;
        };
    }

This essentially allows for binding only certain parameters and
chaining whole algorithms together:

    $algorithm = chain(
        $map($x ~> $x * 2),
        $reduce([])(function ($accumulator, $value) {
            $accumulator[] = $value;
            return $accumulator;
        })
    );

    $result = $algorithm($iterable);

Note that while I've used a basic array here for brevity I could have
used any kind of container that supports adding single items. For
instance, I could have used a set:

    $set = new Set();
    $algorithm = chain(
        $map($x ~> $x * 2),
        $reduce($set)(function ($set, $value) {
            $set->add($value)
            return $set;
        })
    );

    $result = $algorithm($iterable);

Now all the duplicates get removed should there be any.

-----

Hopefully I've been able to demonstrate that this style of coding is
powerful and that the chaining of closures was helpful. Here are the
long-form closure equivalents for contrast:

    $map = function ($fn) {
        return function($input) use($fn) {
           foreach ($input as $key => $value) {
               yield $key => $fn($value);
            }
        };
    };

    $reduce = function ($initial) {
        return function ($fn) use($initial) {
            return function($input) use($initial, $fn) {
                $accumulator = $initial;
                foreach ($input as $value) {
                    $accumulator = $fn($accumulator, $value);
                }
                return $accumulator;
            };
        };
    };

    function chain(callable $fn, callable ...$callables) {
        $functions = func_get_args();
        return function(...$params) use($functions) {
            $count = count($functions);
            $carry = $functions[0](...$params);
            for ($i = 1; $i < $count; $i++) {
                $carry = $functions[$i]($carry);
            }
            return $carry;
        };
    }

    $algorithm = chain(
        $map(function ($x) {
            return $x * 2;
        }),
        $reduce([])(function ($accumulator, $value) {
            $accumulator[] = $value;
            return $accumulator;
        })
    );

----

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. I was initially
against the block syntax but after using it in meaningful code I
concluded that the block syntax is helpful.