• Lambda: λab.ab
• Purpose: Applies a function a to an argument b. In Haskell, this is the $ operator. It can help reduce the number of parentheses in complex expressions.

use loophp\combinator\Combinators;

$a = Combinators::A();
$strlen = 'strlen';
$string = 'hello world';

// Instead of $strlen($string)
echo $a($strlen)($string); // Outputs: 11
```</details>

<details>
<summary>B (Bluebird) Combinator</summary>

*   **Lambda:** `λabc.a(bc)`
*   **Purpose:** Function composition. It takes two functions, `a` and `b`, and a value `c`, and applies `a` to the result of `b` applied to `c`. This is `.` in Haskell.

```php
use loophp\combinator\Combinators;

$b = Combinators::B();
$addOne = fn(int $x): int => $x + 1;
$multiplyByTwo = fn(int $x): int => $x * 2;

// Create a new function: multiply by two, then add one.
$composed = $b($addOne)($multiplyByTwo);

echo $composed(5); // Outputs: 11 (which is 1 + (2 * 5))

• Lambda: λabcd.a(bcd)
• Purpose: Extended function composition for three functions: a(b(c(d))).

use loophp\combinator\Combinators;

$blackbird = Combinators::Blackbird();
$wrapInP = fn(string $s): string => "<p>$s</p>";
$toUpper = 'strtoupper';
$addExclamation = fn(string $s): string => "$s!";

$format = $blackbird($wrapInP)($toUpper)($addExclamation);

echo $format('hello'); // Outputs: <p>HELLO!</p>

• Lambda: λabc.acb
• Purpose: Flips arguments. It takes a function a and two arguments b and c, and applies a with c as the first argument and b as the second. This is flip in Haskell.

use loophp\combinator\Combinators;

$c = Combinators::C();
$divide = fn(int $x, int $y): float => $x / $y;

$flippedDivide = $c($divide);

echo $flippedDivide(2)(10); // Outputs: 5 (same as $divide(10, 2))
```</details>

<details>
<summary>D (Dove) Combinator</summary>

*   **Lambda:** `λabcd.ab(cd)`
*   **Purpose:** Composes two functions and their arguments: `a(b)(c(d))`.

```php
use loophp\combinator\Combinators;

$d = Combinators::D();
$add = fn(int $x): callable => fn(int $y): int => $x + $y;
$multiply = fn(int $x): callable => fn(int $y): int => $x * $y;

// Calculates ( (2 + 3) + (4 * 5) ) using curried functions
echo $d($add)($add(2)(3))($multiply(4))(5); // Outputs: 25

• Lambda: λabcde.ab(cde)
• Purpose: Five-argument composition, useful for deeply nested function calls: a(b)(c(d(e))).

use loophp\combinator\Combinators;

$e = Combinators::E();
$add = fn(int $x): callable => fn(int $y): int => $x + $y;
$multiplyByTwo = fn(int $x): int => $x * 2;
$addOne = fn(int $x): int => $x + 1;

// Equivalent to: $add(10)(($multiplyByTwo($addOne(5))))
echo $e($add)(10)($multiplyByTwo)($addOne)(5); // Outputs: 22

• Lambda: λabc.cba
• Purpose: Reverses the application order. Applies c to b, and then to a.

use loophp\combinator\Combinators;

$f = Combinators::F();
$concat = fn(string $a): callable => fn(string $b): string => $a . $b;

// Instead of $concat(' world')('hello')
echo $f('hello')(' world')($concat); // Outputs: " worldhello"

• Lambda: λabcd.ad(bc)
• Purpose: Applies arguments in a unique order: a(d)(b(c)).

use loophp\combinator\Combinators;

$g = Combinators::G();
$merge = fn(array $a): callable => fn(array $b): array => array_merge($a, $b);
$mapToUpper = fn(array $a): array => array_map('strtoupper', $a);

// Equivalent to $merge(['d', 'e'])(($mapToUpper(['a', 'b', 'c'])))
$result = $g($merge)($mapToUpper)(['a', 'b', 'c'])(['d', 'e']);
print_r($result); // Outputs: Array ( [0] => A [1] => B [2] => C [3] => d [4] => e )

• Lambda: λabc.abcb
• Purpose: Applies a three-argument function, but uses the second argument twice: a(b)(c)(b).

use loophp\combinator\Combinators;

$h = Combinators::H();
$wrap = fn(string $tag): callable => fn(string $content): callable => fn(string $closingTag): string => "<$tag>$content</$closingTag>";

// Uses 'div' as both the opening and closing tag.
$wrapInDiv = $h($wrap)('div');

echo $wrapInDiv('Hello'); // Outputs: <div>Hello</div>

• Lambda: λa.a
• Purpose: The identity function. It returns whatever argument it receives. This is id in Haskell.

use loophp\combinator\Combinators;

$i = Combinators::I();

echo $i('Hello World'); // Outputs: Hello World
echo $i(42);            // Outputs: 42

• Lambda: λabcd.ab(adc)
• Purpose: A complex combinator useful for specific recursive or state-passing scenarios: a(b)(a(d)(c)).

