loophp\collection\Operation\Distinct

Complexity

Total Complexity

2

Size/Duplication

Total Lines	45
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

1 Method

Rating	Name	Duplication	Size	Complexity
A	__invoke()	0	38	2

<?php

declare(strict_types=1);

namespace loophp\collection\Operation;

use ArrayIterator;
use Closure;
use Generator;

/**
 * @immutable
 *
 * @template TKey
 * @template T
 */
final class Distinct extends AbstractOperation
{
    /**
     * @template U
     *
     * @return Closure(callable(U): Closure(U): bool): Closure(callable(T, TKey): U): Closure(iterable<TKey, T>): Generator<TKey, T>
     */
    public function __invoke(): Closure
    {
        return
            /**
             * @param callable(U): (Closure(U): bool) $comparatorCallback
             *
             * @return Closure(callable(T, TKey): U): Closure(iterable<TKey, T>): Generator<TKey, T>
             */
            static fn (callable $comparatorCallback): Closure =>
                /**
                 * @param callable(T, TKey): U $accessorCallback
                 *
                 * @return Closure(iterable<TKey, T>): Generator<TKey, T>
                 */
                static function (callable $accessorCallback) use ($comparatorCallback): Closure {
                    /** @var ArrayIterator<int, array{0: TKey, 1: T}> $stack */
                    $stack = new ArrayIterator();

                    return (new Filter())()(
                        /**
                         * @param T $value
                         * @param TKey $key

The type loophp\collection\Operation\TKey was not found. Maybe you did not declare it correctly or list all dependencies?

                         */
                        static function (mixed $value, mixed $key) use ($comparatorCallback, $accessorCallback, $stack): bool {
                            $every = (new Every())()(
                                /**
                                 * @param array{0: TKey, 1: T} $keyValuePair
                                 */
                                static fn (int $index, array $keyValuePair): bool => !$comparatorCallback($accessorCallback($value, $key))($accessorCallback($keyValuePair[1], $keyValuePair[0]))
                            )($stack);

                            if (false === $every->current()) {
                                return false;
                            }

                            $stack->append([$key, $value]);

                            return true;
                        }
                    );
                };
    }
}