rearrange function arguments in fold

this allows typechecking with the lambda passed to fold also upgraded Result types to use templates
ylixir · Feb 18, 2019 · 80e7463 · 80e7463
1 parent 322671d
commit 80e7463
Show file tree

Hide file tree

Showing 8 changed files with 38 additions and 21 deletions.
diff --git a/docs/api.md b/docs/api.md
@@ -104,7 +104,7 @@ Similar to `array_reduce`, this function can be used to combine values. For exam
 $flower = p::lit("flower");
 $flowers = $flower->and($flower);
 
-$parser = $flowers->fold(function (array $acc, string $in): array {
+$parser = $flowers->fold(function (string $in, string ...$acc): array {
     return ["flowers"];
 }, []);
 
@@ -118,7 +118,7 @@ $flower = p::lit("flower");
 $flowers = p::and($flower, $flower);
 
 $parser = p::fold(
-    function (array $acc, string $in): array {
+    function (string $in, string ...$acc): array {
         return ["flowers"];
     },
     [],

diff --git a/src/Functions.php b/src/Functions.php
@@ -87,7 +87,9 @@ public static function end(callable $p): callable
     }
 
     /**
-     * @param callable(array, mixed):array $f
+     * @template S
+     * @template T
+     * @param callable(T, S...):array<int,S> $f
      * @param callable(string):?r $p
      * @return callable(string):?r
      */
@@ -101,9 +103,18 @@ public static function fold(
             if (null === $r) {
                 return $r;
             } else {
-                /** @var array */ $reduced = array_reduce(
+                $ftransform =
+                    /**
+                     * @param S[] $a
+                     * @param T $s
+                     * @return array<int, S>
+                     */
+                    function (array $a, $s) use ($f): array {
+                        return $f($s, ...$a);
+                    };
+                /** @var array<int, S> */ $reduced = array_reduce(
                     $r->parsed,
-                    $f,
+                    $ftransform,
                     $start
                 );
                 return r::make($r->unparsed, $reduced);
@@ -149,7 +160,8 @@ public static function map(callable $f, callable $p): callable
             if (null === $r) {
                 return $r;
             } else {
-                return r::make($r->unparsed, array_map($f, $r->parsed));
+                /** @var array<int, T> */ $mapped = array_map($f, $r->parsed);
+                return r::make($r->unparsed, $mapped);
             }
         };
     }

diff --git a/src/Oop.php b/src/Oop.php
@@ -51,7 +51,10 @@ public function end(): self
     }
 
     /**
-     * @param callable(array, mixed):array $f
+     * @template T
+     * @template S
+     * @param callable(T, S...):S[] $f
+     * @param array<int, S> $start
      */
     public function fold(callable $f, array $start = []): self
     {

diff --git a/src/Result.php b/src/Result.php
@@ -3,25 +3,33 @@
 namespace Phap;
 
 /**
+ * @template T
  * @property string $unparsed
- * @property array<int,mixed> $parsed
+ * @property array<int,T> $parsed
  * @psalm-seal-properties
  */
 final class Result
 {
     /** @var string */ private $unparsed;
-    /** @var array */ private $parsed;
+    /** @var array<int, T> */ private $parsed;
 
     public function __get(string $prop)
     {
         return $this->$prop;
     }
+
+    /**
+     * @param array<int, T> $parsed
+     */
     private function __construct(string $unparsed, array $parsed)
     {
         $this->unparsed = $unparsed;
         $this->parsed = $parsed;
     }
 
+    /**
+     * @param array<int, T> $parsed
+     */
     public static function make(string $unparsed, array $parsed): self
     {
         return new self($unparsed, $parsed);

diff --git a/test/Integration/OopExamples.php b/test/Integration/OopExamples.php
@@ -22,11 +22,8 @@ public static function integerParser(): p
         $intArray = $allDigits->map('intval');
         //reduce the separate digits into one
         $integer = $intArray->fold(
-            /**
-             * @param array{0:int} $a
-             */
-            function (array $a, int $i): array {
-                return [$a[0] * 10 + $i];
+            function (int $i, int $a, int ...$tail): array {
+                return [$a * 10 + $i];
             },
             [0]
         );

diff --git a/test/Integration/functional_examples.php b/test/Integration/functional_examples.php
@@ -23,11 +23,8 @@ public static function integer_parser(): callable
 
         //reduce the separate digits into one
         $integer = p::fold(
-            /**
-             * @param array{0:int} $a
-             */
-            function (array $a, int $i): array {
-                return [$a[0] * 10 + $i];
+            function (int $i, int $a, int ...$tail): array {
+                return [$a * 10 + $i];
             },
             [0],
             $intArray

diff --git a/test/Unit/FunctionsTest.php b/test/Unit/FunctionsTest.php
@@ -75,7 +75,7 @@ public function test_end(
 
     public function fold_provider(): array
     {
-        $fold = function (array $a, string $s): array {
+        $fold = function (string $s, ...$a): array {
             if ('2' !== $s) {
                 $a[] = $s;
             }

diff --git a/test/Unit/OopTest.php b/test/Unit/OopTest.php
@@ -159,7 +159,7 @@ public function testPop(string $input, ?r $expected): void
 
     public function foldProvider(): array
     {
-        $fold = function (array $a, string $s): array {
+        $fold = function (string $s, ...$a): array {
             if ('2' !== $s) {
                 $a[] = $s;
             }