GeezerVison

functional

Highlight features

Basic structures from Haskell

$maybeInt = Maybe::just(123);
$maybeInt = $maybeInt->fmap(fn ($x) => $x * 2);

if ($maybeInt->isJust()) {
    print $maybeInt->unwrap();
}

Expression helpers

$result = c (fn ($x) => $x + 2) (123); // 125

$f = fn ($x) => $x + 2;
$g = fn ($x) => $x * 2;
$gf = c($f)->fmap($g); // equivalent of g(f($x))

print $gf(123);  // (123 + 2) * 2 = 250

$min = c('min');

$maybeArrayOfInt = Maybe::just(range(1,4));

$maybeMinOfArray = fmap($min, $maybeArrayOfInt);

var_dump($maybeMinOfArray->unwrap());

// putStrLn :: String -> IO ()
$putStrLn = fn (string $x) => IO::inject(fn () => print $x . "\n");

// getLine :: IO String
$getLine = IO::inject(fn (): string => fgets(\STDIN));

$bound = dn($getLine, $putStrLn);
$bound(); // will run getLine and then bind the result to putStrLn and print it

dn(
    writeFile("test.txt", show (123 * 123)),
    appendFile("test.txt", "Hello!\n"),
    readFile("test.txt"),
    putStrLn(...)
)();

function myNotation(mixed ...$elements) {
    return (new LeftToRightNotation(new CategoryOfFunctions()))->composeMany(...$elements);
}

// this will compose a function that first will evaluate the last passed "element"
$composedFunction = myNotation(
     fn (int $x): bool => $x == 16,
     fn (int $x): int  => (int) ($x / 2),
     fn (int $x): int => pow($x, 5),
     fn (array $items): int => count($items),
     array_filter(...)
);

$composedFunction(["one", "two", ""]); // true

Helpers for your tests

class MyType implements FunctorInstance
{
    public function fmap(\Closure $f): FunctorInstance
    {
        // your code here
    }
}

class MyTypeTest
{
    // use helper traits to prove your implementation of fmap abides by the Functor Law.
    use FunctorLawsAssertions;

    public function testIsAFunctor(): void
    {
        $myType = new MyType();

        // Provide an instance and two functions for this assertion

        $this->assertInstanceIsFunctor(
            $myType,
            fn (int $x): int => $x + 2,
            fn (int $x): int => $x + 2
        );
    }
}

Wrap existing code

/**
 * Create a Wrapper with an anonymous function that calls the psr3Logger from a Tuple input.
 */
$wrapper = Wrapper::withAdjustedInput(
    fn (Tuple $p) => $psr3Logger -> log ($p->fst(), $p->snd()),
);

/**
 * Let's add a prefix
 */
$prefix = 'prefixHere: ';

/**
 * Adjust the input
 */
$contextLogger = $wrapper -> adjustInput (fn (Tuple $p): Tuple => t ($prefix . $p->fst(), [$p->snd()]) );

/**
 * Adjust the output
 */
$logger = $contextLogger -> adjustOutput (fn () => time());

$currentTime = $logger (t ("Log message", "context"));

Implement typeclass instances for types

$equalsImplementation = fn (int|float $a, int|float $b): bool  => ((int) $a) == ((int) $b);

Eq::register(
    instanceName: 'int|float',
    typePredicate: fn ($x) => is_int($x) || is_float($x),
    equals: $equalsImplementation,
    notEquals: null // derived
);

$result = equals(12.6, 12.1); // true
$result = notEquals(12.6, 13.1); // true

Loads of bugs and inconsistencies

Contributing

Documentation

Other interesting functional programming in PHP libraries/projects