use loophp\combinator\Combinators;

$j = Combinators::J();
$log = fn(string $prefix): callable => fn(string $message): string => "[$prefix] $message";

// Creates a nested log message
// Equivalent to $log('INFO')($log('USER')('action'))
echo $j($log)('INFO')('action')('USER'); // Outputs: [INFO] [USER] action```
</details>

<details>
<summary>K (Kestrel) Combinator</summary>

*   **Lambda:** `λab.a`
*   **Purpose:** The constant function. It takes two arguments and always returns the first. This is `const` in Haskell.

```php
use loophp\combinator\Combinators;

$k = Combinators::K();
$alwaysReturns5 = $k(5);

echo $alwaysReturns5('foo'); // Outputs: 5
echo $alwaysReturns5(123);   // Outputs: 5

• Lambda: λab.b
• Purpose: The opposite of the Kestrel. It takes two arguments and always returns the second.

use loophp\combinator\Combinators;

$ki = Combinators::Ki();
$getSecond = $ki('ignored');

echo $getSecond('hello'); // Outputs: hello
echo $getSecond(true);    // Outputs: 1 (for true)

• Lambda: λab.a(bb)
• Purpose: Applies function a to the result of function b applied to itself. This requires b to be a function that can meaningfully accept itself as an argument.

use loophp\combinator\Combinators;

$l = Combinators::L();
$inspectType = fn(mixed $arg): string => "Argument is of type: " . gettype($arg);
$selfApplicable = fn(callable $c): string => "I am a function.";

// Equivalent to $inspectType($selfApplicable($selfApplicable))
echo $l($inspectType)($selfApplicable); // Outputs: Argument is of type: string

• Lambda: λa.aa
• Purpose: Self-application (also known as the ω combinator). It applies its single argument (which must be a function) to itself.

use loophp\combinator\Combinators;

$m = Combinators::M();
$describe = fn(callable $c): string => "This is a closure.";

// Applies the $describe function to itself.
echo $m($describe); // Outputs: This is a closure.

• Lambda: λab.b(ab)
• Purpose: A peculiar form of composition, b(a(b)). Useful in specific recursive algorithms or data structure manipulations.

use loophp\combinator\Combinators;

$o = Combinators::O();
// A curried function to prepend to an array
$prepend = fn(mixed $item): callable => fn(array $list): array => [$item, ...$list];
$reverse = 'array_reverse';

// Equivalent to $reverse($prepend(3)([1, 2])) -> $reverse([3, 1, 2])
$result = $o($prepend)([1, 2])($reverse)(3);
print_r($result); // Outputs: Array ( [0] => 2 [1] => 1 [2] => 3 )

• Lambda: λa.(aa)(aa)
• Purpose: The divergent combinator. It is constructed from the Mockingbird (M) as MM. When applied to any function, it creates an infinitely recursive call that will exhaust memory. Do not run this code.

// This will cause a fatal error due to infinite recursion.
// $omega = Combinators::Omega();
// $omega(fn($x) => $x);```
</details>

<details>
<summary>Phoenix Combinator</summary>

*   **Lambda:** `λabcd.a(bd)(cd)`
*   **Purpose:** Distributes an argument `d` across two functions `b` and `c`, then combines the results with function `a`.

