loophp\fpt\Curry

Complexity

Total Complexity

6

Size/Duplication

Total Lines	55
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	of()	0	18	2
A	curryN()	0	6	1
A	getArguments()	0	3	1
A	isComplete()	0	3	2

<?php

/**
 * For the full copyright and license information, please view
 * the LICENSE file that was distributed with this source code.
 */

declare(strict_types=1);

namespace loophp\fpt;

use Closure;
use Generator;
use ReflectionFunction;

use function count;

/**
 * Stateless "Curry" application.
 *
 * @psalm-immutable
 *
 * phpcs:disable Generic.Files.LineLength.TooLong
 */
final class Curry
{
    /**
     * @psalm-pure
     */
    public static function of(): Closure
    {
        return
            /**
             * @param Closure|callable-string $callable

The doc comment Closure|callable-string at position 2 could not be parsed: Unknown type name 'callable-string' at position 2 in Closure|callable-string.

             */
            static function (callable $callable, int $arity = 0, mixed ...$arguments): mixed {
                if (0 === $arity) {
                    $reflection = (new ReflectionFunction($callable));
                    $parameters = $reflection->getNumberOfParameters();
                    $requiredParameters = $reflection->getNumberOfRequiredParameters();
                }

                return self::curryN(
                    $callable,
                    $parameters ?? $arity,
                    $requiredParameters ?? $arity,
                    ...$arguments
                );
            };
    }

    /**
     * @param Closure|callable-string $callable

The doc comment Closure|callable-string at position 2 could not be parsed: Unknown type name 'callable-string' at position 2 in Closure|callable-string.

     */
    private static function curryN(callable $callable, int $parameters, int $requiredParameters, mixed ...$arguments): mixed
    {
        return match (true) {
            0 === $requiredParameters => static fn (): mixed => ($callable)(),
            self::isComplete(count($arguments), $parameters, $requiredParameters) => ($callable)(...$arguments),
            default => static fn (mixed ...$args): mixed => self::curryN($callable, $parameters, $requiredParameters, ...self::getArguments($arguments, $args))
        };
    }

    /**
     * @psalm-pure
     *
     * @psalm-param list<mixed> $args
     * @psalm-param list<mixed> $argsNext
     *
     * @psalm-return Generator<int, mixed>
     */
    private static function getArguments(array $args, array $argsNext): Generator
    {
        return yield from array_merge($args, $argsNext);
    }

    private static function isComplete(int $arguments, int $parameters, int $requiredParameters): bool
    {
        return $arguments === $parameters || $arguments === $requiredParameters;
    }
}