Implemented callable codec (#18) (#21)

Author: emnlmn

src/Codecs.php

@@ -12,6 +12,7 @@
 use Facile\PhpCodec\Internal\Combinators\UnionCodec;
 use Facile\PhpCodec\Internal\IdentityEncoder;
 use Facile\PhpCodec\Internal\Primitives\BoolType;
+use Facile\PhpCodec\Internal\Primitives\CallableDecoder;
 use Facile\PhpCodec\Internal\Primitives\FloatType;
 use Facile\PhpCodec\Internal\Primitives\IntType;
 use Facile\PhpCodec\Internal\Primitives\MixedDecoder;
@@ -227,4 +228,12 @@ public static function mixed(): Codec
     {
         return self::fromDecoder(new MixedDecoder());
     }
+
+    /**
+     * @return Codec<callable, mixed, callable>
+     */
+    public static function callable(): Codec
+    {
+        return self::fromDecoder(new CallableDecoder());
+    }
 }

src/Internal/Primitives/CallableDecoder.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Facile\PhpCodec\Internal\Primitives;
+
+use Facile\PhpCodec\Decoder;
+use function Facile\PhpCodec\Internal\standardDecode;
+use Facile\PhpCodec\Validation\Context;
+use Facile\PhpCodec\Validation\Validation;
+
+/**
+ * @implements Decoder<mixed, callable>
+ */
+class CallableDecoder implements Decoder
+{
+    public function validate($i, Context $context): Validation
+    {
+        return \is_callable($i)
+            ? Validation::success($i)
+            : Validation::failure($i, $context);
+    }
+
+    public function decode($i): Validation
+    {
+        return standardDecode($this, $i);
+    }
+
+    public function getName(): string
+    {
+        return 'callable';
+    }
+}

tests/unit/Internal/Primitives/CallableDecoderTest.php

@@ -0,0 +1,93 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Facile\PhpCodec\Internal\Primitives;
+
+use Eris\Generator as g;
+use Eris\TestTrait;
+use Facile\PhpCodec\Codecs;
+use Tests\Facile\PhpCodec\BaseTestCase;
+use Tests\Facile\PhpCodec\GeneratorUtils;
+
+class CallableDecoderTest extends BaseTestCase
+{
+    use TestTrait;
+
+    public function testLaws(): void
+    {
+        $this
+            ->forAll(
+                g\oneOf(
+                    GeneratorUtils::scalar(),
+                    g\map(
+                        function ($x): callable {
+                            return static function () use ($x) {
+                                return $x;
+                            };
+                        },
+                        GeneratorUtils::scalar()
+                    ),
+                    g\map(
+                        function ($x): callable {
+                            return new class($x) {
+                                private $n;
+
+                                public function __construct($n)
+                                {
+                                    $this->n = $n;
+                                }
+
+                                public function __invoke()
+                                {
+                                    return $this->n;
+                                }
+                            };
+                        },
+                        GeneratorUtils::scalar()
+                    ),
+                    g\constant('date'),
+                    g\constant([T::class, 'm'])
+                ),
+                g\oneOf(
+                    g\map(
+                        function ($x): callable {
+                            return static function () use ($x) {
+                                return $x;
+                            };
+                        },
+                        GeneratorUtils::scalar()
+                    ),
+                    g\map(
+                        function ($x): callable {
+                            return new class($x) {
+                                private $n;
+
+                                public function __construct($n)
+                                {
+                                    $this->n = $n;
+                                }
+
+                                public function __invoke()
+                                {
+                                    return $this->n;
+                                }
+                            };
+                        },
+                        GeneratorUtils::scalar()
+                    ),
+                    g\constant('date'),
+                    g\constant([T::class, 'm'])
+                )
+            )
+            ->then(self::codecLaws(Codecs::callable()));
+    }
+}
+
+class T
+{
+    public static function m(): int
+    {
+        return 1;
+    }
+}