Hey,

I have an implementation of the Writer and Reader monads that are using the interfaces you defined.

At the time, I didn't write any tests however.

Would you be interested in a PR for those two monads ?

Hey,

I am probably missing something, but what is the poing of creating an inner function, currying it and then using call_user_func_array to finally call the result in most utility functions ?

For example the map implementation ( https://github.com/widmogrod/php-functional/blob/master/src/Functional/functions.php#L354 )

function map(callable $transformation = null, Functor $value = null)
{
    return call_user_func_array(curryN(2, function (callable $transformation, Functor $value) {
        return $value->map($transformation);
    }), func_get_args());
}

Isn't this strictly equivalent to :

function map(callable $transformation = null, Functor $value = null)
{
    return $value->map($transformation);
}

What am I missing here ?

Thanks !

Why Haskell do notation is interesting?

In Haskell is just an "syntax sugar" and in many ways is not needed, but in PHP sometimes control flow of monads can be hard to track.

Consider example that use only chaining and compare it to the same version but with do notation in PHP.

Control flow without do notation

$result = Identity::of(1)
    ->bind(function ($a) {
        return Identity::of(3)
            ->bind(function ($b) use ($a) {
                return Identity::of($a + $b)
                    ->bind(function ($c) {
                        return Identity::of($c * $c);
                    });
            });
    });

$this->assertEquals(Identity::of(16), $result);

Control flow with do notation

$result = doo(
    let('a', Identity::of(1)),
    let('b', Identity::of(3)),
    let('c', in(['a', 'b'], function (int $a, int $b): Identity {
        return Identity::of($a + $b);
    })),
    in(['c'], function (int $c): Identity {
        return Identity::of($c * $c);
    })
);

assert($result === Identity::of(16));

Everyone needs to judge by itself, but in my opinion do notationimprove readability of code in PHP.

Since minimum version for this library going to be PHP7.1 all
call_user_func($fn, $value); should be changed to $fn($value)

https://www.packtpub.com/application-development/functional-php

I have used PHP Reflection and implemented version of Curry without need of explicitly passing number of arguments.

is there any reason of not using this way to detect number of arguments?

The current constructor of the Collection monad poses some issues when trying to encapsulate an array. If I want to store an empty array inside the collection, I have to do Collection::of([[]]) which is not isomorphic with say Maybe where I just do Just::of([]).

This is problematic for my implementation of filterM (see #26) where we try to construct the containing monad dynamically but we need a "special case" for Collection as it don't work right now.

One option could be to change the constructor of Collection to use func_get_args and never assume that a traversable passer as parameter should be stored as is.

What do you think ?

PS: I hope my description of the issue is clear.

@krtek4 WDYT to put it to the https://github.com/functional-php organisation?
(as you suggested in your book)

I am trying to use the mcompose function in the library and failing. I keep getting the following error in my console:

PHP Fatal error:  Uncaught Error: Call to undefined function Widmogrod\Functional\mcompose()

Wouldn't it be better if Maybe was implemented the same way as Either:

With a generic Maybe interface and 2 specialisations Just and Nothing.

That way we could deal with the actual null value as a real value (which it is).

Thoughts?

Hey, I've added to my composer.json

...
"widmogrod/php-functional": "*"
...

but i get

Class 'Widmogrod\Primitive\Listt' not found

when i try to run

<?php
namespace App\Controller;
use App\Controller\AppController;
use Cake\Core\Configure;
use Widmogrod\Functional as f;
use Widmogrod\Primitive\Listt;

class DebugController extends AppController
{
    public function initialize()
    {
        parent::initialize();
        $this->Auth->allow(['functional']);
    }

    public function functional()
    {
        $list = Listt::of([
            ['id' => 1, 'name' => 'One'],
            ['id' => 2, 'name' => 'Two'],
            ['id' => 3, 'name' => 'Three'],
        ]);
        exit();
    }
}

Few ideas

• calculator
• GraphQL like batch fetching

Hi,

I was looking to the documentation of liftM2:

However the implementation seems to be wrong: $transformation is not used as a pure function.

It seems to be like bind2.
Am I missing something?

Thanks

Of top of my head

• functions should have docblock with Haskell type notation
• Listt instead of PHP native [], Iterators, Generators
• array as tuple
• const for every function

Hi,

I don't know if it's correct, but let's see this example:

$result = f\constt('foo')(); // returns the closure
$result = f\constt('foo')('bar); // returns "foo"

Is it correct? I think that it should return "foo" in both cases, evaluating it even when there are no parameters

The Problem:
PHP has native array ([]) and \Traversable types like Iterator, Generator,...
To be able handle those types in php-functional a lot of nasty work need to be done to work on those types and do conversion between them:

• toList - https://github.com/widmogrod/php-functional/blob/master/src/Functional/functions.php#L180
• toTraversable https://github.com/widmogrod/php-functional/blob/master/src/Functional/functions.php#L132
• toFoldable https://github.com/widmogrod/php-functional/blob/master/src/Functional/functions.php#L113}
• toNativeTraversable - https://github.com/widmogrod/php-functional/blob/master/src/Functional/functions.php#L598

This complicates learning path and implementation of many structures in this project.

A proposed solution:
My proposition to this problem is to have ONE type Listt.

• every function, monad,... would know how to work on this representation
• set of functions would be created to do adapt any Traversable type to this structure

TODO

• standardise api
• add method head() to Listt
• add method tail()to Listt
• add functions to adapt native PHP types to Listt
• use Listt type every ware in project

Draft:

use Widmogrod\Functional as f;

$list = f\fromNil();
$list = f\prepend(1, $list); // x : xs
$list = f\append($listA, $listB); // xs ++ xs
$list = f\map(add(1), $list);
$head = f\head($list);
$tail = f\tail($list);

use Widmogrod\Functional as f;

$list = f\fromIterable(generate(100));
$list = f\fromIterable([1,2,3]);
$list = f\fromValue(1) // [1]

In #31, @widmogrod said that the minimum PHP version supported is 5.6, referring to the Travis build configuration file.
It would be interesting to explicitly declare it in composer.json

Also note that the current tests are very close to passing on end-of-life PHP 5.5 (tested with PHP 5.5.9-1ubuntu4.20). Only Product and Sum primitives trigger an error due to their constructor, which is both inherited from their parent class Num and from the PointedTrait trait. This seems not to be a problem on more recent PHP versions

Hi,
lately I migrated the CI of some projects of mine from Travis to Github Actions.
The main reason was to escape from the new pricing model of Travis, which gaves to OSS projects a limited amount of free minutes of usage.
But I discovered also that Github Actions are quite faster than Travis.

Could you be interested in them?

When using traverse on the Collection monad, the result should be of the type of the applicative, not the initial monad (ie Collection).

A small test case in Haskell :

Prelude Data.Traversable> let test x = if even x then Just(x) else Nothing
Prelude Data.Traversable> traverse test [1, 2, 3, 4]
Nothing
Prelude Data.Traversable> traverse test [2, 4]
Just [2,4]
Prelude Data.Traversable> 

The same test with PHP :

[2] boris> require_once('vendor/autoload.php');
[3] boris> use function Monad\Maybe\just;
[4] boris> use function Monad\Maybe\nothing;;
[5] boris> use Monad\Collection;
[6] boris> function test($x) { return $x % 2 == 1 ? nothing() : just($x); }
[7] boris> (new Collection([1, 2, 3, 4]))->traverse('test');
// object(Monad\Maybe\Nothing)(
// 
// )
[8] boris> (new Collection([2, 4]))->traverse('test');
// object(Monad\Collection)(
// 
// )
[9] boris> (new Collection([2, 4]))->traverse('test')->extract();
// array(
//   0 => array(
//     0 => 2,
//     1 => 4
//   )
// )

As we can see, it works well when there is a Nothing involved, otherwise there's an issue.

One possibility would be to "extract" the right type by running the transformation callable on the first item before doing the foldr so we could feed the correct of function.

What do you think ?

Put declare(strict_types=1); in every file.

Inspiration

• https://hackage.haskell.org/package/lens
• https://github.com/atomicobject/lenses/blob/master/src/index.ts

Hello there,

Thanks for the great work on this library, it's nice to have some monad implementation especially based on FantasyLand :)

I have one not so small issue however. I usually like to use https://github.com/lstrojny/functional-php but sadly when installing both packages via composer there is a nameclash on the invoke that you both define in the Functional namespace.

PHP Fatal error:  Cannot redeclare Functional\invoke() (previously declared in /vagrant/src/vendor/lstrojny/functional-php/src/Functional/Invoke.php:37) in /vagrant/src/vendor/widmogrod/php-functional/src/Functional/functions.php on line 94

I am not sure what the best solution is. As fas as I know, it is not possible to fix this via composer. I would like to propose a renaming of your namespace as this library is probably less used than "functional-php" thus leading to fewer BC breaks.

I can see two possible renames :

• rename just the Functional namespace to something else, like FunctionalHelpers for examples. But there might be issues for other namespaces like Monad later.
• put everything "under" a parent namespace like Widmogrod or something like that.

What do you think ?

I can provide a PR doing all that as soon as we agree on the best solution.

Cheers,