Primitives.php

Go to the documentation of this file.

<?php

declare(strict_types=1);

namespace ILIAS\Refinery\Parser\ABNF;

use ILIAS\Data\Result;
use ILIAS\Data\Result\Ok;
use ILIAS\Data\Result\Error;
use Closure;

class Primitives
{
    public function simpleEither(array $parse): Closure
    {
        return $this->variadic([$this, 'or2'], $parse);
    }

    public function simpleSequence(array $parse): Closure
    {
        return $this->variadic([$this, 'seq'], $parse);
    }

    public function until(?int $max, $parse): Closure
    {
        if (0 === $max) {
            return $this->nop();
        }

        $max = null === $max ? null : $max - 1;

        return $this->simpleEither([
            $this->nop(),
            $this->simpleSequence([
                $parse,
                $this->lazy([$this, 'until'], $max, $parse)
            ])
        ]);
    }

    public function parserFrom($x): Closure
    {
        return $x instanceof Closure ? $x : $this->mustEqual($x);
    }

    private function or2(Closure $f, Closure $g): Closure
    {
        return static fn(Intermediate $x, Closure $cc): Result => (
            $f($x, $cc)->except(static fn(): Result => $g($x, $cc))
        );
    }

    private function seq(Closure $f, Closure $g): Closure
    {
        return static fn(Intermediate $x, Closure $cc): Result => $f(
            $x,
            static fn(Result $x): Result => (
                $x->then(static fn(Intermediate $x): Result => $g($x, $cc))
                  ->except(static fn($error): Result => $cc(new Error($error)))
            )
        );
    }

    private function eq(int $atom): Closure
    {
        return static fn(Intermediate $x, Closure $cc): Result => $cc(
            $atom === $x->value() ? $x->accept() : $x->reject()
        );
    }

    private function variadic(callable $call, array $parse): Closure
    {
        $parse = array_map([$this, 'parserFrom'], $parse);

        return array_reduce(array_slice($parse, 1), $call, $parse[0]);
    }

    private function mustEqual(string $expected): Closure
    {
        if (strlen($expected) === 1) {
            return $this->eq(ord($expected));
        } elseif ('' === $expected) {
            return $this->nop();
        }

        return $this->simpleSequence(str_split($expected));
    }

    private function nop(): Closure
    {
        return static fn(Intermediate $x, Closure $cc): Result => (
            $cc(new Ok($x))
        );
    }

    private function lazy(callable $call, ...$arguments): Closure
    {
        return static fn(Intermediate $x, Closure $cc): Result => (
            ($call(...$arguments))($x, $cc)
        );
    }
}