Scalp\PatternMatching\Pattern\Type

Complexity

Total Complexity

9

Size/Duplication

Total Lines	73
Duplicated Lines	0 %

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
B	applyConstructorArgumentsPatterns()	0	30	5
A	match()	0	21	3

<?php

declare(strict_types=1);

namespace Scalp\PatternMatching\Pattern;

use const Scalp\__;

The type Scalp\__ was not found. Maybe you did not declare it correctly or list all dependencies?

use Scalp\PatternMatching\CaseClass;
use Scalp\PatternMatching\Exception\InvalidPatternsNumber;
use const Scalp\Utils\isInstanceOfType;

The type Scalp\Utils\isInstanceOfType was not found. Maybe you did not declare it correctly or list all dependencies?

use const Scalp\Utils\Success;
use function Scalp\None;
use Scalp\Option;
use function Scalp\papply;

The type Scalp\papply was not found. Maybe you did not declare it correctly or list all dependencies?

use function Scalp\Some;
use function Scalp\Utils\delay;
use const Scalp\Utils\Failure;
use Scalp\Utils\TryCatch;
use function Scalp\Utils\type;

The type Scalp\Utils\type was not found. Maybe you did not declare it correctly or list all dependencies?

This use statement conflicts with another class in this namespace, Scalp\PatternMatching\Pattern\type. Consider defining an alias.

final class Type extends Pattern implements Binding
{
    use Bind;

    private $type;
    private $patterns;

    public function __construct(string $type, Pattern ...$patterns)
    {
        $this->type = $type;
        $this->patterns = $patterns;
    }

    public function match($x): Option
    {
        $typeMatch = Some($x)
            ->filter(papply(isInstanceOfType, __, $this->type));

        if ($typeMatch->isEmpty() || empty($this->patterns)) {
            return $typeMatch->flatMap(function (): Option { return Some([]); });
        }

        /** @var TryCatch $caseClass */
        $caseClass = $typeMatch
                ->filter(papply(isInstanceOfType, __, CaseClass::class))
                ->fold(
                    delay(Failure, new \RuntimeException('Argument must be CaseClass')),
                    Success
                );

        return $caseClass
                ->map(function (CaseClass $cc): array { return $cc->deconstruct(); })
                ->map(papply(\Closure::fromCallable([$this, 'applyConstructorArgumentsPatterns']), type($x), __, $this->patterns))
                ->get();
    }

    /**
     * @param string    $type
     * @param array     $arguments
     * @param Pattern[] $patterns
     *
     * @return Option
     */
    private function applyConstructorArgumentsPatterns(string $type, array $arguments, array $patterns): Option
    {
        $argumentsNumber = \count($arguments);
        $patternsNumber = \count($patterns);

        if ($argumentsNumber !== $patternsNumber) {
            throw InvalidPatternsNumber::create($type, $argumentsNumber, $patternsNumber);
        }

        $currentPattern = 0;

        $values = [];

        foreach ($arguments as $argument) {
            $pattern = $patterns[$currentPattern];

            $res = $pattern->match($argument);

            if ($res->isEmpty()) {
                return None();
            }

            $value = $res->get();

            $values = array_merge($values, is_array($value) ? $value : [$value]);

            $currentPattern = $currentPattern + 1;
        }

        return Some($values);
    }
}