```php
use loophp\combinator\Combinators;

$phoenix = Combinators::Phoenix();
$add = fn(int $x): callable => fn(int $y): int => $x + $y;
$multiplyByTwo = fn(int $x): int => $x * 2;
$multiplyByThree = fn(int $x): int => $x * 3;

// Calculates (2 * 10) + (3 * 10)
$calculate = $phoenix($add)($multiplyByTwo)($multiplyByThree);

echo $calculate(10); // Outputs: 50

• Lambda: λabcd.a(bc)(bd)
• Purpose: Another distribution combinator, but this one distributes a function b over two arguments c and d.

use loophp\combinator\Combinators;

$psi = Combinators::Psi();
$makePair = fn(string $a): callable => fn(string $b): string => "($a, $b)";
$getName = fn(array $user): string => $user['name'];
$getEmail = fn(array $user): string => $user['email'];
$user = ['name' => 'John', 'email' => 'john@example.com'];

// Equivalent to $makePair($getName($user))($getEmail($user))
echo $psi($makePair)($getName)($getEmail)($user); // Outputs: (John, john@example.com)

• Lambda: λabc.b(ac)
• Purpose: A different form of composition, applying b to the result of a applied to c.

use loophp\combinator\Combinators;

$q = Combinators::Q();
$addOne = fn(int $x): int => $x + 1;
$multiplyByTwo = fn(int $x): int => $x * 2;

// Equivalent to $multiplyByTwo($addOne(5))
$composed = $q($addOne)($multiplyByTwo);

echo $composed(5); // Outputs: 12

• Lambda: λabc.bca
• Purpose: Reorders arguments for a two-argument function b.

use loophp\combinator\Combinators;

$r = Combinators::R();
$divide = fn(int $x): callable => fn(int $y): float => $x / $y;

// Equivalent to $divide(10)(2)
echo $r(2)($divide)(10); // Outputs: 5

• Lambda: λabc.ac(bc)
• Purpose: The substitution combinator. It applies a third argument c to both a and b, then applies the result of a(c) to the result of b(c). It is fundamental to combinatory logic.

use loophp\combinator\Combinators;

$s = Combinators::S();
$add = fn(int $x): callable => fn(int $y): int => $x + $y;
$square = fn(int $x): int => $x * $x;

// Equivalent to $add($x)($square($x)) where $x is 3. So 3 + (3*3)
echo $s($add)($square)(3); // Outputs: 12

• Lambda: λabc.a(bc)c
• Purpose: A variation of the Starling that provides the final argument c to the outer function a as well. Useful for functions that need both the result of an operation and the original value, such as logging or debugging.

use loophp\combinator\Combinators;

$s_ = Combinators::S_();
$log = fn(string $result): callable => fn(string $original): string => "Input '$original' produced '$result'";
$transform = 'strtoupper';

// Equivalent to $log(strtoupper('hello'))('hello')
$logTransformation = $s_($log)($transform);

echo $logTransformation('hello'); // Outputs: Input 'hello' produced 'HELLO'

• Lambda: λabcd.a((bd)(cd))
• Purpose: Applies two different functions b and c to the same data d, and then combines their results with a third function a. In Haskell, this is similar to liftA2.

use loophp\combinator\Combinators;

$s2 = Combinators::S2();
$combine = fn(int $product): callable => fn(int $sum): string => "Sum: $sum, Product: $product";
$sum = fn(int $x): callable => fn(int $y): int => $x + $y;
$product = fn(int $x): callable => fn(int $y): int => $x * $y;
$value = 3;

// This is a bit mind-bending. The lambda is a((bd)(cd)).
// Let's find a better example. `a` must take one argument.
$format = fn(int $result): string => "Final result is: $result";
$multiply = fn(int $x): callable => fn(int $y): int => $x * $y;
$addOne = fn(int $x): int => $x + 1;
$d = 5;

// Equivalent to $format($multiply(5)($addOne(5))) -> $format(5 * 6)
echo $s2($format)($multiply)($addOne)($d); // Outputs: Final result is: 30

• Lambda: λab.ba
• Purpose: Reverse application. Applies function b to argument a. This is (&) in Haskell and is useful for data-last programming styles.

use loophp\combinator\Combinators;

$t = Combinators::T();
$multiplyByTwo = fn(int $x): int => $x * 2;

// Instead of $multiplyByTwo(5)
echo $t(5)($multiplyByTwo); // Outputs: 10
```</details>

<details>
<summary>U (Turing) Combinator</summary>

*   **Lambda:** `λab.b(aab)`
*   **Purpose:** A fixed-point combinator that can hold state. `b` is applied to `a` applied to itself applied to `b`.

```php
use loophp\combinator\Combinators;

$u = Combinators::U();
$factorialGenerator = static fn(callable $f): callable =>
    static fn(int $n): int => (0 === $n) ? 1 : $n * $f($f)($n - 1);

$factorial = $u($factorialGenerator);

echo $factorial(5); // Outputs: 120

• Lambda: λabc.cab
• Purpose: Argument swapping. Given c, a, b, it calls c(a)(b).

use loophp\combinator\Combinators;

$v = Combinators::V();
$str_replace = 'str_replace';
$search = 'foo';
$replace = 'bar';

// Creates a function that replaces 'foo' with 'bar' in a given subject string.
$replaceFoo = $v($search)($replace)($str_replace);

echo $replaceFoo('this is foo'); // Outputs: this is bar

• Lambda: λab.abb
• Purpose: Duplicates an argument. It applies function a to argument b twice.

use loophp\combinator\Combinators;

$w = Combinators::W();
$add = fn(int $x): callable => fn(int $y): int => $x + $y;

// Equivalent to $add(5)(5)
echo $w($add)(5); // Outputs: 10

• Purpose: The Y and Z combinators are used to achieve recursion in languages that do not have built-in recursive syntax. They are "fixed-point" finders for functions. The Z combinator is a variant that works in strict (eagerly evaluated) languages like PHP without causing infinite loops during construction.

use loophp\combinator\Combinators;
use Closure;

// A "generator" function that describes one step of the factorial calculation.
// It takes the recursive function ($fact) as an argument.
$factorialGenerator = static fn (Closure $fact): Closure =>
    static fn (int $n): int => (0 === $n) ? 1 : ($n * $fact($n - 1));

// The Z combinator creates a recursive factorial function from the generator.
$factorial = Combinators::Z()($factorialGenerator);

echo $factorial(6); // Outputs: 720

// The Y combinator can also be used, as this library implements it in a way
// that is safe for eager evaluation.
$fibonacciGenerator = static fn (Closure $fibo): Closure =>
    static fn (int $n): int => ($n <= 1) ? $n : $fibo($n - 1) + $fibo($n - 2);

$fibonacci = Combinators::Y()($fibonacciGenerator);

echo $fibonacci(10); // Outputs: 55