What do you think about introducing to functional php autocurring and function composition?

I have created working prototype of library with autocurring, function composition and making$collection as last argument: https://github.com/psliwa/rfp

In my opinion it looks promising, allows to take advantage of functional programming in even better way. There is the chance to make new release, aka "functional php 2"?

For my own use I wrote a function called hashMap to create associative arrays:

>>> hashMap(
...     ['abc', 'foobar'],
...     function ($value) {
...         return [$value[0], $value];
...     }
... )
=> [
     "a" => "abc",
     "f" => "foobar",
   ]

function hashMap($collection, callable $callback)
{
    InvalidArgumentException::assertCollection($collection, __FUNCTION__, 1);

    $aggregation = [];

    foreach ($collection as $index => $element) {
        list($key, $value) = $callback($element, $index, $collection);
        $aggregation[$key] = $value;
    }

    return $aggregation;
}

Is this something that would also be useful to others? If yes, I can prepare a proper pull request. Of course it can be named differently if there is a better term for what this function does.

What do you think about transforming the memoize function into a high order function? I think it would become easier to use from the client perspective and it may simplify its internal implementation. I'm thinking of something like

function memoize(callable $function, callable $hashGenerator = null) {
    if (null === $hashGenerator) {
        $hashGenerator = function(array $arguments) {
            // ...
        }
    }

    return function (...$arguments) use ($function, $hashGenerator) {
        static $localCache = [];

        $key = $hashGenerator($arguments);

        if (!array_key_exists($key, $localCache)) {
            $localCache[$key] = $callback(...$arguments);
        }

        return $localCache[$key];
    };
}

Added function which defines a function of an arbitry number of arguments and calls the provided callable with only the given number of arguments

Didn't add tests as it wasn't obvious how they worked and wanted feedback before investing the time

Previous title: Add enumerate, similar to Python's

This PR adds an enumerate(Transversable|array, int=) function that acts like Python's enumerate

foreach (enumerate($this->hash) as $i => [$k => $v]) {
    // ...
}

My use case is to iterate over an array with string keys and have an associated integer that can be used as an ID

tap() calls the given $callback with the given $value, which, in quite a few cases, makes the code read more fluent and "functional":

tap(User::create('John Doe'), function (User $user) {
    UserService::sendWelcomeEmail($user);
})->login();

// or

tap(DisposableEmail::create('From Nigerian Prince with luv'), function (Email $email) {
    EmailManager::send($email);
})->destroy();

This function is inspired by Laravel, which is in turn inspired by Ruby.

Is it me or one currently can't invert a boolean-returning function ?

I'd like a not function looking like:

namespace Functional;

function not(callable $callback) {
    return function($value) use ($callback) {
        return !$callback($value);
    };
}

see https://3v4l.org/G3vtd for a working impl.

Do you think it's a good idea? If yes, I can try to make a PR.

Thanks!

Partition() currently only accepts one predicate function and splits an array in to two partitions, putting elements which pass in the first, and those which fail in the second.

Partition() should accept n predicate functions, create n+1 partitions, and place each element in the partition of the first predicate it matches, with unmatched ones in the last.

In the case of single predicate function the behavior should be unchanged.

I've added a few functional typeclasses using interfaces.

Also, this PR provides a basic implementation of Scala Option (or Haskell Maybe). Option implements all included interfaces and comes with unit tests.

I implemented the function, but tests for it are failing, because for some reason PHPUnit thinks that the sort_by function is not defined. I don't know why that error occurs, as far as I can see the function is defined and used correctly. @lstrojny Can you help me with this one?

Fixes #162

I found myself in need of such a function

So you could transform a list to a dictionary like so:

$dictionary = flatMapWithKeys($list, function($element) {
    $key = ...
    $value = ...
    return [
        $key => $value,
    ];
});

Naive implementation would be something like this:

function flatMapWithKeys(array $array, callable $fn)
{
    $result = [];
    foreach ($array as $key => $value)
    {
        $result += $fn($value, $key);
    }
    return $result;
}

Would this be useful?

Hi,

since PHP 7.1 one can use iterable type hint for everything that is iterable, including array and Traversable.

I know this lib shall also work for older PHP version, but adding iterable to the phpdoc-block would not hurt.

Currently IDE's and other tools throw warnings when I pass an iterable instead of an array or a Traversable.

Suggestion:

Add iterable to all doc-blocks.

Best Regards Martin

Expected take_left to support iterators without requiring fully iterating through it. Because sequence_linear returns an infinite iterator the take_left function is never able to provide the first $count of iteration values due to its use of array_to_iterator.

Generative testing looks ideal for Functional PHP and https://github.com/steos/php-quickcheck looks like a good implementation.

TBD

• [ ] weither to use it inside of PHPUnit or not. First instinct is rather not but the question is weither it's sensible to port tests like FunctionalTest and AnnotationsTest

Surprised to see InvalidArgumentException::assertCallback was removed with no apparent substitute on sight, implemented check for callables inside Pipe functor construction, and adding some docblocks that Psalm complained about.