├── readme.md
├── initials.php
├── matrix.php
├── LICENSE
└── lib.php


/readme.md:
--------------------------------------------------------------------------------
1 | ## Code for my "Functional programming in PHP" talk
2 | 
3 | Link to the slides:
4 | [https://speakerdeck.com/pwm/functional-programming-in-php](https://speakerdeck.com/pwm/functional-programming-in-php)
5 | 
6 | Link to the video:
7 | [https://www.youtube.com/watch?v=pWQV1x3YIJM&t=1m0s](https://www.youtube.com/watch?v=pWQV1x3YIJM&t=1m0s)
8 | 
9 | 


--------------------------------------------------------------------------------
/initials.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | require __DIR__.'/lib.php';
 3 | 
 4 | $explode = curry('explode');
 5 | $implode = curry('implode');
 6 | $match   = curry('preg_match');
 7 | $head    = function ($s) { return $s[0]; };
 8 | $isWord  = $match('/[a-z]/i');
 9 | 
10 | $initials = $compose([
11 |     $implode(' '),
12 |     $map($o('strtoupper')($head)),
13 |     $filter($isWord),
14 |     $explode(' ')
15 | ]);
16 | 
17 | assert($initials('This is rather cool :)') === 'T I R C');
18 | 


--------------------------------------------------------------------------------
/matrix.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | require __DIR__.'/lib.php';
 3 | 
 4 | $plus = curry(function ($x, $y) { return $x + $y; });
 5 | 
 6 | $sum = $foldr($plus)(0);
 7 | 
 8 | assert($sum([1, 2, 3, 4, 5]) === 15);
 9 | 
10 | $matrix = [
11 |     [1, 1, 1, 1, 1],
12 |     [2, 2, 2, 2, 2],
13 |     [3, 3, 3, 3, 3],
14 |     [4, 4, 4, 4, 4],
15 |     [5, 5, 5, 5, 5],
16 | ];
17 | 
18 | $sumMatrix = $o($sum)($map($sum));
19 | 
20 | assert($sumMatrix($matrix) === 75);
21 | 
22 | $addOneToMatrix = $map($map($plus(1)));
23 | 
24 | assert($sumMatrix($addOneToMatrix($matrix)) === 100);
25 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2016 pwm
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/lib.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // Syntactic sugar so we don't have to manually write curried function definitions.
 4 | // We still curry at function calls for the sake of authenticity.
 5 | function curry($f, ...$args) {
 6 |     return function (...$partialArgs) use ($f, $args) {
 7 |         return (function ($args) use ($f) {
 8 |             return count($args) < (new ReflectionFunction($f))->getNumberOfRequiredParameters()
 9 |                 ? curry($f, ...$args)
10 |                 : $f(...$args);
11 |         })(array_merge($args, $partialArgs));
12 |     };
13 | }
14 | 
15 | // The identity function
16 | // a -> a
17 | $id = function ($x) { return $x; };
18 | 
19 | // Function composition operator aka. little circle
20 | // (b -> c) -> (a -> b) -> (a -> c)
21 | $o = curry(function ($g, $f) {
22 |     return function ($x) use ($g, $f) {
23 |         return $g($f($x));
24 |     };
25 | });
26 | 
27 | // The Y fixed point combinator in applicative-order form
28 | // It transforms "pseudo recursive" functions to recursive functions
29 | // λf.(λx.f (λv.x x v)) (λx.f (λv.x x v))
30 | $Y = function ($f) {
31 |     return
32 |         (function ($x) use ($f) { return $f(function ($v) use ($x) { return $x($x)($v); }); })
33 |         (function ($x) use ($f) { return $f(function ($v) use ($x) { return $x($x)($v); }); });
34 | };
35 | 
36 | // Right fold, the "essence" of recursion on lists (made recursive via the Y combinator)
37 | // (a -> b -> b) -> b -> [a] -> b
38 | $foldr = $Y(function ($foldr) {
39 |     return curry(function ($f, $v, $l) use ($foldr) {
40 |         return count($l) > 0
41 |             ? $f($l[0])($foldr($f)($v)(array_slice($l, 1)))
42 |             : $v;
43 |     });
44 | });
45 | 
46 | // Map, expressed by foldr
47 | // (a -> b) -> [a] -> [b]
48 | $map = curry(function ($f, $l) use ($foldr) {
49 |     return $foldr
50 |         (curry(function ($x, $v) use ($f) { return array_merge([$f($x)], $v); }))
51 |         ([])
52 |         ($l);
53 | });
54 | 
55 | // Filter, expressed by foldr
56 | // (a -> Bool) -> [a] -> [a]
57 | $filter = curry(function ($p, $l) use ($foldr) {
58 |     return $foldr
59 |         (curry(function ($x, $v) use ($p) { return $p($x) ? array_merge([$x], $v) : $v; }))
60 |         ([])
61 |         ($l);
62 | });
63 | 
64 | // Composition of a list of functions
65 | // compose :: [a -> a] -> (a -> a)
66 | $compose = $foldr($o)($id);
67 | 


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