├── .prettierrc
├── composer.json
├── renovate.json
└── src
    ├── Combinator.php
    ├── Combinator
        ├── A.php
        ├── B.php
        ├── Blackbird.php
        ├── C.php
        ├── D.php
        ├── E.php
        ├── F.php
        ├── G.php
        ├── H.php
        ├── I.php
        ├── J.php
        ├── K.php
        ├── Ki.php
        ├── L.php
        ├── M.php
        ├── O.php
        ├── Omega.php
        ├── Phoenix.php
        ├── Psi.php
        ├── Q.php
        ├── R.php
        ├── S.php
        ├── S2.php
        ├── S_.php
        ├── T.php
        ├── U.php
        ├── V.php
        ├── W.php
        ├── Y.php
        └── Z.php
    ├── Combinators.php
    └── Contract
        └── Combinator.php


/.prettierrc:
--------------------------------------------------------------------------------
1 | {
2 |     "proseWrap": "always"
3 | }
4 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "loophp/combinator",
 3 |     "description": "A curated list of combinators",
 4 |     "license": "MIT",
 5 |     "type": "library",
 6 |     "keywords": [
 7 |         "combinator",
 8 |         "combinatory logic",
 9 |         "educational",
10 |         "functional programming"
11 |     ],
12 |     "authors": [
13 |         {
14 |             "name": "Pol Dellaiera",
15 |             "email": "pol.dellaiera@protonmail.com"
16 |         }
17 |     ],
18 |     "support": {
19 |         "issues": "https://github.com/loophp/combinator/issues",
20 |         "source": "https://github.com/loophp/combinator"
21 |     },
22 |     "funding": [
23 |         {
24 |             "type": "github",
25 |             "url": "https://github.com/drupol"
26 |         }
27 |     ],
28 |     "require": {
29 |         "php": ">= 8.1"
30 |     },
31 |     "require-dev": {
32 |         "ext-pcov": "*",
33 |         "drupol/php-conventions": "^6",
34 |         "friends-of-phpspec/phpspec-code-coverage": "^6",
35 |         "infection/infection": ">= 0.26",
36 |         "infection/phpspec-adapter": "^0.2",
37 |         "phpspec/phpspec": "^7",
38 |         "phpstan/phpstan-strict-rules": "^1.0"
39 |     },
40 |     "autoload": {
41 |         "psr-4": {
42 |             "loophp\\combinator\\": "./src/"
43 |         }
44 |     },
45 |     "autoload-dev": {
46 |         "psr-4": {
47 |             "tests\\loophp\\combinator\\": "./tests/src/"
48 |         }
49 |     },
50 |     "config": {
51 |         "allow-plugins": {
52 |             "composer/package-versions-deprecated": true,
53 |             "phpstan/extension-installer": true,
54 |             "ergebnis/composer-normalize": true,
55 |             "phpro/grumphp": true,
56 |             "infection/extension-installer": true
57 |         },
58 |         "sort-packages": true
59 |     },
60 |     "scripts": {
61 |         "changelog-unreleased": "auto-changelog -c .auto-changelog -u",
62 |         "changelog-version": "auto-changelog -c .auto-changelog -v",
63 |         "grumphp": "./vendor/bin/grumphp run",
64 |         "infection": "vendor/bin/infection run -j 2",
65 |         "phpspec": "vendor/bin/phpspec run -vvv --stop-on-failure"
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/renovate.json:
--------------------------------------------------------------------------------
1 | {
2 |     "$schema": "https://docs.renovatebot.com/renovate-schema.json",
3 |     "extends": ["config:base"]
4 | }
5 | 


--------------------------------------------------------------------------------
/src/Combinator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Contract\Combinator as CombinatorInterface;
14 | 
15 | abstract class Combinator implements CombinatorInterface
16 | {
17 |     final public function __construct()
18 |     {
19 |     }
20 | 
21 |     abstract public function __invoke(): Closure;
22 | 
23 |     public static function of(): Closure
24 |     {
25 |         return (new static())->__invoke();
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Combinator/A.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | /**
16 |  * @template NewAType
17 |  * @template NewBType
18 |  */
19 | final class A extends Combinator
20 | {
21 |     /**
22 |      * @return Closure(callable(NewAType): NewBType): Closure(NewAType): NewBType
23 |      */
24 |     public function __invoke(): Closure
25 |     {
26 |         return
27 |             /**
28 |              * @param callable(NewAType): NewBType $f
29 |              *
30 |              * @return Closure(NewAType): NewBType
31 |              */
32 |             static fn (callable $f): Closure =>
33 |                 /**
34 |                  * @param NewAType $x
35 |                  *
36 |                  * @return NewBType
37 |                  */
38 |                 static fn (mixed $x): mixed => $f($x);
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Combinator/B.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | /**
16 |  * Class B.
17 |  *
18 |  * @template NewAType
19 |  * @template NewBType
20 |  * @template NewCType
21 |  *
22 |  * phpcs:disable Generic.Files.LineLength.TooLong
23 |  */
24 | final class B extends Combinator
25 | {
26 |     /**
27 |      * @return Closure(callable(NewAType): NewBType): Closure(callable(NewCType): NewAType): Closure(NewCType): NewBType
28 |      */
29 |     public function __invoke(): Closure
30 |     {
31 |         return
32 |             /**
33 |              * @param callable(NewAType): NewBType $f
34 |              *
35 |              * @return Closure(callable(NewCType): NewAType): Closure(NewCType): NewBType
36 |              */
37 |             static fn (callable $f): Closure =>
38 |                 /**
39 |                  * @param callable(NewCType): NewAType $g
40 |                  *
41 |                  * @return Closure(NewCType): NewBType
42 |                  */
43 |                 static fn (callable $g): Closure =>
44 |                     /**
45 |                      * @param NewCType $x
46 |                      *
47 |                      * @return NewBType
48 |                      */
49 |                     static fn (mixed $x): mixed => ($f)(($g)($x));
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/Combinator/Blackbird.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | /**
16 |  * Class Blackbird.
17 |  *
18 |  * @template NewAType
19 |  * @template NewBType
20 |  * @template NewCType
21 |  * @template NewDType
22 |  *
23 |  * phpcs:disable Generic.Files.LineLength.TooLong
24 |  */
25 | final class Blackbird extends Combinator
26 | {
27 |     /**
28 |      * @return Closure(callable(NewCType): NewDType): Closure(callable(NewAType): callable(NewBType): NewCType): Closure(NewAType): Closure(NewBType): NewCType
29 |      */
30 |     public function __invoke(): Closure
31 |     {
32 |         return B::of()(B::of())(B::of());
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Combinator/C.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | /**
16 |  * Class C.
17 |  *
18 |  * @template NewAType
19 |  * @template NewBType
20 |  * @template NewCType
21 |  *
22 |  * phpcs:disable Generic.Files.LineLength.TooLong
23 |  */
24 | final class C extends Combinator
25 | {
26 |     /**
27 |      * @return Closure(callable(NewAType): callable(NewBType): NewCType): Closure(NewBType): Closure(NewAType): NewCType
28 |      */
29 |     public function __invoke(): Closure
30 |     {
31 |         return
32 |             /**
33 |              * @param callable(NewAType): (callable(NewBType): NewCType) $f
34 |              *
35 |              * @return Closure(NewBType): Closure(NewAType): NewCType
36 |              */
37 |             static fn (callable $f): Closure =>
38 |                 /**
39 |                  * @param NewBType $x
40 |                  *
41 |                  * @return Closure(NewAType): NewCType
42 |                  */
43 |                 static fn (mixed $x): Closure =>
44 |                     /**
45 |                      * @param NewAType $y
46 |                      *
47 |                      * @return NewCType
48 |                      */
49 |                     static fn (mixed $y) => ($f)($y)($x);
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/Combinator/D.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | /**
16 |  * Class D.
17 |  *
18 |  * @template NewAType
19 |  * @template NewBType
20 |  * @template NewCType
21 |  * @template NewDType
22 |  *
23 |  * phpcs:disable Generic.Files.LineLength.TooLong
24 |  * phpcs:disable Generic.WhiteSpace.ScopeIndent.IncorrectExact
25 |  */
26 | final class D extends Combinator
27 | {
28 |     /**
29 |      * @return Closure(callable(NewAType): Closure(NewCType): NewDType): Closure(NewAType): Closure(callable(NewBType): NewCType): Closure(NewBType): NewDType
30 |      */
31 |     public function __invoke(): Closure
32 |     {
33 |         return
34 |             /**
35 |              * @param callable(NewAType): (Closure(NewCType): NewDType) $f
36 |              *
37 |              * @return Closure(NewAType): Closure(callable(NewBType): NewCType): Closure(NewBType): NewDType
38 |              */
39 |             static fn (callable $f): Closure =>
40 |                 /**
41 |                  * @param NewAType $x
42 |                  *
43 |                  * @return Closure(callable(NewBType): NewCType): Closure(NewBType): NewDType
44 |                  */
45 |                 static fn (mixed $x): Closure =>
46 |                     /**
47 |                      * @param callable(NewBType): NewCType $g
48 |                      *
49 |                      * @return Closure(NewBType): NewDType
50 |                      */
51 |                     static fn (callable $g): Closure =>
52 |                         /**
53 |                          * @param NewBType $y
54 |                          *
55 |                          * @return NewDType
56 |                          */
57 |                         static fn (mixed $y): mixed => (($f)($x))(($g)($y));
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/src/Combinator/E.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | /**
16 |  * Class E.
17 |  *
18 |  * @template NewAType
19 |  * @template NewBType
20 |  * @template NewCType
21 |  * @template NewDType
22 |  * @template NewEType
23 |  *
24 |  * phpcs:disable Generic.Files.LineLength.TooLong
25 |  * phpcs:disable Generic.WhiteSpace.ScopeIndent.IncorrectExact
26 |  */
27 | final class E extends Combinator
28 | {
29 |     /**
30 |      * @return Closure(callable(NewAType): callable(NewDType): NewEType): Closure(NewAType): Closure(callable(NewBType): callable(NewCType): NewDType): Closure(NewBType): Closure(NewCType): NewEType
31 |      */
32 |     public function __invoke(): Closure
33 |     {
34 |         return
35 |             /**
36 |              * @param callable(NewAType): (callable(NewDType): NewEType) $f
37 |              *
38 |              * @return Closure(NewAType): Closure(callable(NewBType): callable(NewCType): NewDType): Closure(NewBType): Closure(NewCType): NewEType
39 |              */
40 |             static fn (callable $f): Closure =>
41 |                 /**
42 |                  * @param NewAType $x
43 |                  *
44 |                  * @return Closure(callable(NewBType): callable(NewCType): NewDType): Closure(NewBType): Closure(NewCType): NewEType
45 |                  */
46 |                 static fn (mixed $x): Closure =>
47 |                     /**
48 |                      * @param callable(NewBType): (callable(NewCType): NewDType) $g
49 |                      *
50 |                      * @return Closure(NewBType): Closure(NewCType): NewEType
51 |                      */
52 |                     static fn (callable $g): Closure =>
53 |                         /**
54 |                          * @param NewBType $y
55 |                          *
56 |                          * @return Closure(NewCType): NewEType
57 |                          */
58 |                         static fn (mixed $y): Closure =>
59 |                             /**
60 |                              * @param NewCType $z
61 |                              *
62 |                              * @return NewEType
63 |                              */
64 |                             static fn (mixed $z): mixed => (($f)($x))((($g)($y))($z));
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Combinator/F.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | /**
16 |  * Class F.
17 |  *
18 |  * @template NewAType
19 |  * @template NewBType
20 |  * @template NewCType
21 |  *
22 |  * phpcs:disable Generic.Files.LineLength.TooLong
23 |  * phpcs:disable Generic.WhiteSpace.ScopeIndent.IncorrectExact
24 |  */
25 | final class F extends Combinator
26 | {
27 |     /**
28 |      * @return Closure(NewAType): Closure(NewBType): Closure(callable(NewBType): Closure(NewAType): NewCType): NewCType
29 |      */
30 |     public function __invoke(): Closure
31 |     {
32 |         return
33 |             /**
34 |              * @param NewAType $x
35 |              *
36 |              * @return Closure(NewBType): Closure(callable(NewBType): Closure(NewAType): NewCType): NewCType
37 |              */
38 |             static fn (mixed $x): Closure =>
39 |                 /**
40 |                  * @param NewBType $y
41 |                  *
42 |                  * @return Closure(callable(NewBType): Closure(NewAType): NewCType): NewCType
43 |                  */
44 |                 static fn (mixed $y): Closure =>
45 |                     /**
46 |                      * @param callable(NewBType): (Closure(NewAType): NewCType) $f
47 |                      *
48 |                      * @return NewCType
49 |                      */
50 |                     static fn (callable $f): mixed => ($f)($y)($x);
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/src/Combinator/G.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | /**
16 |  * Class G.
17 |  *
18 |  * @template NewAType
19 |  * @template NewBType
20 |  * @template NewCType
21 |  * @template NewDType
22 |  *
23 |  * phpcs:disable Generic.Files.LineLength.TooLong
24 |  * phpcs:disable Generic.WhiteSpace.ScopeIndent.IncorrectExact
25 |  */
26 | final class G extends Combinator
27 | {
28 |     /**
29 |      * @return Closure(callable(NewAType): callable(NewBType): NewCType): Closure(callable(NewDType): NewBType): Closure(NewDType): Closure(NewAType): NewCType
30 |      */
31 |     public function __invoke(): Closure
32 |     {
33 |         return
34 |             /**
35 |              * @param callable(NewAType): (callable(NewBType): NewCType) $f
36 |              *
37 |              * @return Closure(callable(NewDType): NewBType): Closure(NewDType): Closure(NewAType): NewCType
38 |              */
39 |             static fn (callable $f): Closure =>
40 |                 /**
41 |                  * @param callable(NewDType): NewBType $g
42 |                  *
43 |                  * @return Closure(NewDType): Closure(NewAType): NewCType
44 |                  */
45 |                 static fn (callable $g): Closure =>
46 |                     /**
47 |                      * @param NewDType $x
48 |                      *
49 |                      * @return Closure(NewAType): NewCType
50 |                      */
51 |                     static fn (mixed $x): Closure =>
52 |                         /**
53 |                          * @param NewAType $y
54 |                          *
55 |                          * @return NewCType
56 |                          */
57 |                         static fn (mixed $y): mixed => (($f)($y))(($g)($x));
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/src/Combinator/H.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | /**
16 |  * Class H.
17 |  *
18 |  * @template NewAType
19 |  * @template NewBType
20 |  * @template NewCType
21 |  *
22 |  * phpcs:disable Generic.Files.LineLength.TooLong
23 |  * phpcs:disable Generic.WhiteSpace.ScopeIndent.IncorrectExact
24 |  */
25 | final class H extends Combinator
26 | {
27 |     /**
28 |      * @return Closure(callable(NewAType): Closure(NewBType): Closure(NewAType): NewCType): Closure(NewAType): Closure(NewBType): NewCType
29 |      */
30 |     public function __invoke(): Closure
31 |     {
32 |         return
33 |             /**
34 |              * @param callable(NewAType): (Closure(NewBType): (Closure(NewAType): NewCType)) $f
35 |              *
36 |              * @return Closure(NewAType): Closure(NewBType): NewCType
37 |              */
38 |             static fn (callable $f): Closure =>
39 |                 /**
40 |                  * @param NewAType $x
41 |                  *
42 |                  * @return Closure(NewBType): NewCType
43 |                  */
44 |                 static fn (mixed $x): Closure =>
45 |                     /**
46 |                      * @param NewBType $y
47 |                      *
48 |                      * @return NewCType
49 |                      */
50 |                     static fn (mixed $y): mixed => ((($f)($x))($y))($x);
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/src/Combinator/I.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | /**
16 |  * @template NewAType
17 |  */
18 | final class I extends Combinator
19 | {
20 |     /**
21 |      * @return Closure(NewAType): NewAType
22 |      */
23 |     public function __invoke(): Closure
24 |     {
25 |         return
26 |             /**
27 |              * @param NewAType $x
28 |              *
29 |              * @return NewAType
30 |              */
31 |             static fn (mixed $x): mixed => $x;
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Combinator/J.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | /**
16 |  * Class J.
17 |  *
18 |  * @template NewAType
19 |  * @template NewBType
20 |  *
21 |  * phpcs:disable Generic.Files.LineLength.TooLong
22 |  * phpcs:disable Generic.WhiteSpace.ScopeIndent.IncorrectExact
23 |  */
24 | final class J extends Combinator
25 | {
26 |     /**
27 |      * @return Closure(callable(NewAType): Closure(NewBType): NewBType): Closure(NewAType):(Closure(NewBType):(Closure(NewAType):(NewBType)))
28 |      */
29 |     public function __invoke(): Closure
30 |     {
31 |         return
32 |             /**
33 |              * @param callable(NewAType): (Closure(NewBType): NewBType) $f
34 |              *
35 |              * @return Closure(NewAType): Closure(NewBType): Closure(NewAType): NewBType
36 |              */
37 |             static fn (callable $f): Closure =>
38 |                 /**
39 |                  * @param NewAType $x
40 |                  *
41 |                  * @return Closure(NewBType): Closure(NewAType): NewBType
42 |                  */
43 |                 static fn (mixed $x): Closure =>
44 |                     /**
45 |                      * @param NewBType $y
46 |                      *
47 |                      * @return Closure(NewAType): NewBType
48 |                      */
49 |                     static fn (mixed $y): Closure =>
50 |                         /**
51 |                          * @param NewAType $z
52 |                          *
53 |                          * @return NewBType
54 |                          */
55 |                         static fn (mixed $z): mixed => (($f)($x))((($f)($z))($y));
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/Combinator/K.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | /**
16 |  * @template NewAType
17 |  * @template NewBType
18 |  */
19 | final class K extends Combinator
20 | {
21 |     /**
22 |      * @return Closure(NewAType): Closure(NewBType): NewAType
23 |      */
24 |     public function __invoke(): Closure
25 |     {
26 |         return
27 |             /**
28 |              * @param NewAType $x
29 |              *
30 |              * @return Closure(NewBType): NewAType
31 |              */
32 |             static fn (mixed $x): Closure =>
33 |                 /**
34 |                  * @param NewBType $y
35 |                  *
36 |                  * @return NewAType
37 |                  */
38 |                 static fn (mixed $y) => $x;
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Combinator/Ki.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | /**
16 |  * @template NewAType
17 |  * @template NewBType
18 |  */
19 | final class Ki extends Combinator
20 | {
21 |     /**
22 |      * @return Closure(NewAType): Closure(NewBType): NewBType
23 |      */
24 |     public function __invoke(): Closure
25 |     {
26 |         return
27 |             /**
28 |              * @param NewAType $x
29 |              *
30 |              * @return Closure(NewBType): NewBType
31 |              */
32 |             static fn (mixed $x): Closure =>
33 |                 /**
34 |                  * @param NewBType $y
35 |                  *
36 |                  * @return NewBType
37 |                  */
38 |                 static fn (mixed $y) => $y;
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Combinator/L.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | final class L extends Combinator
16 | {
17 |     /**
18 |      * @psalm-suppress MissingClosureReturnType
19 |      */
20 |     public function __invoke(): Closure
21 |     {
22 |         return static fn (callable $f): Closure => static fn (callable $g): mixed => ($f)(($g)($g));
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Combinator/M.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | final class M extends Combinator
16 | {
17 |     public function __invoke(): Closure
18 |     {
19 |         return static fn (callable $f): mixed => $f($f);
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Combinator/O.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | /**
16 |  * Class O.
17 |  *
18 |  * @template NewAType
19 |  * @template NewBType
20 |  *
21 |  * phpcs:disable Generic.Files.LineLength.TooLong
22 |  * phpcs:disable Generic.WhiteSpace.ScopeIndent.IncorrectExact
23 |  */
24 | final class O extends Combinator
25 | {
26 |     /**
27 |      * @return Closure(callable(callable(NewAType): NewBType): NewAType): Closure(callable(NewAType): (NewBType)): (NewBType)
28 |      */
29 |     public function __invoke(): Closure
30 |     {
31 |         return
32 |             /**
33 |              * @param callable(callable(NewAType): NewBType): NewAType $f
34 |              *
35 |              * @return Closure(callable(NewAType): NewBType): NewBType
36 |              */
37 |             static fn (callable $f): Closure =>
38 |                 /**
39 |                  * @param callable(NewAType): NewBType $g
40 |                  *
41 |                  * @return NewBType
42 |                  */
43 |                 static fn (callable $g): mixed => ($g)((($f)($g)));
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Combinator/Omega.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | final class Omega extends Combinator
16 | {
17 |     public function __invoke(): Closure
18 |     {
19 |         return
20 |             /**
21 |              * @param callable(callable): (callable(callable): callable) $f
22 |              */
23 |             static fn (callable $f): mixed => ($f)($f)(($f)($f));
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Combinator/Phoenix.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | /**
16 |  * Class Phoenix.
17 |  *
18 |  * @template NewAType
19 |  * @template NewBType
20 |  * @template NewCType
21 |  * @template NewDType
22 |  *
23 |  * phpcs:disable Generic.Files.LineLength.TooLong
24 |  * phpcs:disable Generic.WhiteSpace.ScopeIndent.IncorrectExact
25 |  */
26 | final class Phoenix extends Combinator
27 | {
28 |     /**
29 |      * @return Closure(callable(NewAType): callable(NewBType): NewCType): Closure(callable(NewDType): NewAType): Closure(callable(NewDType): NewBType): Closure(NewDType): NewCType
30 |      */
31 |     public function __invoke(): Closure
32 |     {
33 |         return
34 |             /**
35 |              * @param callable(NewAType): (callable(NewBType): NewCType) $f
36 |              *
37 |              * @return Closure(callable(NewDType): NewAType): Closure(callable(NewDType): NewBType): Closure(NewDType): NewCType
38 |              */
39 |             static fn (callable $f): Closure =>
40 |                 /**
41 |                  * @param callable(NewDType): NewAType $g
42 |                  *
43 |                  * @return Closure(callable(NewDType): NewBType): Closure(NewDType): NewCType
44 |                  */
45 |                 static fn (callable $g): Closure =>
46 |                     /**
47 |                      * @param callable(NewDType): NewBType $h
48 |                      *
49 |                      * @return Closure(NewDType): NewCType
50 |                      */
51 |                     static fn (callable $h): Closure =>
52 |                         /**
53 |                          * @param NewDType $x
54 |                          *
55 |                          * @return NewCType
56 |                          */
57 |                         static fn (mixed $x): mixed => ($f)(($g)($x))(($h)($x));
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/src/Combinator/Psi.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | /**
16 |  * Class Psi.
17 |  *
18 |  * @template NewAType
19 |  * @template NewBType
20 |  * @template NewCType
21 |  *
22 |  * phpcs:disable Generic.Files.LineLength.TooLong
23 |  * phpcs:disable Generic.WhiteSpace.ScopeIndent.IncorrectExact
24 |  */
25 | final class Psi extends Combinator
26 | {
27 |     /**
28 |      * @return Closure(callable(NewAType): callable(NewAType): NewBType): Closure(callable(NewCType): NewAType): Closure(NewCType): Closure(NewCType): NewBType
29 |      */
30 |     public function __invoke(): Closure
31 |     {
32 |         return
33 |             /**
34 |              * @param callable(NewAType): (callable(NewAType): NewBType) $f
35 |              *
36 |              * @return Closure(callable(NewCType): NewAType): Closure(NewCType): Closure(NewCType): NewBType
37 |              */
38 |             static fn (callable $f): Closure =>
39 |                 /**
40 |                  * @param callable(NewCType): NewAType $g
41 |                  *
42 |                  * @return Closure(NewCType): Closure(NewCType): NewBType
43 |                  */
44 |                 static fn (callable $g): Closure =>
45 |                     /**
46 |                      * @param NewCType $x
47 |                      *
48 |                      * @return Closure(NewCType): NewBType
49 |                      */
50 |                     static fn (mixed $x): Closure =>
51 |                         /**
52 |                          * @param NewCType $y
53 |                          *
54 |                          * @return NewBType
55 |                          */
56 |                         static fn (mixed $y): mixed => ($f)(($g)($x))(($g)($y));
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/src/Combinator/Q.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | /**
16 |  * Class Q.
17 |  *
18 |  * @template NewAType
19 |  * @template NewBType
20 |  * @template NewCType
21 |  *
22 |  * phpcs:disable Generic.Files.LineLength.TooLong
23 |  * phpcs:disable Generic.WhiteSpace.ScopeIndent.IncorrectExact
24 |  */
25 | final class Q extends Combinator
26 | {
27 |     /**
28 |      * @return Closure(callable(NewAType): NewBType): Closure(callable(NewBType): NewCType):Closure(NewAType): NewCType
29 |      */
30 |     public function __invoke(): Closure
31 |     {
32 |         return
33 |             /**
34 |              * @param callable(NewAType): NewBType $f
35 |              *
36 |              * @return Closure(callable(NewBType): NewCType):Closure(NewAType): NewCType
37 |              */
38 |             static fn (callable $f): Closure =>
39 |                 /**
40 |                  * @param callable(NewBType): NewCType $g
41 |                  *
42 |                  * @return Closure(NewAType): NewCType
43 |                  */
44 |                 static fn (callable $g): Closure =>
45 |                     /**
46 |                      * @param NewAType $x
47 |                      *
48 |                      * @return NewCType
49 |                      */
50 |                     static fn (mixed $x): mixed => ($g)((($f)($x)));
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/src/Combinator/R.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | /**
16 |  * @template NewAType
17 |  * @template NewBType
18 |  * @template NewCType
19 |  */
20 | final class R extends Combinator
21 | {
22 |     /**
23 |      * @return Closure(NewAType): Closure(callable(NewBType): Closure(NewAType): NewCType): Closure(NewBType): NewCType
24 |      */
25 |     public function __invoke(): Closure
26 |     {
27 |         return
28 |             /**
29 |              * @param NewAType $x
30 |              *
31 |              * @return Closure(callable(NewBType): Closure(NewAType): NewCType): Closure(NewBType): NewCType
32 |              */
33 |             static fn (mixed $x): Closure =>
34 |                 /**
35 |                  * @param callable(NewBType): (Closure(NewAType): NewCType) $f
36 |                  *
37 |                  * @return Closure(NewBType): NewCType
38 |                  */
39 |                 static fn (callable $f): Closure =>
40 |                     /**
41 |                      * @param NewBType $y
42 |                      *
43 |                      * @return NewCType
44 |                      */
45 |                     static fn (mixed $y): mixed => (($f)($y))($x);
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Combinator/S.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | /**
16 |  * Class S.
17 |  *
18 |  * @template NewAType
19 |  * @template NewBType
20 |  * @template NewCType
21 |  *
22 |  * phpcs:disable Generic.Files.LineLength.TooLong
23 |  * phpcs:disable Generic.WhiteSpace.ScopeIndent.IncorrectExact
24 |  */
25 | final class S extends Combinator
26 | {
27 |     /**
28 |      * @return Closure(callable(NewAType): Closure(NewBType): NewCType): Closure(callable(NewAType): NewBType): Closure(NewAType): NewCType
29 |      */
30 |     public function __invoke(): Closure
31 |     {
32 |         return
33 |             /**
34 |              * @param callable(NewAType): (Closure(NewBType): NewCType) $f
35 |              *
36 |              * @return Closure(callable(NewAType): NewBType): Closure(NewAType): NewCType
37 |              */
38 |             static fn (callable $f): Closure =>
39 |                 /**
40 |                  * @param callable(NewAType): NewBType $g
41 |                  *
42 |                  * @return Closure(NewAType): NewCType
43 |                  */
44 |                 static fn (callable $g): Closure =>
45 |                     /**
46 |                      * @param NewAType $x
47 |                      *
48 |                      * @return NewCType
49 |                      */
50 |                     static fn (mixed $x): mixed => $f($x)($g($x));
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/src/Combinator/S2.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | /**
16 |  * Class S2.
17 |  *
18 |  * @template NewAType
19 |  * @template NewBType
20 |  * @template NewCType
21 |  * @template NewDType
22 |  *
23 |  * phpcs:disable Generic.Files.LineLength.TooLong
24 |  * phpcs:disable Generic.WhiteSpace.ScopeIndent.IncorrectExact
25 |  */
26 | final class S2 extends Combinator
27 | {
28 |     /**
29 |      * @return Closure(callable(NewBType): Closure(NewCType): NewDType): Closure(callable(NewAType): NewBType): Closure(callable(NewAType): NewCType): Closure(NewAType): NewDType
30 |      */
31 |     public function __invoke(): Closure
32 |     {
33 |         return
34 |             /**
35 |              * @param callable(NewBType): (Closure(NewCType): NewDType) $f
36 |              *
37 |              * @return Closure(callable(NewAType): NewBType): Closure(callable(NewAType): NewCType): Closure(NewAType): NewDType
38 |              */
39 |             static fn (callable $f): Closure =>
40 |                 /**
41 |                  * @param callable(NewAType): NewBType $g
42 |                  *
43 |                  * @return Closure(callable(NewAType): NewCType): Closure(NewAType): NewDType
44 |                  */
45 |                 static fn (callable $g): Closure =>
46 |                     /**
47 |                      * @param callable(NewAType): NewCType $h
48 |                      *
49 |                      * @return Closure(NewAType): NewDType
50 |                      */
51 |                     static fn (callable $h): Closure =>
52 |                         /**
53 |                          * @param NewAType $x
54 |                          *
55 |                          * @return NewDType
56 |                          */
57 |                         static fn (mixed $x): mixed => $f($g($x))($h($x));
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/src/Combinator/S_.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | /**
16 |  * Class S_.
17 |  *
18 |  * @template NewAType
19 |  * @template NewBType
20 |  * @template NewCType
21 |  *
22 |  * phpcs:disable Generic.Files.LineLength.TooLong
23 |  * phpcs:disable Generic.WhiteSpace.ScopeIndent.IncorrectExact
24 |  * phpcs:disable Squiz.Classes.ValidClassName.NotCamelCaps
25 |  */
26 | final class S_ extends Combinator
27 | {
28 |     /**
29 |      * @return Closure(callable(NewAType): Closure(NewBType): NewCType): Closure(callable(NewBType): NewAType): Closure(NewBType): NewCType
30 |      */
31 |     public function __invoke(): Closure
32 |     {
33 |         return
34 |             /**
35 |              * @param callable(NewAType): (Closure(NewBType): NewCType) $f
36 |              *
37 |              * @return Closure(callable(NewBType): NewAType): Closure(NewBType): NewCType
38 |              */
39 |             static fn (callable $f): Closure =>
40 |                 /**
41 |                  * @param callable(NewBType): NewAType $g
42 |                  *
43 |                  * @return Closure(NewBType): NewCType
44 |                  */
45 |                 static fn (callable $g): Closure =>
46 |                     /**
47 |                      * @param NewBType $x
48 |                      *
49 |                      * @return NewCType
50 |                      */
51 |                     static fn (mixed $x): mixed => $f($g($x))($x);
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/src/Combinator/T.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | /**
16 |  * @template NewAType
17 |  * @template NewBType
18 |  */
19 | final class T extends Combinator
20 | {
21 |     /**
22 |      * @return Closure(NewAType): Closure(callable(NewAType): NewBType): NewBType
23 |      */
24 |     public function __invoke(): Closure
25 |     {
26 |         return
27 |             /**
28 |              * @param NewAType $x
29 |              *
30 |              * @return Closure(callable(NewAType): NewBType): NewBType
31 |              */
32 |             static fn (mixed $x): Closure =>
33 |                 /**
34 |                  * @param callable(NewAType): NewBType $f
35 |                  *
36 |                  * @return NewBType
37 |                  */
38 |                 static fn (callable $f): mixed => ($f)($x);
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Combinator/U.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | final class U extends Combinator
16 | {
17 |     /**
18 |      * @suppress MissingClosureReturnType
19 |      * @suppress MissingClosureParamType
20 |      * @suppress MixedArgumentTypeCoercion
21 |      */
22 |     public function __invoke(): Closure
23 |     {
24 |         return
25 |             /**
26 |              * @param callable(callable): callable $f
27 |              *
28 |              * @return Closure(callable): mixed
29 |              */
30 |             static fn (callable $f): Closure => static fn (callable $g): mixed => $g(($f($f))($g));
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Combinator/V.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | /**
16 |  * @template NewAType
17 |  * @template NewBType
18 |  * @template NewCType
19 |  */
20 | final class V extends Combinator
21 | {
22 |     /**
23 |      * @return Closure(NewAType): Closure(NewBType): Closure(callable(NewAType): callable(NewBType): NewCType): NewCType
24 |      */
25 |     public function __invoke(): Closure
26 |     {
27 |         return
28 |             /**
29 |              * @param NewAType $x
30 |              *
31 |              * @return Closure(NewBType): Closure(callable(NewAType): callable(NewBType): NewCType): NewCType
32 |              */
33 |             static fn (mixed $x): Closure =>
34 |                 /**
35 |                  * @param NewBType $y
36 |                  *
37 |                  * @return Closure(callable(NewAType): callable(NewBType): NewCType): NewCType
38 |                  */
39 |                 static fn (mixed $y): Closure =>
40 |                     /**
41 |                      * @param callable(NewAType): (callable(NewBType): NewCType) $f
42 |                      *
43 |                      * @return NewCType
44 |                      */
45 |                     static fn (callable $f): mixed => (($f)($x))($y);
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Combinator/W.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | /**
16 |  * @template NewAType
17 |  * @template NewBType
18 |  */
19 | final class W extends Combinator
20 | {
21 |     /**
22 |      * @return Closure(callable(NewAType): callable(NewAType): NewBType): Closure(NewAType): NewBType
23 |      */
24 |     public function __invoke(): Closure
25 |     {
26 |         return
27 |             /**
28 |              * @param callable(NewAType): (callable(NewAType): NewBType) $f
29 |              *
30 |              * @return Closure(NewAType): NewBType
31 |              */
32 |             static fn (callable $f): Closure =>
33 |                 /**
34 |                  * @param NewAType $x
35 |                  *
36 |                  * @return NewBType
37 |                  */
38 |                 static fn (mixed $x): mixed => ($f)($x)($x);
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Combinator/Y.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | final class Y extends Combinator
16 | {
17 |     /**
18 |      * @psalm-suppress MixedInferredReturnType
19 |      */
20 |     public function __invoke(): Closure
21 |     {
22 |         return
23 |             /**
24 |              * @psalm-suppress MissingClosureReturnType
25 |              * @psalm-suppress MissingClosureParamType
26 |              * @psalm-suppress MixedArgumentTypeCoercion
27 |              * @psalm-suppress ImpureMethodCall
28 |              * @psalm-suppress MixedFunctionCall
29 |              * @psalm-suppress MixedReturnStatement
30 |              * @psalm-suppress UnusedClosureParam
31 |              */
32 |             static fn (callable $f): Closure => M::of()(
33 |                 static fn (callable $loop): Closure => $f(
34 |                     static fn (...$arguments): mixed => M::of()($loop)(...$arguments)
35 |                 )
36 |             );
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Combinator/Z.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Combinator;
11 | 
12 | use Closure;
13 | use loophp\combinator\Combinator;
14 | 
15 | final class Z extends Combinator
16 | {
17 |     /**
18 |      * @psalm-suppress MixedInferredReturnType
19 |      */
20 |     public function __invoke(): Closure
21 |     {
22 |         return
23 |             /**
24 |              * @psalm-suppress MissingClosureReturnType
25 |              * @psalm-suppress MissingClosureParamType
26 |              * @psalm-suppress MixedArgumentTypeCoercion
27 |              * @psalm-suppress ImpureMethodCall
28 |              * @psalm-suppress MixedFunctionCall
29 |              * @psalm-suppress MixedReturnStatement
30 |              * @psalm-suppress UnusedClosureParam
31 |              */
32 |             static fn (callable $callable): Closure => M::of()(
33 |                 static fn (callable $f): Closure => $callable(
34 |                     static fn (): Closure => static fn (...$arguments): Closure => M::of()($f)(...$arguments)
35 |                 )
36 |             );
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Combinators.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * For the full copyright and license information, please view
  5 |  * the LICENSE file that was distributed with this source code.
  6 |  */
  7 | 
  8 | declare(strict_types=1);
  9 | 
 10 | namespace loophp\combinator;
 11 | 
 12 | use Closure;
 13 | use loophp\combinator\Combinator\A;
 14 | use loophp\combinator\Combinator\B;
 15 | use loophp\combinator\Combinator\Blackbird;
 16 | use loophp\combinator\Combinator\C;
 17 | use loophp\combinator\Combinator\D;
 18 | use loophp\combinator\Combinator\E;
 19 | use loophp\combinator\Combinator\F;
 20 | use loophp\combinator\Combinator\G;
 21 | use loophp\combinator\Combinator\H;
 22 | use loophp\combinator\Combinator\I;
 23 | use loophp\combinator\Combinator\J;
 24 | use loophp\combinator\Combinator\K;
 25 | use loophp\combinator\Combinator\Ki;
 26 | use loophp\combinator\Combinator\L;
 27 | use loophp\combinator\Combinator\M;
 28 | use loophp\combinator\Combinator\O;
 29 | use loophp\combinator\Combinator\Omega;
 30 | use loophp\combinator\Combinator\Phoenix;
 31 | use loophp\combinator\Combinator\Psi;
 32 | use loophp\combinator\Combinator\Q;
 33 | use loophp\combinator\Combinator\R;
 34 | use loophp\combinator\Combinator\S;
 35 | use loophp\combinator\Combinator\S2;
 36 | use loophp\combinator\Combinator\S_;
 37 | use loophp\combinator\Combinator\T;
 38 | use loophp\combinator\Combinator\U;
 39 | use loophp\combinator\Combinator\V;
 40 | use loophp\combinator\Combinator\W;
 41 | use loophp\combinator\Combinator\Y;
 42 | use loophp\combinator\Combinator\Z;
 43 | 
 44 | /**
 45 |  * Class Combinators.
 46 |  *
 47 |  * phpcs:disable PSR1.Methods.CamelCapsMethodName.NotCamelCaps
 48 |  */
 49 | final class Combinators
 50 | {
 51 |     public static function A(): Closure
 52 |     {
 53 |         return A::of();
 54 |     }
 55 | 
 56 |     public static function B(): Closure
 57 |     {
 58 |         return B::of();
 59 |     }
 60 | 
 61 |     public static function Blackbird(): Closure
 62 |     {
 63 |         return Blackbird::of();
 64 |     }
 65 | 
 66 |     public static function C(): Closure
 67 |     {
 68 |         return C::of();
 69 |     }
 70 | 
 71 |     public static function D(): Closure
 72 |     {
 73 |         return D::of();
 74 |     }
 75 | 
 76 |     public static function E(): Closure
 77 |     {
 78 |         return E::of();
 79 |     }
 80 | 
 81 |     public static function F(): Closure
 82 |     {
 83 |         return F::of();
 84 |     }
 85 | 
 86 |     public static function G(): Closure
 87 |     {
 88 |         return G::of();
 89 |     }
 90 | 
 91 |     public static function H(): Closure
 92 |     {
 93 |         return H::of();
 94 |     }
 95 | 
 96 |     public static function I(): Closure
 97 |     {
 98 |         return I::of();
 99 |     }
100 | 
101 |     public static function J(): Closure
102 |     {
103 |         return J::of();
104 |     }
105 | 
106 |     public static function K(): Closure
107 |     {
108 |         return K::of();
109 |     }
110 | 
111 |     public static function Ki(): Closure
112 |     {
113 |         return Ki::of();
114 |     }
115 | 
116 |     public static function L(): Closure
117 |     {
118 |         return L::of();
119 |     }
120 | 
121 |     public static function M(): Closure
122 |     {
123 |         return M::of();
124 |     }
125 | 
126 |     public static function O(): Closure
127 |     {
128 |         return O::of();
129 |     }
130 | 
131 |     public static function Omega(): Closure
132 |     {
133 |         return Omega::of();
134 |     }
135 | 
136 |     public static function Phoenix(): Closure
137 |     {
138 |         return Phoenix::of();
139 |     }
140 | 
141 |     public static function Psi(): Closure
142 |     {
143 |         return Psi::of();
144 |     }
145 | 
146 |     public static function Q(): Closure
147 |     {
148 |         return Q::of();
149 |     }
150 | 
151 |     public static function R(): Closure
152 |     {
153 |         return R::of();
154 |     }
155 | 
156 |     public static function S(): Closure
157 |     {
158 |         return S::of();
159 |     }
160 | 
161 |     public static function S2(): Closure
162 |     {
163 |         return S2::of();
164 |     }
165 | 
166 |     public static function S_(): Closure
167 |     {
168 |         return S_::of();
169 |     }
170 | 
171 |     public static function T(): Closure
172 |     {
173 |         return T::of();
174 |     }
175 | 
176 |     public static function U(): Closure
177 |     {
178 |         return U::of();
179 |     }
180 | 
181 |     public static function V(): Closure
182 |     {
183 |         return V::of();
184 |     }
185 | 
186 |     public static function W(): Closure
187 |     {
188 |         return W::of();
189 |     }
190 | 
191 |     public static function Y(): Closure
192 |     {
193 |         return Y::of();
194 |     }
195 | 
196 |     public static function Z(): Closure
197 |     {
198 |         return Z::of();
199 |     }
200 | }
201 | 


--------------------------------------------------------------------------------
/src/Contract/Combinator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * For the full copyright and license information, please view
 5 |  * the LICENSE file that was distributed with this source code.
 6 |  */
 7 | 
 8 | declare(strict_types=1);
 9 | 
10 | namespace loophp\combinator\Contract;
11 | 
12 | use Closure;
13 | 
14 | interface Combinator
15 | {
16 |     public static function of(): Closure;
17 | }
18 | 


--------------------------------------------------------------------------------