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

# Definition of monads

**Monads** are versatile functors built on top of polymorphic concepts, and complete a genealogy of type-classes. The versatility of monads is such that they allow programmers to write context-rich maps. With a monad, it is possible to compose branching logic (like that seen in the Maybe and Either sum types), computations (I/O-bound and CPU-bound code), and effects (the integer residue of a print call for instance). Like functors, monads follow the laws of the calculus from which they originate. The cornerstone monad principles are the mathematical forms of associativity, left-identity, and right-identity. They are as follows:


| Law            | Mathematical Representation                    |
| -------------- | ---------------------------------------------- |
| Left identity  | $return \space x >>= f = f \circ x$               |
| Right identity | $m >>= return = m$                         |
| Associativity  | $(m >>= f) >>= g = m >>= (x \longrightarrow f x >>= g)$ |

> **Note:** $m$ is a monad, $f$ and $g$ are functions, $x$ is a value encapsulated in a monadic context, $>>=$ is the bind operation, $return$ is a monad constructor.

- The **left-identity** property validates whether a function, $f$, bound to a monadic construct, $m$, whose context contains a specified value, $x$, is the same as a direct call of the monad-bound function with said value. We can conclude that the function, 
 $f$, evaluates to a type-class instance.

- The **right-identity** principle is based on establishing that the return method evaluates to a type class, and by extension, to a monad instance. This proves that it behaves similarly to a monad constructor.

- **Associativity**, the third and final monad property, proves whether successive function bindings to a monad mirror the result obtained from chaining the same functions within a function.

As is the case with the functor proofs in the previous lesson, additions to the `Calculator` type class are imperative. The main addition, `bind`, serves the purpose of the $>>=$ operator in the discussion above. The other function, `exec`,  unwraps the object and reveals the floating-point value encapsulated in it.


Learn the formal definition of monads with the corresponding PHP code.

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

Monads

Definition of monads