Forem: Chonbashev Artyk

Functional Programming in PHP: Part 2

Chonbashev Artyk — Sun, 31 May 2020 03:10:03 +0000

Today we will cover: First Class and High Order Functions.

So, now we know what is a pure function, what else do we need to know?
In PHP we have a First Class Function, what is it and how to use it?

First Class Function means, we can use our function like any other types.
For example, we can pass it around, we can assign it, destroy, etc.

Let's see an examples:

// Assign
$validate = fn(string $x): bool => strlen($x) > 14;

// Destroy
unset($validate);

// Pass it
$id = fn($x) => $x;

function map(callable $fn, array $arr): Generator {
    foreach($arr as $item) {
        yield $fn($item);
    }
}

$fruits = ['apple', 'orange'];
$unchangedFruits = map($id, $fruits); // ['apple', 'orange'];
$capitalizedFruits = map('ucfirst', $fruits); // ['Apple', 'Orange'];

So, now we know, that we can use our functions like everything else, that's great!
And now get to know what is High Order Functions, that's a function which accepts a function and/or returns a functions! So, that's basically our map function above :)

So, let's see how does it look, when function returns a function.

// Change our function a little
function map(callable $fn): callable {
    return function(array $arr) use($fn): Generator {
        foreach($arr as $item) {
            yield $fn($item);
        }
    }     
}

$doube = map(fn($x) => x * 2);
$doube([1, 2, 3]); // 2, 4, 6

What benefits we gained?
Well, now we have a function which work with arrays and can easily return to us our function which will work with any array and double it, so we can easily reuse our High Order map and First Class double function :)

Functional Programming in PHP

Chonbashev Artyk — Sat, 30 May 2020 14:47:17 +0000

Hello there!
I decided to write a little bit about FP which I know.

This time we will talk about Functional Programming
and one of it's concepts Pure Functions.

So, let's start what is Functional Programming itself?
As you can guess it's based upon functions and not which we are used to,
but math functions and the biggest difference here's the all math functions are pure and have a single argument.

So let me give an example:

function hello(string $name): string {
    return "hello, $name!";
}

This function is pure, because it has following:

It doesn't have side effects
It's referentially transparent

What is a side effect? It's something that's done outside of scope of our function, e. g.: database queries, file writings, changing global variable values, etc. Example (to run in cli):

function hello(string $name): void {
    echo "Hello, $name!";
}
hello('John'); // John
fclose(STDOUT);
hello('John'); // Nothing

So now we know, at least our function must not change state of our app to be pure,

What is RT? It's when our function depends on it's input (arguments) and produce the same output if you have given the same arguments.
And the first introduced function is referentially transparent, because no matter how many times we call it with the same arguments, we will receive the same result.

function hello(string $name): string {
    return "hello, $name!";
}

hello('John') // John
hello('John'); // John

What benefits we gain?

Easy to test
Easy to understand

If somebody is interested in it, I will continue to cover this topic.