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

# Patterns implementation

Before completing the pattern matching, it’s possible to add two routines to categorize, and hence simplify the printing output.

- The first of these functions, `registryAction`, conveys a message that signals the completion of a write action. It's suitable for the `create` and `delete` pattern primitives.
- The second, `showRegistryData`, prints formatted registry contents, and works well with the `all` and `search` pattern primitives, which are extensions of the phonebook’s read faculty.

<?php
function registryAction(callable $action, ...$args): IO
{
	$action = m\mcompose(
		// print message about action completion/failure
		fn (bool $res) => IO\IO(f\concat(' ', 'Action', ($res ? 'completed' : 'not completed'))),
		// pass function arguments to IO function
		fn ($args) => $action(...$args)
	);

	return $action(IO\IO($args));
}

function showRegistryData(callable $transform, ...$args): IO
{
	$show = m\mcompose(
		// format printable data
		fn ($data) => IO\IO(formatOutput($data)),
		fn ($args) => $transform(...$args)
	);

	return $show(IO\IO($args));
}

The rest of the patterns should now resemble the code in the following snippet:

<?php
'["add", name, phone]' 	=> fn (string $name, string $phone) => (
	registryAction(create, $name, $phone)
),
'["delete", name]'			=> fn (string $name) => (
	registryAction(delete, $name)
),
'["search", name]' 			=> fn (string $name) => (
	showRegistryData(search, $name)
),
'["all"]'          			=> fn () => showRegistryData(readRegistry),

# Phonebook in action

The REPL is almost complete at this point. The only glaring absence in the design is an actual loop. Remember, the mechanism of a REPL is such that it recursively parses each command it receives, conveying a result on each parsing iteration. Many REPLs like the one built into PHP and PsySH have a prompt that prefixes all command input. The constant, `CONSOLE_PROMPT`, declared in the `constants.php` file should work just fine.

IO monad primitives should prove apt in completing the REPL. The robustness of the device is such that it's invoked directly in routines that read from Standard Input and write to Standard Output, both of which are the console in this case. The approach for this project is to funnel user input into the parser function named `action` and then print it to the screen.


The `main()` function shown below abstracts the REPL's core. The `putStr` and `getLine` IO artifacts respectively write to the console and fetch console input. An infinite loop is added on the execution of the `main()` function because the app was barely usable and incomplete without it.

That's it. The REPL is complete. 

# Running the application

To run it, press the "Run" button below and start writing patterns (according to the project rubric) to make changes to the phonebook registry.

| **Pattern**                | **Corresponding Action**          | **Example**                 |
| :---------------------- | :----------------------------- | :----------------------- |
| `["add", name, phone]` | Create contact                | `add Michael 784312475` |
| `["search", name]`     | Search contact by name        | `search Trevor`         |
| `["delete", name]`     | Delete contact by name        | `delete Jeffrey`        |
| `["all"]`              | Show all contacts in registry | `all`                   |
| `["exit"]`             | Terminate the REPL            | `exit`                  |
| `_`                    | Unrecognized input            | `house party`           |

To use it again after exiting, type the command, `php7.4 phonebook.php`, in the terminal.

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

The Phonebook App

Patterns implementation