Gain insights into functional programming in PHP. Learn about pure functions, immutable data, and monads. Explore error handling and apply principles through practical projects.

fp15aug.tar.gz

php7.4

ch8-phonebook

php8.1

purescript

python-pytoolz

chapter5-challenge1

AMQP

eris-testing-lesson

AMQP-Challenge

eris-testing-challenge

Functional programming is a paradigm that emphasizes expressing program logic as compositions of pure functions. PHP is a good fit for functional programming as functions are first-class citizens in its userland.
 
This course introduces you to the core concepts of functional programming, like pure functions, immutable data structures, and referential transparency. From there, you'll explore ways to handle errors with default values and callbacks while also exploring sum types such as Either or Maybe. Next, you'll look at functors before diving deep into monads, including IO, State, Reader, and List.
 
By the end of this course, you'll have a keen understanding of how to apply these principles in practice through a worked-out project. Not only will you know another way to program, but you’ll also feel confident enough to apply these ideas to your projects in PHP.

Learn Functional Programming in PHP

For languages like PHP that don’t have default userland functor supportA type class that implements functor-compatible methods is an effective replacement for the functor concept. The **fantasyland** package helps with functor compliance checks. It’s a PHP port of a more complex JavaScript package of the same name. In addition to the required functor design, the **fantasyland** project also includes verification of laws that functors must satisfy.


# Functors are type classes

To effectively create a working functor, we need to implement the functor rubric—defined by category theory from the previous section—as a type class. A **type class** is a composite data type, which supports operator overloading. With a type class, it is possible to, with each invocation of a class method, overwrite its internal state and create a new immutable entity. Overriding in functors is expressed in the signatures of functions meant to be methods of the type class. Also referred to as ad-hoc polymorphism, operator overloading minimizes the redundancy of writing multiple methods to operationalize a new state. It truncates the boilerplate quite effectively.

Formally, a `T` class with an `x` parameter is a type class if the value of `x` can be influenced by a set of operations (functions) that maintain its type constraints. Type classes are interfaces that influence behavior in Haskell, a language that promotes type usage. 

The `Calculator` class shown below is a simple demonstration of these ideas.



<?php
class Calculator
{
  private int $value;
  public function __construct(int $value)
  {
    $this->value = $value;
  }
  public static function get(int $value): Calculator
  {
    return new static($value);
  }
}
print_r(Calculator::get(1));

Type classes are immutable and ensure that every object generated by the `get` static method is atomic to the point of having isolated operations. Additionally, repeated constructor calls that effectively create new objects need not be made according to said conditions.

Adding a method to the type class that has a function as an input that acts on the internal class state operationalizes it as an as-needed polymorphic construct. Through the `operation` function, the class `Calculator` achieves the functor status.

<?php
class Calculator
{
  private int $value;

  public function __construct(int $value)
  {
    $this->value = $value;
  }

  public static function get(int $value): Calculator
  {
    return new static($value);
  }
  public function operation(callable $operation): Calculator
  {
    return self::get($operation($this->value));
  }
}
$obj = new Calculator(1);
print_r($obj->operation(fn (int $val): int => $val + 2));

It's now possible to create logic chains with arithmetic expressions and demonstrate how to use the simple `Calculator` functor.

<?php

$calc = Calculator::get(1)
  ->operation(fn (int $val): int => $val + 10)
  ->operation(fn (int $val): int => $val - 5)
  ->operation(fn (int $val): int => $val * 3);

print_r($calc);

The code in the snippet above is constrained to using integer values, unlike a real calculator. That said, the purpose of this example is to serve as a proof of concept. It’s possible to add as many arithmetic operations to the chain as possible, provided all the functions in the chain adhere to the parametric requirements of the type (the class) to which they’re applied.

> **Note:** It’s no secret that PHP is a weakly-typed language. If we intend to make the most of the language’s type system in our code, the most likely course of action involves the strict-types `ini` declaration (`declare(strict_types=1);`) that forces the use of type observance.


# Functor properties

Two typical functor properties, identity and composition, should hold for every functor. Below are simple mathematical representations of these ideas:

| Law         | Mathematical Representation          |
| ----------- | ------------------------------------ |
| Identity    | $F(id) = id$                     |
| Composition | $F(g \circ f) = F(g) \circ F(f)$ |

> Here, $F$ is a functor and $g$, $id$, and $f$ are arrow functions / morphisms.


The identity proof is one such that an identity function, $id$, once mapped to a functor, $F$, should equate to an identity function whose argument is the same functor instance. On the other hand, the composition is premised on a functor being able to return the same value from a composed, composite function application as a sequential application of distinct functions, $f$ and $g$, that constitutes a chain. To prove these laws is a demonstration with a modified version of the `Calculator` type class.




Learn about functors as type classes and their properties using a calculator class coding example.

Getting Started

An Introduction to Functional Programming in PHP

Core Concepts: Functional Programming in PHP

Composition and Helper Functions

Error Handling in Functional Programming

Functors in PHP

Parallelization of Tasks in PHP

Recursion, Pattern Matching, and Property Testing

Phonebook Application — A Simple Project

Conclusion

Appendix

Functors in PHP Programming

Functors are type classes