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

# What's temporal coupling?

**Temporal coupling** deters code-readability. It occurs whenever a class’s design is such that two or more of its methods follow an invocation order that closely binds the result of a method call to that of the one that directly follows it. Class setters are enforcers of this anti-pattern.

## Problem scenario

Take a close look at the snippet below.

<?php

$calculator = new PriceCalculator();

$calculator->updateCurrencyRates([
    'usd' => 1.25,
    'ugx' => 3.2
]);
$price = $calculator->computePrice([
    'lapel pin' => 8,
    'notebook'  => 14
]);

The invocation order in the snippet above reflects a slight coupling between `PriceCalculator` object methods. The constructor call is directly followed by subsequent calls to the `updateCurrencyRates` and `computePrice` methods. The coupling is such that the `computePrice` method produces a result that depends on the object’s internal state. The bindings of the internal state are handled by the `updateCurrencyRates` method that depends on the constructor call that instantiates the `PriceCalculator` class. The result of each call is tied to the result of the preceding call. The second method in the order is an impure setter where the state bindings are better archived to the constructor. The third is likely a pure function with an invocation that ends the call chain.

## Solution to the problem

Immutability is our simple remedy to this mess.

Immutability preempts unnecessary state changes. It enables the creation of objects with unique states that can be modified by method calls gracefully within parametric reason. Below, we show how an immutable implementation of the `PriceCalculator` class can be used as a value object, and thus act as an immutable construct similar to those discussed thus far.

Learn about temporal coupling with a simple 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

Temporal Coupling

What’s temporal coupling?

Problem scenario