loophp\fpt\Curry

Complexity

Total Complexity

8

Size/Duplication

Total Lines	60
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	6
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	curryN()	0	9	3
A	of()	0	18	2
A	getArguments()	0	3	1
A	isComplete()	0	5	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;
use function func_get_args;

/**
 * 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, ?int $parameters = null, ?int $requiredParameters = null, 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
    {
        // Normally the curry function takes one parameter at a time (returns a unary function).
        return (0 === $requiredParameters) ?
            static fn () => ($callable)() :
            (
                self::isComplete(count($arguments), $parameters, $requiredParameters) ?
                    ($callable)(...$arguments) :
                    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
    {
        var_dump(func_get_args());

var_dump(func_get_args()) looks like debug code. Are you sure you do not want to remove it?

        return $arguments === $parameters || $arguments === $requiredParameters;
    }
}