├── composer.json
├── renovate.json
└── src
    ├── Collection.php
    ├── CollectionDecorator.php
    ├── Contract
        ├── Collection.php
        ├── Operation.php
        └── Operation
        │   ├── Allable.php
        │   ├── Appendable.php
        │   ├── Applyable.php
        │   ├── Associateable.php
        │   ├── AsyncMapNable.php
        │   ├── AsyncMapable.php
        │   ├── Averagesable.php
        │   ├── Cacheable.php
        │   ├── Chunkable.php
        │   ├── Coalesceable.php
        │   ├── Collapseable.php
        │   ├── Columnable.php
        │   ├── Combinateable.php
        │   ├── Combineable.php
        │   ├── Compactable.php
        │   ├── Comparable.php
        │   ├── Containsable.php
        │   ├── CountInAble.php
        │   ├── Currentable.php
        │   ├── Cycleable.php
        │   ├── Diffable.php
        │   ├── Diffkeysable.php
        │   ├── Dispersionable.php
        │   ├── Distinctable.php
        │   ├── DropWhileable.php
        │   ├── Dropable.php
        │   ├── Dumpable.php
        │   ├── Duplicateable.php
        │   ├── Entropyable.php
        │   ├── Equalsable.php
        │   ├── Everyable.php
        │   ├── Explodeable.php
        │   ├── Falsyable.php
        │   ├── Filterable.php
        │   ├── Findable.php
        │   ├── Firstable.php
        │   ├── FlatMapable.php
        │   ├── Flattenable.php
        │   ├── Flipable.php
        │   ├── FoldLeft1able.php
        │   ├── FoldLeftable.php
        │   ├── FoldRight1able.php
        │   ├── FoldRightable.php
        │   ├── Forgetable.php
        │   ├── Frequencyable.php
        │   ├── Getable.php
        │   ├── GroupByable.php
        │   ├── Groupable.php
        │   ├── Hasable.php
        │   ├── Headable.php
        │   ├── IfThenElseable.php
        │   ├── Implodeable.php
        │   ├── Initable.php
        │   ├── Initsable.php
        │   ├── Intersectable.php
        │   ├── Intersectkeysable.php
        │   ├── Intersperseable.php
        │   ├── IsEmptyable.php
        │   ├── IsNotEmptyable.php
        │   ├── Keyable.php
        │   ├── Keysable.php
        │   ├── Lastable.php
        │   ├── Limitable.php
        │   ├── Linesable.php
        │   ├── MapNable.php
        │   ├── Mapable.php
        │   ├── Matchable.php
        │   ├── Matchingable.php
        │   ├── Maxable.php
        │   ├── Mergeable.php
        │   ├── Minable.php
        │   ├── Normalizeable.php
        │   ├── Nthable.php
        │   ├── Nullsyable.php
        │   ├── Packable.php
        │   ├── Padable.php
        │   ├── Pairable.php
        │   ├── Partitionable.php
        │   ├── Permutateable.php
        │   ├── Pipeable.php
        │   ├── Pluckable.php
        │   ├── Prependable.php
        │   ├── Productable.php
        │   ├── RSampleable.php
        │   ├── Randomable.php
        │   ├── Rangeable.php
        │   ├── Reduceable.php
        │   ├── Reductionable.php
        │   ├── Rejectable.php
        │   ├── Reverseable.php
        │   ├── Sameable.php
        │   ├── Scaleable.php
        │   ├── ScanLeft1able.php
        │   ├── ScanLeftable.php
        │   ├── ScanRight1able.php
        │   ├── ScanRightable.php
        │   ├── Shuffleable.php
        │   ├── Sinceable.php
        │   ├── Sliceable.php
        │   ├── Sortable.php
        │   ├── Spanable.php
        │   ├── Splitable.php
        │   ├── Squashable.php
        │   ├── Strictable.php
        │   ├── Tailable.php
        │   ├── Tailsable.php
        │   ├── TakeWhileable.php
        │   ├── Tappable.php
        │   ├── Timesable.php
        │   ├── Transposeable.php
        │   ├── Truthyable.php
        │   ├── Unfoldable.php
        │   ├── Unlinesable.php
        │   ├── Unpackable.php
        │   ├── Unpairable.php
        │   ├── Untilable.php
        │   ├── Unwindowable.php
        │   ├── Unwordsable.php
        │   ├── Unwrapable.php
        │   ├── Unzipable.php
        │   ├── Whenable.php
        │   ├── Windowable.php
        │   ├── Wordsable.php
        │   ├── Wrapable.php
        │   └── Zipable.php
    ├── Iterator
        └── PsrCacheIterator.php
    ├── Operation
        ├── AbstractOperation.php
        ├── Append.php
        ├── Apply.php
        ├── Associate.php
        ├── AsyncMap.php
        ├── AsyncMapN.php
        ├── Averages.php
        ├── Cache.php
        ├── Chunk.php
        ├── Coalesce.php
        ├── Collapse.php
        ├── Column.php
        ├── Combinate.php
        ├── Combine.php
        ├── Compact.php
        ├── Compare.php
        ├── Contains.php
        ├── Current.php
        ├── Cycle.php
        ├── Diff.php
        ├── DiffKeys.php
        ├── Dispersion.php
        ├── Distinct.php
        ├── Drop.php
        ├── DropWhile.php
        ├── Dump.php
        ├── Duplicate.php
        ├── Entropy.php
        ├── Equals.php
        ├── Every.php
        ├── Explode.php
        ├── Falsy.php
        ├── Filter.php
        ├── Find.php
        ├── First.php
        ├── FlatMap.php
        ├── Flatten.php
        ├── Flip.php
        ├── FoldLeft.php
        ├── FoldLeft1.php
        ├── FoldRight.php
        ├── FoldRight1.php
        ├── Forget.php
        ├── Frequency.php
        ├── Get.php
        ├── Group.php
        ├── GroupBy.php
        ├── Has.php
        ├── Head.php
        ├── IfThenElse.php
        ├── Implode.php
        ├── Init.php
        ├── Inits.php
        ├── Intersect.php
        ├── IntersectKeys.php
        ├── Intersperse.php
        ├── IsEmpty.php
        ├── IsNotEmpty.php
        ├── Key.php
        ├── Keys.php
        ├── Last.php
        ├── Limit.php
        ├── Lines.php
        ├── Map.php
        ├── MapN.php
        ├── MatchOne.php
        ├── Matching.php
        ├── Max.php
        ├── Merge.php
        ├── Min.php
        ├── Normalize.php
        ├── Nth.php
        ├── Nullsy.php
        ├── Pack.php
        ├── Pad.php
        ├── Pair.php
        ├── Partition.php
        ├── Permutate.php
        ├── Pipe.php
        ├── Pluck.php
        ├── Prepend.php
        ├── Product.php
        ├── RSample.php
        ├── Random.php
        ├── Range.php
        ├── Reduce.php
        ├── Reduction.php
        ├── Reject.php
        ├── Reverse.php
        ├── Same.php
        ├── Scale.php
        ├── ScanLeft.php
        ├── ScanLeft1.php
        ├── ScanRight.php
        ├── ScanRight1.php
        ├── Shuffle.php
        ├── Since.php
        ├── Slice.php
        ├── Sort.php
        ├── Span.php
        ├── Split.php
        ├── Strict.php
        ├── Tail.php
        ├── Tails.php
        ├── TakeWhile.php
        ├── Tap.php
        ├── Times.php
        ├── Transpose.php
        ├── Truthy.php
        ├── Unfold.php
        ├── Unlines.php
        ├── Unpack.php
        ├── Unpair.php
        ├── Until.php
        ├── Unwindow.php
        ├── Unwords.php
        ├── Unwrap.php
        ├── Unzip.php
        ├── When.php
        ├── Window.php
        ├── Words.php
        ├── Wrap.php
        └── Zip.php
    └── Utils
        └── CallbacksArrayReducer.php


/renovate.json:
--------------------------------------------------------------------------------
1 | {
2 |     "$schema": "https://docs.renovatebot.com/renovate-schema.json",
3 |     "extends": ["config:base"]
4 | }
5 | 


--------------------------------------------------------------------------------
/src/Contract/Operation.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract;
 6 | 
 7 | use Closure;
 8 | 
 9 | /**
10 |  * @immutable
11 |  */
12 | interface Operation
13 | {
14 |     public function __invoke(): Closure;
15 | 
16 |     public static function of(): Closure;
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Allable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | /**
 8 |  * @template TKey
 9 |  * @template T
10 |  */
11 | interface Allable
12 | {
13 |     /**
14 |      * Convert the collection into an array.
15 |      *
16 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#all
17 |      *
18 |      * @param bool $normalize
19 |      *
20 |      * @psalm-return ($normalize is true ? list<T> : array<TKey, T>)
21 |      */
22 |     public function all(bool $normalize = true): array;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Appendable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Appendable
14 | {
15 |     /**
16 |      * Add one or more items to a collection.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#append
19 |      *
20 |      * @template U
21 |      *
22 |      * @param U ...$items
23 |      *
24 |      * @return Collection<int|TKey, T|U>
25 |      */
26 |     public function append(mixed ...$items): Collection;
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Applyable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Applyable
14 | {
15 |     /**
16 |      * Execute callback(s) on each element of the collection.
17 |      * Iterates on the collection items regardless of the return value of the callback.
18 |      * If the callback does not return `true` then it stops applying callbacks on subsequent items.
19 |      *
20 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#apply
21 |      *
22 |      * @param callable(T, TKey, iterable<TKey, T>): bool ...$callbacks
23 |      *
24 |      * @return Collection<TKey, T>
25 |      */
26 |     public function apply(callable ...$callbacks): Collection;
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Associateable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Associateable
14 | {
15 |     /**
16 |      * Transform keys and values of the collection independently and combine them.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#associate
19 |      *
20 |      * @template UKey
21 |      * @template U
22 |      *
23 |      * @param callable(TKey, T, iterable<TKey, T>): UKey $callbackForKeys
24 |      * @param callable(T, TKey, iterable<TKey, T>): U $callbackForValues
25 |      *
26 |      * @return Collection<UKey, U>
27 |      */
28 |     public function associate(?callable $callbackForKeys = null, ?callable $callbackForValues = null): Collection;
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/AsyncMapNable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface AsyncMapNable
14 | {
15 |     /**
16 |      * Asynchronously apply one or more supplied callbacks to every item of a collection and use the return value.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#asyncmapn
19 |      *
20 |      * @param callable(mixed, mixed): mixed ...$callbacks
21 |      *
22 |      * @return Collection<mixed, mixed>
23 |      */
24 |     public function asyncMapN(callable ...$callbacks): Collection;
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/AsyncMapable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface AsyncMapable
14 | {
15 |     /**
16 |      * Asynchronously apply a single callback to every item of a collection and use the return value.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#asyncmap
19 |      *
20 |      * @template V
21 |      *
22 |      * @param callable(T, TKey): V $callback
23 |      *
24 |      * @return Collection<TKey, V>
25 |      */
26 |     public function asyncMap(callable $callback): Collection;
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Averagesable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Averagesable
14 | {
15 |     /**
16 |      * Calculate the average of a collection of numbers.
17 |      *
18 |      * The average constitute the result obtained by adding together several
19 |      * amounts and then dividing this total by the number of amounts.
20 |      *
21 |      * Based on `scanLeft1`, this operation will return the average at each
22 |      * iteration.
23 |      * Therefore, if you're looking for one single result, you must get the last
24 |      * item using `last` operation.
25 |      *
26 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#averages
27 |      *
28 |      * @return Collection<int, float>
29 |      */
30 |     public function averages(): Collection;
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Cacheable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | use Psr\Cache\CacheItemPoolInterface;
 9 | 
10 | /**
11 |  * @template TKey
12 |  * @template T
13 |  */
14 | interface Cacheable
15 | {
16 |     /**
17 |      * Useful when using a resource as input and you need to run through the collection multiple times.
18 |      *
19 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#cache
20 |      *
21 |      * @return Collection<TKey, T>
22 |      */
23 |     public function cache(?CacheItemPoolInterface $cache = null): Collection;
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Chunkable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Chunkable
14 | {
15 |     /**
16 |      * Chunk a collection of items into chunks of items of a given size.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#chunk
19 |      *
20 |      * @return Collection<int, non-empty-list<T>>
21 |      */
22 |     public function chunk(int ...$sizes): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Coalesceable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Coalesceable
14 | {
15 |     /**
16 |      * Return the first non-nullsy value in a collection.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#coalesce
19 |      *
20 |      * @return Collection<TKey, T>
21 |      */
22 |     public function coalesce(): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Collapseable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Collapseable
14 | {
15 |     /**
16 |      * Collapse a collection of items into a simple flat collection.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#collapse
19 |      *
20 |      * @return Collection<TKey, T>
21 |      */
22 |     public function collapse(): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Columnable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Columnable
14 | {
15 |     /**
16 |      * Return the values from a single column in the input iterables.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#column
19 |      *
20 |      * @return Collection<int, mixed>
21 |      */
22 |     public function column(mixed $column): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Combinateable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Combinateable
14 | {
15 |     /**
16 |      * Get all the combinations of a given length of a collection of items.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#combinate
19 |      *
20 |      * @return Collection<TKey, T>
21 |      */
22 |     public function combinate(?int $length = null): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Combineable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Combineable
14 | {
15 |     /**
16 |      * Combine a collection of items with some other keys.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#combine
19 |      *
20 |      * @template U
21 |      *
22 |      * @param U ...$keys
23 |      *
24 |      * @return Collection<U|null, T|null>
25 |      */
26 |     public function combine(mixed ...$keys): Collection;
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Compactable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Compactable
14 | {
15 |     /**
16 |      * Remove given values from the collection; if no values are provided, it removes *nullsy* values.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#compact
19 |      *
20 |      * @param T ...$values
21 |      *
22 |      * @return Collection<TKey, T>
23 |      */
24 |     public function compact(mixed ...$values): Collection;
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Comparable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | /**
 8 |  * @template TKey
 9 |  * @template T
10 |  */
11 | interface Comparable
12 | {
13 |     /**
14 |      * Fold the collection through a comparison operation, yielding the "highest" or "lowest"
15 |      * element as defined by the comparator callback. The callback takes a pair of two elements
16 |      * and should return the "highest" or "lowest" one as desired.
17 |      *
18 |      * If no custom logic is required for the comparison, the simpler `max` or `min` operations
19 |      * can be used instead.
20 |      *
21 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#compare
22 |      *
23 |      * @template V
24 |      *
25 |      * @param callable(T, T, TKey, iterable<TKey, T>): T $comparator
26 |      * @param V $default
27 |      *
28 |      * @return T|V
29 |      */
30 |     public function compare(callable $comparator, mixed $default = null);
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Containsable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | /**
 8 |  * @template TKey
 9 |  * @template T
10 |  */
11 | interface Containsable
12 | {
13 |     /**
14 |      * Check if the collection contains one or more values.
15 |      *
16 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#contains
17 |      *
18 |      * @param T ...$values
19 |      */
20 |     public function contains(mixed ...$values): bool;
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/CountInAble.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface CountInAble
14 | {
15 |     /**
16 |      * This operation requires a reference to a parameter that will contain the
17 |      * amount of items in the collection. The difference with the `count`
18 |      * operation is that the `count` operation will return the amount of items
19 |      * in the collection and the `countIn` operation will yield over the
20 |      * collection itself while updating the counter variable.
21 |      *
22 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#countIn
23 |      *
24 |      * @param non-negative-int $counter
25 |      *
26 |      * @return Collection<TKey, T>
27 |      */
28 |     public function countIn(int &$counter): Collection;
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Currentable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | /**
 8 |  * @template TKey
 9 |  * @template T
10 |  */
11 | interface Currentable
12 | {
13 |     /**
14 |      * Get the value of an item in the collection given a numeric index or the default `0`.
15 |      *
16 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#current
17 |      *
18 |      * @template V
19 |      *
20 |      * @param V $default
21 |      *
22 |      * @return T|V
23 |      */
24 |     public function current(int $index = 0, mixed $default = null);
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Cycleable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Cycleable
14 | {
15 |     /**
16 |      * Cycle indefinitely around a collection of items.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#cycle
19 |      *
20 |      * @return Collection<TKey, T>
21 |      */
22 |     public function cycle(): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Diffable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Diffable
14 | {
15 |     /**
16 |      * Compares the collection against another collection, iterable, or set of multiple values.
17 |      * This method will return the values in the original collection that are not present in the given argument set.
18 |      *
19 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#diff
20 |      *
21 |      * @template U
22 |      *
23 |      * @param U ...$values
24 |      *
25 |      * @return Collection<TKey, T>
26 |      */
27 |     public function diff(mixed ...$values): Collection;
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Diffkeysable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Diffkeysable
14 | {
15 |     /**
16 |      * Compares the collection against another collection, iterable, or set of multiple keys.
17 |      * This method will return the key / value pairs in the original collection that are not
18 |      * present in the given argument set.
19 |      *
20 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#diffkeys
21 |      *
22 |      * @param TKey ...$keys
23 |      *
24 |      * @return Collection<TKey, T>
25 |      */
26 |     public function diffKeys(mixed ...$keys): Collection;
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Dispersionable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Dispersionable
14 | {
15 |     /**
16 |      * This method extends the library's functionality by allowing users to calculate
17 |      * a dispersion value using the amount of value changes within the collection.
18 |      *
19 |      * For example, the set `[a, b, a]` contains three elements and two changes.
20 |      * From `a` to `b` and from `b` to `a`. Therefore, the dispersion value is
21 |      * `2 / 2 = 1`.
22 |      *
23 |      * The dispersion value is normalized between `0` and `1`. A dispersion of `0`
24 |      * indicates no dispersion, while a dispersion of `1` means maximum dispersion.
25 |      *
26 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#dispersion
27 |      *
28 |      * @return Collection<int, float|int<0,1>>
29 |      */
30 |     public function dispersion(): Collection;
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Distinctable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use Closure;
 8 | use loophp\collection\Contract\Collection;
 9 | 
10 | /**
11 |  * @template TKey
12 |  * @template T
13 |  */
14 | interface Distinctable
15 | {
16 |     /**
17 |      * Remove duplicated values from a collection, preserving keys.
18 |      * The operation has 2 optional parameters that allow you to customize precisely
19 |      * how values are accessed and compared to each other.
20 |      *
21 |      * The first parameter is the comparator. This is a curried function which takes
22 |      * first the left part, then the right part and then returns a boolean.
23 |      *
24 |      * The second parameter is the accessor. This binary function takes the value and the key
25 |      * of the current iterated value and then return the value to compare.
26 |      * This is useful when you want to compare objects.
27 |      *
28 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#distinct
29 |      *
30 |      * @template U
31 |      *
32 |      * @param null|callable(U): (Closure(U): bool) $comparatorCallback
33 |      * @param null|callable(T, TKey): U $accessorCallback
34 |      *
35 |      * @return Collection<TKey, T>
36 |      */
37 |     public function distinct(?callable $comparatorCallback = null, ?callable $accessorCallback = null): Collection;
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/DropWhileable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface DropWhileable
14 | {
15 |     /**
16 |      * Iterate over the collection items and takes from it its elements
17 |      * from the moment when the condition fails for the first time till the end of the list.
18 |      *
19 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#dropwhile
20 |      *
21 |      * @return Collection<TKey, T>
22 |      */
23 |     public function dropWhile(callable ...$callbacks): Collection;
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Dropable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Dropable
14 | {
15 |     /**
16 |      * Drop the `n` first items of the collection.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#drop
19 |      *
20 |      * @return Collection<TKey, T>
21 |      */
22 |     public function drop(int $count): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Dumpable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use Closure;
 8 | use loophp\collection\Contract\Collection;
 9 | 
10 | /**
11 |  * @template TKey
12 |  * @template T
13 |  */
14 | interface Dumpable
15 | {
16 |     /**
17 |      * Dump one or multiple items. It uses symfony/var-dumper if it is available,
18 |      * var_dump() otherwise. A custom `callback` can be also used.
19 |      *
20 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#dump
21 |      *
22 |      * @return Collection<TKey, T>
23 |      */
24 |     public function dump(string $name = '', int $size = 1, ?Closure $closure = null): Collection;
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Duplicateable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use Closure;
 8 | use loophp\collection\Contract\Collection;
 9 | 
10 | /**
11 |  * @template TKey
12 |  * @template T
13 |  */
14 | interface Duplicateable
15 | {
16 |     /**
17 |      * Find duplicated values from the collection.
18 |      * The operation has 2 optional parameters that allow you to customize precisely
19 |      * how values are accessed and compared to each other.
20 |      *
21 |      * The first parameter is the comparator. This is a curried function which takes
22 |      * first the left part, then the right part and then returns a boolean.
23 |      *
24 |      * The second parameter is the accessor. This binary function takes the value and the key
25 |      * of the current iterated value and then return the value to compare.
26 |      * This is useful when you want to compare objects.
27 |      *
28 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#duplicate
29 |      *
30 |      * @template U
31 |      *
32 |      * @param null|callable(U): (Closure(U): bool) $comparatorCallback
33 |      * @param null|callable(T, TKey): U $accessorCallback
34 |      *
35 |      * @return Collection<TKey, T>
36 |      */
37 |     public function duplicate(?callable $comparatorCallback = null, ?callable $accessorCallback = null): Collection;
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Entropyable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Entropyable
14 | {
15 |     /**
16 |      * This method extends the library's functionality by allowing users to calculate
17 |      * the normalized Shannon entropy of each item in a collection. Since it is not
18 |      * possible to calculate it lazily just like in the `average` operation, this
19 |      * operation returns a collection of entropy values, calculated individually for
20 |      * each item. Therefore, if you're looking for the entropy of the whole collection,
21 |      * you must get the last item using `last` operation.
22 |      *
23 |      * The implementation provides the normalized version of Shannon entropy.
24 |      * Normalization ensures that the entropy value is scaled between `0` and `1`,
25 |      * making it easier to compare entropy across different collections, irrespective
26 |      * of their size or the diversity of elements they contain.
27 |      *
28 |      * An entropy of `0` indicates no diversity (all elements are the same), while an
29 |      * entropy of `1` signifies maximum diversity (all elements are different).
30 |      *
31 |      * @see https://en.wikipedia.org/wiki/Entropy_(information_theory)
32 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#entropy
33 |      *
34 |      * @return Collection<int, int<0,1>|float>
35 |      */
36 |     public function entropy(): Collection;
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Equalsable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | interface Equalsable
 8 | {
 9 |     /**
10 |      * Compare two collections for equality. Collections are considered equal if:
11 |      * - they have the same number of elements;
12 |      * - they contain the same elements, regardless of the order they appear in or their keys.
13 |      *
14 |      * Elements will be compared using strict equality (`===`). If you want to customize how
15 |      * elements are compared or the order in which the keys/values appear is important, use the `same` operation.
16 |      *
17 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#equals
18 |      *
19 |      * @param iterable<mixed, mixed> $other
20 |      */
21 |     public function equals(iterable $other): bool;
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Everyable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | /**
 8 |  * @template TKey
 9 |  * @template T
10 |  */
11 | interface Everyable
12 | {
13 |     /**
14 |      * Check whether all elements in the collection pass the test implemented by the provided callback(s).
15 |      *
16 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#every
17 |      *
18 |      * @param callable(T, TKey, iterable<TKey, T>): bool ...$callbacks
19 |      */
20 |     public function every(callable ...$callbacks): bool;
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Explodeable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Explodeable
14 | {
15 |     /**
16 |      * Explode a collection into subsets based on a given value.
17 |      * This operation uses the `split` operation with the flag `Splitable::REMOVE` and thus,
18 |      * values used to explode the collection are removed from the chunks.
19 |      *
20 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#explode
21 |      *
22 |      * @return Collection<int, list<T>>
23 |      */
24 |     public function explode(mixed ...$explodes): Collection;
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Falsyable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | /**
 8 |  * @template TKey
 9 |  * @template T
10 |  */
11 | interface Falsyable
12 | {
13 |     /**
14 |      * Check if the collection contains only falsy values.
15 |      * A value is determined to be falsy by applying a `bool` cast.
16 |      *
17 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#falsy
18 |      */
19 |     public function falsy(): bool;
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Filterable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Filterable
14 | {
15 |     /**
16 |      * Filter collection items based on one or more callbacks.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#filter
19 |      *
20 |      * @param callable(T, TKey, iterable<TKey, T>): bool ...$callbacks
21 |      *
22 |      * @return Collection<TKey, T>
23 |      */
24 |     public function filter(callable ...$callbacks): Collection;
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Findable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | /**
 8 |  * @template TKey
 9 |  * @template T
10 |  */
11 | interface Findable
12 | {
13 |     /**
14 |      * Find a value in the collection that matches all predicates or return the
15 |      * default value.
16 |      *
17 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#find
18 |      *
19 |      * @template V
20 |      *
21 |      * @param V $default
22 |      * @param (callable(T, TKey, iterable<TKey, T>): bool) ...$callbacks
23 |      *
24 |      * @return T|V
25 |      */
26 |     public function find(mixed $default = null, callable ...$callbacks);
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Firstable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | /**
 8 |  * @template TKey
 9 |  * @template T
10 |  */
11 | interface Firstable
12 | {
13 |     /**
14 |      * Get the first item from the collection in a separate collection. Alias for `head`.
15 |      *
16 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#first
17 |      *
18 |      * @template V
19 |      *
20 |      * @param V $default
21 |      *
22 |      * @return T|V
23 |      */
24 |     public function first(mixed $default = null);
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/FlatMapable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface FlatMapable
14 | {
15 |     /**
16 |      * Transform the collection using a callback and keep the return value, then flatten it one level.
17 |      * The supplied callback needs to return an `iterable`: either an `array`or a class that implements Traversable.
18 |      *
19 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#flatmap
20 |      *
21 |      * @template UKey
22 |      * @template U
23 |      *
24 |      * @param callable(T, TKey, iterable<TKey, T>): iterable<UKey, U> $callback
25 |      *
26 |      * @return Collection<UKey, U>
27 |      */
28 |     public function flatMap(callable $callback): Collection;
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Flattenable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | use const PHP_INT_MAX;
10 | 
11 | /**
12 |  * @template TKey
13 |  * @template T
14 |  */
15 | interface Flattenable
16 | {
17 |     /**
18 |      * Flatten a collection of items into a simple flat collection.
19 |      *
20 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#flatten
21 |      *
22 |      * @return Collection<mixed, mixed>
23 |      */
24 |     public function flatten(int $depth = PHP_INT_MAX): Collection;
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Flipable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Flipable
14 | {
15 |     /**
16 |      * Flip keys and items in a collection.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#flip
19 |      *
20 |      * @return Collection<T, TKey>
21 |      */
22 |     public function flip(): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/FoldLeft1able.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | /**
 8 |  * @template TKey
 9 |  * @template T
10 |  */
11 | interface FoldLeft1able
12 | {
13 |     /**
14 |      * Takes the first two items of the list and applies the function to them, then feeds
15 |      * the function with this result and the third argument and so on. See `scanLeft1` for intermediate results.
16 |      *
17 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#foldleft1
18 |      *
19 |      * @template V
20 |      *
21 |      * @param callable((T|V), T, TKey, iterable<TKey, T>): V $callback
22 |      *
23 |      * @return V
24 |      */
25 |     public function foldLeft1(callable $callback): mixed;
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/FoldLeftable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | /**
 8 |  * @template TKey
 9 |  * @template T
10 |  */
11 | interface FoldLeftable
12 | {
13 |     /**
14 |      * Takes the initial value and the first item of the list and applies the function to them, then feeds
15 |      * the function with this result and the second argument and so on. See `scanLeft` for intermediate results.
16 |      *
17 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#foldleft
18 |      *
19 |      * @template V
20 |      *
21 |      * @param callable(V, T, TKey, iterable<TKey, T>): V $callback
22 |      * @param V $initial
23 |      *
24 |      * @return V
25 |      */
26 |     public function foldLeft(callable $callback, mixed $initial);
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/FoldRight1able.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | /**
 8 |  * @template TKey
 9 |  * @template T
10 |  */
11 | interface FoldRight1able
12 | {
13 |     /**
14 |      * @template V
15 |      *
16 |      * @param callable((T|V), T, TKey, iterable<TKey, T>): V $callback
17 |      *
18 |      * @return V
19 |      */
20 |     public function foldRight1(callable $callback): mixed;
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/FoldRightable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | /**
 8 |  * @template TKey
 9 |  * @template T
10 |  */
11 | interface FoldRightable
12 | {
13 |     /**
14 |      * Takes the initial value and the last item of the list and applies the function, then it takes
15 |      * the penultimate item from the end and the result, and so on. See scanRight for intermediate results.
16 |      *
17 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#foldright
18 |      *
19 |      * @template V
20 |      *
21 |      * @param callable(V, T, TKey, iterable<TKey, T>): V $callback
22 |      * @param V $initial
23 |      *
24 |      * @return V
25 |      */
26 |     public function foldRight(callable $callback, mixed $initial): mixed;
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Forgetable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Forgetable
14 | {
15 |     /**
16 |      * Remove items having specific keys.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#forget
19 |      *
20 |      * @return Collection<TKey, T>
21 |      */
22 |     public function forget(mixed ...$keys): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Frequencyable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Frequencyable
14 | {
15 |     /**
16 |      * Calculate the frequency of the items in the collection
17 |      * Returns a new key-value collection with frequencies as keys.
18 |      *
19 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#frequency
20 |      *
21 |      * @return Collection<int, T>
22 |      */
23 |     public function frequency(): Collection;
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Getable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | /**
 8 |  * @template TKey
 9 |  * @template T
10 |  */
11 | interface Getable
12 | {
13 |     /**
14 |      * Get a specific element of the collection from a key; if the key doesn't exist, returns the default value.
15 |      *
16 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#get
17 |      *
18 |      * @template V
19 |      *
20 |      * @param TKey $key
21 |      * @param V $default
22 |      *
23 |      * @return T|V
24 |      */
25 |     public function get(mixed $key, mixed $default = null);
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/GroupByable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface GroupByable
14 | {
15 |     /**
16 |      * Group items based on a custom callback.
17 |      * The grouping will be based on the returned value of the callback.
18 |      * The callback takes two parameters, the value and the key of the current
19 |      * item in the iterator, the returned value must be an integer or a string.
20 |      *
21 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#groupby
22 |      *
23 |      * @param callable(T, TKey): array-key $callback
24 |      *
25 |      * @return Collection<array-key, non-empty-list<T>>
26 |      */
27 |     public function groupBy(callable $callback): Collection;
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Groupable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Groupable
14 | {
15 |     /**
16 |      * Takes a list and returns a list of lists such that the concatenation of the result is equal to the argument.
17 |      * Moreover, each sublist in the result contains only equal elements.
18 |      *
19 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#group
20 |      *
21 |      * @return Collection<int, list<T>>
22 |      */
23 |     public function group(): Collection;
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Hasable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | /**
 8 |  * @template TKey
 9 |  * @template T
10 |  */
11 | interface Hasable
12 | {
13 |     /**
14 |      * Check if the collection has values with the help of one or more callables.
15 |      *
16 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#has
17 |      *
18 |      * @param callable(T, TKey, iterable<TKey, T>): T ...$callbacks
19 |      */
20 |     public function has(callable ...$callbacks): bool;
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Headable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | /**
 8 |  * @template TKey
 9 |  * @template T
10 |  */
11 | interface Headable
12 | {
13 |     /**
14 |      * Get the first item from the collection in a separate collection. Same as `first`.
15 |      *
16 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#head
17 |      *
18 |      * @template V
19 |      *
20 |      * @param V $default
21 |      *
22 |      * @return T|V
23 |      */
24 |     public function head(mixed $default = null);
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/IfThenElseable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface IfThenElseable
14 | {
15 |     /**
16 |      * Execute a mapping callback on each item of the collection when a condition is met.
17 |      * If no `else` callback is provided, the identity function is applied (elements are not modified).
18 |      *
19 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#ifthenelse
20 |      *
21 |      * @return Collection<TKey, T>
22 |      */
23 |     public function ifThenElse(callable $condition, callable $then, ?callable $else = null): Collection;
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Implodeable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | /**
 8 |  * @template TKey
 9 |  * @template T
10 |  */
11 | interface Implodeable
12 | {
13 |     /**
14 |      * Join all the elements of the collection into a single string
15 |      * using a glue provided or the empty string as default.
16 |      *
17 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#implode
18 |      */
19 |     public function implode(string $glue = ''): string;
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Initable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Initable
14 | {
15 |     /**
16 |      * Returns the collection without its last item.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#init
19 |      *
20 |      * @return Collection<TKey, T>
21 |      */
22 |     public function init(): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Initsable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Initsable
14 | {
15 |     /**
16 |      * Returns all initial segments of the collection, shortest first.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#inits
19 |      *
20 |      * @return Collection<int, list<array{0: TKey, 1: T}>>
21 |      */
22 |     public function inits(): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Intersectable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Intersectable
14 | {
15 |     /**
16 |      * Removes any values from the original collection that are not present in the given values set.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#intersect
19 |      *
20 |      * @return Collection<TKey, T>
21 |      */
22 |     public function intersect(mixed ...$values): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Intersectkeysable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Intersectkeysable
14 | {
15 |     /**
16 |      * Removes any keys from the original collection that are not present in the given keys set.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#intersectkeys
19 |      *
20 |      * @return Collection<TKey, T>
21 |      */
22 |     public function intersectKeys(mixed ...$keys): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Intersperseable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Intersperseable
14 | {
15 |     /**
16 |      * Insert a given value at every n element of a collection; indices are not preserved.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#intersperse
19 |      *
20 |      * @template U
21 |      *
22 |      * @param U $element
23 |      *
24 |      * @return Collection<TKey, T|U>
25 |      */
26 |     public function intersperse(mixed $element, int $every = 1, int $startAt = 0): Collection;
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/IsEmptyable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | /**
 8 |  * @template TKey
 9 |  * @template T
10 |  */
11 | interface IsEmptyable
12 | {
13 |     /**
14 |      * Check if a collection has no elements inside.
15 |      *
16 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#isempty
17 |      */
18 |     public function isEmpty(): bool;
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/IsNotEmptyable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | /**
 8 |  * @template TKey
 9 |  * @template T
10 |  */
11 | interface IsNotEmptyable
12 | {
13 |     /**
14 |      * Check if a collection has at least one element inside.
15 |      *
16 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#isnotempty
17 |      */
18 |     public function isNotEmpty(): bool;
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Keyable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | /**
 8 |  * @template TKey
 9 |  * @template T
10 |  */
11 | interface Keyable
12 | {
13 |     /**
14 |      * Get the key of an item in the collection given a numeric index, default index is 0.
15 |      *
16 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#key
17 |      *
18 |      * @return TKey|null
19 |      */
20 |     public function key(int $index = 0);
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Keysable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Keysable
14 | {
15 |     /**
16 |      * Get the keys of the items.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#keys
19 |      *
20 |      * @return Collection<int, TKey>
21 |      */
22 |     public function keys(): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Lastable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | /**
 8 |  * @template TKey
 9 |  * @template T
10 |  */
11 | interface Lastable
12 | {
13 |     /**
14 |      * Extract the last element of a collection, which must be finite and non-empty.
15 |      *
16 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#last
17 |      *
18 |      * @template V
19 |      *
20 |      * @param V $default
21 |      *
22 |      * @return T|V
23 |      */
24 |     public function last(mixed $default = null);
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Limitable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Limitable
14 | {
15 |     /**
16 |      * Limit the number of values in the collection.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#limit
19 |      *
20 |      * @return Collection<TKey, T>
21 |      */
22 |     public function limit(int $count = -1, int $offset = 0): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Linesable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Linesable
14 | {
15 |     /**
16 |      * Split a string into lines.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#lines
19 |      *
20 |      * @return Collection<int, string>
21 |      */
22 |     public function lines(): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/MapNable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface MapNable
14 | {
15 |     /**
16 |      * Apply one or more callbacks to every item of a collection and use the return value.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#mapn
19 |      *
20 |      * @param callable(mixed, mixed, iterable<TKey, T>): mixed ...$callbacks
21 |      *
22 |      * @return Collection<mixed, mixed>
23 |      */
24 |     public function mapN(callable ...$callbacks): Collection;
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Mapable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Mapable
14 | {
15 |     /**
16 |      * Apply a single callback to every item of a collection and use the return value.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#map
19 |      *
20 |      * @template U
21 |      *
22 |      * @param callable(T, TKey, iterable<TKey, T>): U $callback
23 |      *
24 |      * @return Collection<TKey, U>
25 |      */
26 |     public function map(callable $callback): Collection;
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Matchable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | /**
 8 |  * @template TKey
 9 |  * @template T
10 |  */
11 | interface Matchable
12 | {
13 |     /**
14 |      * Check if the collection matches a given `user callback`.
15 |      * You must provide a callback that can get the `key`, the `current value`, and the `iterator` as parameters.
16 |      * When no matcher callback is provided, the user callback must return `true`
17 |      * (the default value of the matcher callback) in order to stop.
18 |      *
19 |      * The returned value of the operation is `true` when the callback matches at least
20 |      * one element of the collection, `false` otherwise.
21 |      * If you want to match the `user callback` against another value (other than `true`),
22 |      * you must provide your own `matcher callback` as a second argument, and it must return a `boolean`.
23 |      *
24 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#match
25 |      *
26 |      * @param callable(T, TKey, iterable<TKey, T>): bool $callback
27 |      * @param null|callable(T, TKey, iterable<TKey, T>): bool $matcher
28 |      */
29 |     public function match(callable $callback, ?callable $matcher = null): bool;
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Matchingable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use Doctrine\Common\Collections\Criteria;
 8 | use loophp\collection\Contract\Collection;
 9 | 
10 | /**
11 |  * @template TKey
12 |  * @template T
13 |  */
14 | interface Matchingable
15 | {
16 |     /**
17 |      * Collection lets you use the Criteria API provided by Doctrine Collections, but in a lazy way.
18 |      *
19 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#matching
20 |      *
21 |      * @return Collection<TKey, T>
22 |      */
23 |     public function matching(Criteria $criteria): Collection;
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Maxable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | /**
 8 |  * @template TKey
 9 |  * @template T
10 |  */
11 | interface Maxable
12 | {
13 |     /**
14 |      * Generate the maximum value of the collection by successively applying the PHP `max` function
15 |      * to each pair of two elements.
16 |      *
17 |      * If custom logic is required to determine the maximum, such as when comparing objects,
18 |      * the `compare` operation can be used instead.
19 |      *
20 |      * @see https://www.php.net/manual/en/function.max.php
21 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#max
22 |      *
23 |      * @template V
24 |      *
25 |      * @param V $default
26 |      *
27 |      * @return T|V
28 |      */
29 |     public function max(mixed $default = null);
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Mergeable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Mergeable
14 | {
15 |     /**
16 |      * Merge one or more iterables onto a collection.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#merge
19 |      *
20 |      * @template U
21 |      *
22 |      * @param iterable<U> ...$sources
23 |      *
24 |      * @return Collection<TKey, T|U>
25 |      */
26 |     public function merge(iterable ...$sources): Collection;
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Minable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | /**
 8 |  * @template TKey
 9 |  * @template T
10 |  */
11 | interface Minable
12 | {
13 |     /**
14 |      * Generate the minimum value of the collection by successively applying the PHP `min` function
15 |      * to each pair of two elements.
16 |      *
17 |      * If custom logic is required to determine the minimum, such as when comparing objects,
18 |      * the `compare` operation can be used instead.
19 |      *
20 |      * @see https://www.php.net/manual/en/function.min.php
21 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#min
22 |      *
23 |      * @template V
24 |      *
25 |      * @param V $default
26 |      *
27 |      * @return T|V
28 |      */
29 |     public function min(mixed $default = null);
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Normalizeable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Normalizeable
14 | {
15 |     /**
16 |      * Replace, reorder and use numeric keys on a collection.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#normalize
19 |      *
20 |      * @return Collection<int, T>
21 |      */
22 |     public function normalize(): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Nthable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Nthable
14 | {
15 |     /**
16 |      * Get every n-th element of a collection.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#nth
19 |      *
20 |      * @return Collection<TKey, T>
21 |      */
22 |     public function nth(int $step, int $offset = 0): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Nullsyable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | /**
 8 |  * @template TKey
 9 |  * @template T
10 |  */
11 | interface Nullsyable
12 | {
13 |     /**
14 |      * Check if the collection contains only *nullsy* values.
15 |      *
16 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#nullsy
17 |      */
18 |     public function nullsy(): bool;
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Packable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Packable
14 | {
15 |     /**
16 |      * Wrap each item into an array containing 2 items: the key and the value.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#pack
19 |      *
20 |      * @return Collection<int, array{0: TKey, 1: T}>
21 |      */
22 |     public function pack(): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Padable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Padable
14 | {
15 |     /**
16 |      * Pad a collection to the given length with a given value.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#pad
19 |      *
20 |      * @template U
21 |      *
22 |      * @param U $value
23 |      *
24 |      * @return Collection<int|TKey, T|U>
25 |      */
26 |     public function pad(int $size, mixed $value): Collection;
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Pairable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Pairable
14 | {
15 |     /**
16 |      * Make an associative collection from pairs of values.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#pair
19 |      *
20 |      * @return Collection<T, T|null>
21 |      */
22 |     public function pair(): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Partitionable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Collection;
 8 | use loophp\collection\Contract\Collection as CollectionInterface;
 9 | 
10 | /**
11 |  * @template TKey
12 |  * @template T
13 |  */
14 | interface Partitionable
15 | {
16 |     /**
17 |      * Partition the collection into two subgroups of items using one or more callables.
18 |      *
19 |      * The first inner collection contains items that have met the provided callback(s).
20 |      * The second (and last) collection contains items that have not met the provided callback(s).
21 |      *
22 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#partition
23 |      *
24 |      * @param callable(T, TKey, iterable<TKey, T>): bool ...$callbacks
25 |      *
26 |      * @return CollectionInterface<int, Collection<TKey, T>>
27 |      */
28 |     public function partition(callable ...$callbacks): CollectionInterface;
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Permutateable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Permutateable
14 | {
15 |     /**
16 |      * Find all the permutations of a collection.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#permutate
19 |      *
20 |      * @return Collection<TKey, T>
21 |      */
22 |     public function permutate(): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Pipeable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Pipeable
14 | {
15 |     /**
16 |      * Pipe together multiple operations and apply them in succession to the collection items.
17 |      * To maintain a lazy nature, each operation needs to return a `Generator`.
18 |      * Custom operations and operations provided in the API can be combined together.
19 |      *
20 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#pipe
21 |      *
22 |      * @param callable(iterable<TKey, T>): iterable<TKey, T> ...$callbacks
23 |      *
24 |      * @return Collection<TKey, T>
25 |      */
26 |     public function pipe(callable ...$callbacks): Collection;
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Pluckable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Pluckable
14 | {
15 |     /**
16 |      * Retrieves all of the values of a collection for a given key.
17 |      * Nested values can be retrieved using “dot notation” and the wildcard character `*`.
18 |      *
19 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#pluck
20 |      *
21 |      * @param array<int, string>|array-key $pluck
22 |      *
23 |      * @return Collection<int, iterable<int, T>|T>
24 |      */
25 |     public function pluck(mixed $pluck, mixed $default = null): Collection;
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Prependable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Prependable
14 | {
15 |     /**
16 |      * Push an item onto the beginning of the collection.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#prepend
19 |      *
20 |      * @template U
21 |      *
22 |      * @param U ...$items
23 |      *
24 |      * @return Collection<int|TKey, T|U>
25 |      */
26 |     public function prepend(mixed ...$items): Collection;
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Productable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Productable
14 | {
15 |     /**
16 |      * Get the the cartesian product of items of a collection.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#product
19 |      *
20 |      * @template UKey
21 |      * @template U
22 |      *
23 |      * @param iterable<UKey, U> ...$iterables
24 |      *
25 |      * @return Collection<TKey, list<T|U>>
26 |      */
27 |     public function product(iterable ...$iterables): Collection;
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/RSampleable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface RSampleable
14 | {
15 |     /**
16 |      * Take a random sample of elements of items from a collection.
17 |      * Accepts a probability parameter which will influence the number of items sampled;
18 |      * higher probabilities increase the chance of sampling close to the entire collection.
19 |      *
20 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#rsample
21 |      *
22 |      * @return Collection<TKey, T>
23 |      */
24 |     public function rsample(float $probability): Collection;
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Randomable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Randomable
14 | {
15 |     /**
16 |      * Returns a random item from the collection.
17 |      *
18 |      * An optional integer can be passed to random to specify how many items you would like to randomly retrieve.
19 |      * An optional seed can be passed as well.
20 |      *
21 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#random
22 |      *
23 |      * @return Collection<TKey, T>
24 |      */
25 |     public function random(int $size = 1, ?int $seed = null): Collection;
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Rangeable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | use const INF;
10 | 
11 | interface Rangeable
12 | {
13 |     /**
14 |      * Build a collection from a range of values.
15 |      *
16 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#range
17 |      *
18 |      * @return Collection<int, float>
19 |      */
20 |     public static function range(float $start = 0.0, float $end = INF, float $step = 1.0): Collection;
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Reduceable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | /**
 8 |  * @template TKey
 9 |  * @template T
10 |  */
11 | interface Reduceable
12 | {
13 |     /**
14 |      * Reduce a collection of items through a given callback.
15 |      *
16 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#reduce
17 |      *
18 |      * @template V
19 |      *
20 |      * @param callable(V, T, TKey, iterable<TKey, T>): V $callback
21 |      * @param V $initial
22 |      *
23 |      * @return V
24 |      */
25 |     public function reduce(callable $callback, mixed $initial = null);
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Reductionable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Reductionable
14 | {
15 |     /**
16 |      * Reduce a collection of items through a given callback and yield each intermediary results.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#reduction
19 |      *
20 |      * @template V
21 |      *
22 |      * @param callable(V, T, TKey, iterable<TKey, T>): V $callback
23 |      * @param V $initial
24 |      *
25 |      * @return Collection<TKey|int, V>
26 |      */
27 |     public function reduction(callable $callback, mixed $initial = null): Collection;
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Rejectable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Rejectable
14 | {
15 |     /**
16 |      * Reject collection items based on one or more callbacks.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#reject
19 |      *
20 |      * @param callable(T, TKey, iterable<TKey, T>): bool ...$callbacks
21 |      *
22 |      * @return Collection<TKey, T>
23 |      */
24 |     public function reject(callable ...$callbacks): Collection;
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Reverseable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Reverseable
14 | {
15 |     /**
16 |      * Reverse the order of items in a collection.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#reverse
19 |      *
20 |      * @return Collection<TKey, T>
21 |      */
22 |     public function reverse(): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Sameable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use Closure;
 8 | 
 9 | interface Sameable
10 | {
11 |     /**
12 |      * Compare two collections for sameness. Collections are considered same if:
13 |      * - they have the same number of elements;
14 |      * - they have the same keys and elements, in the same order.
15 |      *
16 |      * By default elements and keys will be compared using strict equality (`===`). However, this behaviour
17 |      * can be customized with a comparator callback. This should be a curried function which takes
18 |      * first the left value and key, then the right value and key, and returns a boolean.
19 |      *
20 |      * This operation will stop and return a value as soon as one of the collections has been seen fully
21 |      * or as soon as the comparison yields false for any key-value pair.
22 |      *
23 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#same
24 |      *
25 |      * @param iterable<mixed, mixed> $other
26 |      * @param null|callable(mixed, mixed): (Closure(mixed, mixed): bool) $comparatorCallback
27 |      */
28 |     public function same(iterable $other, ?callable $comparatorCallback = null): bool;
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Scaleable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Scaleable
14 | {
15 |     /**
16 |      * Scale/normalize values.Scale/normalize values.
17 |      * Values will be scaled between  `0` and `1` by default, if no desired bounds are provided.
18 |      *
19 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#scale
20 |      *
21 |      * @return Collection<TKey, float|int>
22 |      */
23 |     public function scale(
24 |         float $lowerBound,
25 |         float $upperBound,
26 |         float $wantedLowerBound = 0.0,
27 |         float $wantedUpperBound = 1.0,
28 |         float $base = 0.0
29 |     ): Collection;
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/ScanLeft1able.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface ScanLeft1able
14 | {
15 |     /**
16 |      * Takes the first two items of the list and applies the function to them,
17 |      * then feeds the function with this result and the third argument and so on.
18 |      * It returns the list of intermediate and final results.
19 |      *
20 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#scanleft1
21 |      *
22 |      * @template V
23 |      *
24 |      * @param callable((T|V), T, TKey, iterable<TKey, T>): (T|V) $callback
25 |      *
26 |      * @return Collection<TKey|int, T|V>
27 |      */
28 |     public function scanLeft1(callable $callback): Collection;
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/ScanLeftable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface ScanLeftable
14 | {
15 |     /**
16 |      * Takes the initial value and the first item of the list and applies the function to them,
17 |      * then feeds the function with this result and the second argument and so on.
18 |      * It returns the list of intermediate and final results.
19 |      *
20 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#scanleft
21 |      *
22 |      * @template V
23 |      *
24 |      * @param callable(V, T, TKey, iterable<TKey, T>): V $callback
25 |      * @param V $initial
26 |      *
27 |      * @return Collection<TKey|int, V>
28 |      */
29 |     public function scanLeft(callable $callback, mixed $initial): Collection;
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/ScanRight1able.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use Iterator;
 8 | use loophp\collection\Contract\Collection;
 9 | 
10 | /**
11 |  * @template TKey
12 |  * @template T
13 |  */
14 | interface ScanRight1able
15 | {
16 |     /**
17 |      * Takes the last two items of the list and applies the function,
18 |      * then it takes the third item from the end and the result, and so on.
19 |      * It returns the list of intermediate and final results.
20 |      *
21 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#scanright1
22 |      *
23 |      * @template V
24 |      *
25 |      * @param callable((T|V), T, TKey, Iterator<TKey, T>): (T|V) $callback
26 |      *
27 |      * @return Collection<TKey|int, T|V>
28 |      */
29 |     public function scanRight1(callable $callback): Collection;
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/ScanRightable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface ScanRightable
14 | {
15 |     /**
16 |      * Takes the initial value and the last item of the list and applies the function,
17 |      * then it takes the penultimate item from the end and the result, and so on.
18 |      * It returns the list of intermediate and final results.
19 |      *
20 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#scanright
21 |      *
22 |      * @template V
23 |      *
24 |      * @param callable(V, T, TKey, iterable<TKey, T>): V $callback
25 |      * @param V $initial
26 |      *
27 |      * @return Collection<TKey|int, V>
28 |      */
29 |     public function scanRight(callable $callback, mixed $initial): Collection;
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Shuffleable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Shuffleable
14 | {
15 |     /**
16 |      * Shuffle a collection, randomly changing the order of items.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#shuffle
19 |      *
20 |      * @return Collection<TKey, T>
21 |      */
22 |     public function shuffle(?int $seed = null): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Sinceable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Sinceable
14 | {
15 |     /**
16 |      * Skip items until the callback is met.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#since
19 |      *
20 |      * @param callable(T, TKey, iterable<TKey, T>):bool ...$callbacks
21 |      *
22 |      * @return Collection<TKey, T>
23 |      */
24 |     public function since(callable ...$callbacks): Collection;
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Sliceable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Sliceable
14 | {
15 |     /**
16 |      * Get a slice of a collection.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#slice
19 |      *
20 |      * @return Collection<TKey, T>
21 |      */
22 |     public function slice(int $offset, int $length = -1): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Sortable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use Closure;
 8 | use loophp\collection\Contract\Collection;
 9 | 
10 | /**
11 |  * @template TKey
12 |  * @template T
13 |  */
14 | interface Sortable
15 | {
16 |     public const BY_KEYS = 1;
17 | 
18 |     public const BY_VALUES = 0;
19 | 
20 |     /**
21 |      * Sort a collection using a callback. If no callback is provided, it will sort using natural order.
22 |      * By default, it will sort by values and using a callback.
23 |      * If you want to sort by keys, you can pass a parameter to change the behaviour or use twice the `flip` operation.
24 |      *
25 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#sort
26 |      *
27 |      * @param null|callable|Closure(T, T, TKey, TKey): int $callback
28 |      *
29 |      * @return Collection<TKey, T>
30 |      */
31 |     public function sort(int $type = Sortable::BY_VALUES, null|callable|Closure $callback = null): Collection;
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Spanable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Collection;
 8 | use loophp\collection\Contract\Collection as CollectionInterface;
 9 | 
10 | /**
11 |  * @template TKey
12 |  * @template T
13 |  */
14 | interface Spanable
15 | {
16 |     /**
17 |      * Partition the collection into two subgroups where the first element is the longest prefix (possibly empty)
18 |      * of elements that satisfy the callback(s) and the second element is the remainder.
19 |      *
20 |      * The first inner collection is the result of a `TakeWhile` operation.
21 |      * The second (and last) inner collection is the result of a `DropWhile` operation.
22 |      *
23 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#span
24 |      *
25 |      * @param callable(T, TKey, iterable<TKey, T>): bool ...$callbacks
26 |      *
27 |      * @return CollectionInterface<int, Collection<TKey, T>>
28 |      */
29 |     public function span(callable ...$callbacks): CollectionInterface;
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Splitable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Splitable
14 | {
15 |     public const AFTER = 1;
16 | 
17 |     public const BEFORE = -1;
18 | 
19 |     public const REMOVE = 0;
20 | 
21 |     /**
22 |      * Split a collection using one or more callbacks.
23 |      *
24 |      * A flag must be provided in order to specify whether the value used to split the collection
25 |      * should be added at the end of a chunk, at the beginning of a chunk, or completely removed.
26 |      *
27 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#split
28 |      *
29 |      * @return Collection<int, list<T>>
30 |      */
31 |     public function split(int $type = Splitable::BEFORE, callable ...$callbacks): Collection;
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Squashable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Squashable
14 | {
15 |     /**
16 |      * Eagerly apply operations in a collection rather than lazily.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#squash
19 |      *
20 |      * @return Collection<TKey, T>
21 |      */
22 |     public function squash(): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Strictable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Strictable
14 | {
15 |     /**
16 |      * Enforce a single type in the collection at runtime.
17 |      * If the collection contains objects, they will either be expected to implement the same interfaces
18 |      * or be of the exact same class (no inheritance logic applies).
19 |      *
20 |      * Note that the current logic allows *arrays* of any type in the collection, as well as *null*.
21 |      *
22 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#strict
23 |      *
24 |      * @param null|callable(mixed): string $callback
25 |      *
26 |      * @return Collection<TKey, T>
27 |      */
28 |     public function strict(?callable $callback = null): Collection;
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Tailable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Tailable
14 | {
15 |     /**
16 |      * Get the collection items except the first.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#tail
19 |      *
20 |      * @return Collection<TKey, T>
21 |      */
22 |     public function tail(): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Tailsable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Tailsable
14 | {
15 |     /**
16 |      * Returns the list of initial segments of the collection, shortest last.
17 |      * Similar to applying tail successively and collecting all results in one list.
18 |      *
19 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#tails
20 |      *
21 |      * @return Collection<int, list<T>>
22 |      */
23 |     public function tails(): Collection;
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/TakeWhileable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface TakeWhileable
14 | {
15 |     /**
16 |      * Iterate over the collection items while the provided callback(s) are satisfied.
17 |      * It stops iterating when the callback(s) are not met.
18 |      *
19 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#takewhile
20 |      *
21 |      * @param callable(T, TKey, iterable<TKey, T>): bool ...$callbacks
22 |      *
23 |      * @return Collection<TKey, T>
24 |      */
25 |     public function takeWhile(callable ...$callbacks): Collection;
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Tappable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Tappable
14 | {
15 |     /**
16 |      * Execute callback(s) on each element of the collection.
17 |      * Iterates on the collection items regardless of the return value of the callback.
18 |      *
19 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#apply
20 |      *
21 |      * @param callable(T, TKey, iterable<TKey, T>): void ...$callbacks
22 |      *
23 |      * @return Collection<TKey, T>
24 |      */
25 |     public function tap(callable ...$callbacks): Collection;
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Timesable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | interface Timesable
10 | {
11 |     /**
12 |      * Create a collection by invoking a callback a given amount of times.
13 |      * If no callback is provided, then it will create a simple list of incremented integers.
14 |      *
15 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#times
16 |      *
17 |      * @template T
18 |      *
19 |      * @param callable(int): T $callback
20 |      *
21 |      * @return Collection<int, T>
22 |      */
23 |     public static function times(int $number = 0, ?callable $callback = null): Collection;
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Transposeable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Transposeable
14 | {
15 |     /**
16 |      * Computes the transpose of a matrix.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#transpose
19 |      *
20 |      * @return Collection<TKey, list<T>>
21 |      */
22 |     public function transpose(): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Truthyable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | /**
 8 |  * @template TKey
 9 |  * @template T
10 |  */
11 | interface Truthyable
12 | {
13 |     /**
14 |      * Check if the collection contains only truthy values. Opposite of `falsy`.
15 |      * A value is determined to be truthy by applying a `bool` cast.
16 |      *
17 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#truthy
18 |      */
19 |     public function truthy(): bool;
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Unfoldable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | interface Unfoldable
10 | {
11 |     /**
12 |      * Create a collection by yielding from a callback with an initial value.
13 |      *
14 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#unfold
15 |      *
16 |      * @template T
17 |      *
18 |      * @param callable(T...): iterable<array-key, T> $callback
19 |      * @param iterable<array-key, T> $parameters
20 |      *
21 |      * @return Collection<int, iterable<array-key, T>>
22 |      */
23 |     public static function unfold(callable $callback, iterable $parameters = []): Collection;
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Unlinesable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | /**
 8 |  * @template TKey
 9 |  * @template T
10 |  */
11 | interface Unlinesable
12 | {
13 |     /**
14 |      * Opposite of `lines`, creates a single string from multiple lines using `PHP_EOL` as the glue.
15 |      *
16 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#unlines
17 |      */
18 |     public function unlines(): string;
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Unpackable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Unpackable
14 | {
15 |     /**
16 |      * Opposite of `pack`, transforms groupings of items representing a key and a value into actual keys and values.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#unpack
19 |      *
20 |      * @return Collection<TKey, T>
21 |      */
22 |     public function unpack(): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Unpairable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Unpairable
14 | {
15 |     /**
16 |      * Opposite of `pair`, creates a flat list of values from a collection of key-value pairs.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#unpair
19 |      *
20 |      * @return Collection<int, TKey|T>
21 |      */
22 |     public function unpair(): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Untilable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Untilable
14 | {
15 |     /**
16 |      * Iterate over the collection items until the provided callback(s) are satisfied.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#until
19 |      *
20 |      * @param callable(T, TKey, iterable<TKey, T>):bool ...$callbacks
21 |      *
22 |      * @return Collection<TKey, T>
23 |      */
24 |     public function until(callable ...$callbacks): Collection;
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Unwindowable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Unwindowable
14 | {
15 |     /**
16 |      * Opposite of `window`, usually needed after a call to that operation.
17 |      * Turns already-created windows back into a flat list.
18 |      *
19 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#unwindow
20 |      *
21 |      * @return Collection<TKey, T>
22 |      */
23 |     public function unwindow(): Collection;
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Unwordsable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | /**
 8 |  * @template TKey
 9 |  * @template T
10 |  */
11 | interface Unwordsable
12 | {
13 |     /**
14 |      * Opposite of `words` and similar to `unlines`, creates a single string
15 |      * from multiple strings using one space as the glue.
16 |      *
17 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#unwords
18 |      */
19 |     public function unwords(): string;
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Unwrapable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Unwrapable
14 | {
15 |     /**
16 |      * Opposite of `wrap`, turn a collection of arrays into a flat list.
17 |      * Equivalent to `flatten(1)`.
18 |      *
19 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#unwrap
20 |      *
21 |      * @return Collection<mixed, mixed>
22 |      */
23 |     public function unwrap(): Collection;
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Unzipable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Unzipable
14 | {
15 |     /**
16 |      * Opposite of `zip`, splits zipped items in a collection.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#unzip
19 |      *
20 |      * @return Collection<int, list<T>>
21 |      */
22 |     public function unzip(): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Whenable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Whenable
14 | {
15 |     /**
16 |      * This operation will execute the given `$whenTrue` callback when the given `$predicate` callback
17 |      * evaluates to `true`. Otherwise it will execute the `$whenFalse` callback if any.
18 |      *
19 |      * Unlike the `ifThenElse` operation where the operation is applied to each element of the collection,
20 |      * this operation operates on the collection directly.
21 |      *
22 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#when
23 |      *
24 |      * @param callable(iterable<TKey, T>): bool $predicate
25 |      * @param callable(iterable<TKey, T>): iterable<TKey, T> $whenTrue
26 |      * @param callable(iterable<TKey, T>): iterable<TKey, T> $whenFalse
27 |      *
28 |      * @return Collection<TKey, T>
29 |      */
30 |     public function when(callable $predicate, callable $whenTrue, ?callable $whenFalse = null): Collection;
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Windowable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Windowable
14 | {
15 |     /**
16 |      * Loop the collection yielding windows of data by adding a given number of items to the current item.
17 |      * Initially the windows yielded will be smaller, until size `1 + $size` is reached.
18 |      *
19 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#window
20 |      *
21 |      * @return Collection<TKey, list<T>>
22 |      */
23 |     public function window(int $size): Collection;
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Wordsable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Wordsable
14 | {
15 |     /**
16 |      * Get a list of words from a string, splitting based on the character set: \t, \n, ' '.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#words
19 |      *
20 |      * @return Collection<TKey, string>
21 |      */
22 |     public function words(): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Wrapable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Wrapable
14 | {
15 |     /**
16 |      * Wrap every element into an array.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#wrap
19 |      *
20 |      * @return Collection<int, array<TKey, T>>
21 |      */
22 |     public function wrap(): Collection;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contract/Operation/Zipable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Contract\Operation;
 6 | 
 7 | use loophp\collection\Contract\Collection;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  * @template T
12 |  */
13 | interface Zipable
14 | {
15 |     /**
16 |      * Zip a collection together with one or more iterables.
17 |      *
18 |      * @see https://loophp-collection.readthedocs.io/en/stable/pages/api.html#zip
19 |      *
20 |      * @template U
21 |      * @template UKey
22 |      *
23 |      * @param iterable<UKey, U> ...$iterables
24 |      *
25 |      * @return Collection<list<TKey|UKey>, list<T|U>>
26 |      */
27 |     public function zip(iterable ...$iterables): Collection;
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Operation/AbstractOperation.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use loophp\collection\Contract\Operation;
 9 | 
10 | /**
11 |  * @immutable
12 |  */
13 | abstract class AbstractOperation implements Operation
14 | {
15 |     final public function __construct() {}
16 | 
17 |     public static function of(): Closure
18 |     {
19 |         return (new static())->__invoke();
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Operation/Append.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\iterators\ConcatIterableAggregate;
10 | 
11 | /**
12 |  * @immutable
13 |  *
14 |  * @template TKey
15 |  * @template T
16 |  */
17 | final class Append extends AbstractOperation
18 | {
19 |     /**
20 |      * @template U
21 |      *
22 |      * @return Closure(array<U>): Closure(iterable<TKey, T>): Generator<int|TKey, T|U>
23 |      */
24 |     public function __invoke(): Closure
25 |     {
26 |         return
27 |             /**
28 |              * @param array<U> $items
29 |              *
30 |              * @return Closure(iterable<TKey, T>): Generator<int|TKey, T|U>
31 |              */
32 |             static fn (array $items): Closure =>
33 |                 /**
34 |                  * @param iterable<TKey, T> $iterable
35 |                  *
36 |                  * @return Generator<int|TKey, T|U>
37 |                  */
38 |                 static fn (iterable $iterable): Generator => yield from new ConcatIterableAggregate([$iterable, $items]);
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Operation/Apply.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Apply extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(callable(T, TKey, iterable<TKey, T>):bool ...): Closure(iterable<TKey, T>): Generator<TKey, T>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         return
24 |             /**
25 |              * @param callable(T, TKey, iterable<TKey, T>): bool ...$callbacks
26 |              *
27 |              * @return Closure(iterable<TKey, T>): Generator<TKey, T>
28 |              */
29 |             static fn (callable ...$callbacks): Closure =>
30 |                 /**
31 |                  * @param iterable<TKey, T> $iterable
32 |                  *
33 |                  * @return Generator<TKey, T>
34 |                  */
35 |                 static function (iterable $iterable) use ($callbacks): Generator {
36 |                     foreach ($iterable as $key => $value) {
37 |                         foreach ($callbacks as $cKey => $callback) {
38 |                             if (false === $callback($value, $key, $iterable)) {
39 |                                 unset($callbacks[$cKey]);
40 |                             }
41 |                         }
42 | 
43 |                         yield $key => $value;
44 |                     }
45 |                 };
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Operation/Averages.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Averages extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(iterable<TKey, T>): Generator<int, float>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         /** @var Closure(iterable<TKey, T>): Generator<int, float> $pipe */
24 |         $pipe = (new Pipe())()(
25 |             (new Normalize())(),
26 |             (new ScanLeft1())()(
27 |                 static fn (float $acc, float $value, int $key): float => ($acc * $key + $value) / ($key + 1)
28 |             )
29 |         );
30 | 
31 |         return $pipe;
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Operation/Cache.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\collection\Iterator\PsrCacheIterator;
10 | use loophp\iterators\IterableIteratorAggregate;
11 | use Psr\Cache\CacheItemPoolInterface;
12 | 
13 | /**
14 |  * @immutable
15 |  *
16 |  * @template TKey
17 |  * @template T
18 |  */
19 | final class Cache extends AbstractOperation
20 | {
21 |     /**
22 |      * @return Closure(CacheItemPoolInterface): Closure(iterable<TKey, T>): Generator<TKey, T>
23 |      */
24 |     public function __invoke(): Closure
25 |     {
26 |         return
27 |             /**
28 |              * @return Closure(iterable<TKey, T>): Generator<TKey, T>
29 |              */
30 |             static fn (CacheItemPoolInterface $cache): Closure =>
31 |                 /**
32 |                  * @param iterable<TKey, T> $iterable
33 |                  *
34 |                  * @return Generator<TKey, T>
35 |                  */
36 |                 static fn (iterable $iterable): Generator => yield from new PsrCacheIterator((new IterableIteratorAggregate($iterable))->getIterator(), $cache);
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Operation/Coalesce.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Coalesce extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(iterable<TKey, T>): Generator<TKey, T>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         /** @var Closure(iterable<TKey, T>): Generator<TKey, T> $pipe */
24 |         $pipe = (new Pipe())()(
25 |             (new Compact())()([]),
26 |             (new Head())(),
27 |         );
28 | 
29 |         // Point free style.
30 |         return $pipe;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Operation/Collapse.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Collapse extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(iterable<TKey, (T|iterable<TKey, T>)>): Generator<TKey, T>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         $filterCallback =
24 |             /**
25 |              * @param T $value
26 |              */
27 |             static fn (mixed $value): bool => is_iterable($value);
28 | 
29 |         /** @var Closure(iterable<TKey, (T|iterable<TKey, T>)>): Generator<TKey, T> $pipe */
30 |         $pipe = (new Pipe())()(
31 |             (new Filter())()($filterCallback),
32 |             (new Flatten())()(1),
33 |         );
34 | 
35 |         // Point free style.
36 |         return $pipe;
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Operation/Column.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Column extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(mixed): Closure(iterable<TKey, T>): Generator<int, mixed>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         return
24 |             /**
25 |              * @return Closure(iterable<TKey, T>): Generator<int, mixed>
26 |              */
27 |             static function (mixed $column): Closure {
28 |                 $filterCallbackBuilder =
29 |                     /**
30 |                      * @param T $value
31 |                      * @param TKey $key
32 |                      */
33 |                     static fn (mixed $value, mixed $key): bool => $key === $column;
34 | 
35 |                 /** @var Closure(iterable<TKey, T>): Generator<int, mixed> $pipe */
36 |                 $pipe = (new Pipe())()(
37 |                     (new Transpose())(),
38 |                     (new Filter())()($filterCallbackBuilder),
39 |                     (new Head())(),
40 |                     (new Flatten())()(1)
41 |                 );
42 | 
43 |                 // Point free style.
44 |                 return $pipe;
45 |             };
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Operation/Combine.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\iterators\MultipleIterableAggregate;
10 | use MultipleIterator;
11 | 
12 | /**
13 |  * @immutable
14 |  *
15 |  * @template TKey
16 |  * @template T
17 |  */
18 | final class Combine extends AbstractOperation
19 | {
20 |     /**
21 |      * @template U
22 |      *
23 |      * @return Closure(array<U>): Closure(iterable<TKey, T>): Generator<null|U, null|T>
24 |      */
25 |     public function __invoke(): Closure
26 |     {
27 |         return
28 |             /**
29 |              * @param array<U> $keys
30 |              *
31 |              * @return Closure(iterable<TKey, T>): Generator<null|U, null|T>
32 |              */
33 |             static function (array $keys): Closure {
34 |                 $buildMultipleIterable =
35 |                     /**
36 |                      * @param iterable<TKey, T> $iterable
37 |                      */
38 |                     static fn (iterable $iterable): Generator => yield from new MultipleIterableAggregate([$keys, $iterable], MultipleIterator::MIT_NEED_ANY);
39 | 
40 |                 /** @var Closure(iterable<TKey, T>): Generator<null|U, null|T> $pipe */
41 |                 $pipe = (new Pipe())()(
42 |                     $buildMultipleIterable,
43 |                     (new Flatten())()(1),
44 |                     (new Pair())(),
45 |                 );
46 | 
47 |                 // Point free style.
48 |                 return $pipe;
49 |             };
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/Operation/Compact.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | use function in_array;
11 | 
12 | /**
13 |  * @immutable
14 |  *
15 |  * @template TKey
16 |  * @template T
17 |  */
18 | final class Compact extends AbstractOperation
19 | {
20 |     /**
21 |      * @return Closure(array<T>): Closure(iterable<TKey, T>): Generator<TKey, T>
22 |      */
23 |     public function __invoke(): Closure
24 |     {
25 |         return
26 |             /**
27 |              * @param array<T> $values
28 |              *
29 |              * @return Closure(iterable<TKey, T>): Generator<TKey, T>
30 |              */
31 |             static function (array $values): Closure {
32 |                 $filterCallback =
33 |                     /**
34 |                      * @param non-empty-array<int, (null|array|int|bool|string|T)> $values
35 |                      */
36 |                     static fn (array $values): Closure =>
37 |                         /**
38 |                          * @param T $value
39 |                          */
40 |                         static fn (mixed $value): bool => !in_array($value, $values, true);
41 | 
42 |                 return (new Filter())()(
43 |                     $filterCallback(
44 |                         [] === $values ?
45 |                             Nullsy::VALUES :
46 |                             $values
47 |                     )
48 |                 );
49 |             };
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/Operation/Compare.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Compare extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(callable(T, T, TKey, iterable<TKey, T>): T): Closure(iterable<TKey, T>): Generator<TKey, T>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         return
24 |             /**
25 |              * @param callable(T, T, TKey, iterable<TKey, T>): T $comparator
26 |              *
27 |              * @return Closure(iterable<TKey, T>): Generator<TKey,T>
28 |              */
29 |             static function (callable $comparator): Closure {
30 |                 /** @var Closure(iterable<TKey, T>): Generator<TKey, T> $foldLeft1 */
31 |                 $foldLeft1 = (new FoldLeft1())()($comparator);
32 | 
33 |                 // Point free style.
34 |                 return $foldLeft1;
35 |             };
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Operation/Contains.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | use function in_array;
11 | 
12 | /**
13 |  * @immutable
14 |  *
15 |  * @template TKey
16 |  * @template T
17 |  */
18 | final class Contains extends AbstractOperation
19 | {
20 |     /**
21 |      * @return Closure(array<T>): Closure(iterable<TKey, T>): Generator<TKey, bool>
22 |      */
23 |     public function __invoke(): Closure
24 |     {
25 |         return
26 |             /**
27 |              * @param array<T> $values
28 |              *
29 |              * @return Closure(iterable<TKey, T>): Generator<TKey, bool>
30 |              */
31 |             static fn (array $values): Closure => (new MatchOne())()(static fn (): bool => true)(
32 |                 /**
33 |                  * @param T $value
34 |                  */
35 |                 static fn (mixed $value): bool => in_array($value, $values, true)
36 |             );
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Operation/Current.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Current extends AbstractOperation
17 | {
18 |     /**
19 |      * @template V
20 |      *
21 |      * @return Closure(int): Closure(V): Closure(iterable<TKey, T>): Generator<int, T|V>
22 |      */
23 |     public function __invoke(): Closure
24 |     {
25 |         return
26 |             /**
27 |              * @return Closure(V): Closure(iterable<TKey, T>): Generator<int, T|V>
28 |              */
29 |             static fn (int $index): Closure =>
30 |             /**
31 |              * @param V $default
32 |              *
33 |              * @return Closure(iterable<TKey, T>): Generator<int, T|V>
34 |              */
35 |             static function (mixed $default) use ($index): Closure {
36 |                 /** @var Closure(iterable<TKey, T>): Generator<int, T|V> $pipe */
37 |                 $pipe = (new Pipe())()(
38 |                     (new Normalize())(),
39 |                     (new Get())()($index)($default)
40 |                 );
41 | 
42 |                 // Point free style.
43 |                 return $pipe;
44 |             };
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Operation/Cycle.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use loophp\iterators\InfiniteIteratorAggregate;
 9 | use loophp\iterators\IterableIteratorAggregate;
10 | 
11 | /**
12 |  * @immutable
13 |  *
14 |  * @template TKey
15 |  * @template T
16 |  */
17 | final class Cycle extends AbstractOperation
18 | {
19 |     /**
20 |      * @return Closure(iterable<TKey, T>): iterable<TKey, T>
21 |      */
22 |     public function __invoke(): Closure
23 |     {
24 |         return
25 |             /**
26 |              * @param iterable<TKey, T> $iterable
27 |              *
28 |              * @return iterable<TKey, T>
29 |              */
30 |             static function (iterable $iterable): iterable {
31 |                 yield from new InfiniteIteratorAggregate((new IterableIteratorAggregate($iterable))->getIterator());
32 |             };
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Operation/Diff.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | use function in_array;
11 | 
12 | /**
13 |  * @immutable
14 |  *
15 |  * @template TKey
16 |  * @template T
17 |  */
18 | final class Diff extends AbstractOperation
19 | {
20 |     /**
21 |      * @return Closure(array<T>): Closure(iterable<TKey, T>): Generator<TKey, T>
22 |      */
23 |     public function __invoke(): Closure
24 |     {
25 |         return
26 |             /**
27 |              * @param array<T> $values
28 |              *
29 |              * @return Closure(iterable<TKey, T>): Generator<TKey, T>
30 |              */
31 |             static fn (array $values): Closure => (new Filter())()(
32 |                 /**
33 |                  * @param T $value
34 |                  */
35 |                 static fn (mixed $value): bool => !in_array($value, $values, true)
36 |             );
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Operation/DiffKeys.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | use function in_array;
11 | 
12 | /**
13 |  * @immutable
14 |  *
15 |  * @template TKey
16 |  * @template T
17 |  */
18 | final class DiffKeys extends AbstractOperation
19 | {
20 |     /**
21 |      * @return Closure(array<TKey>): Closure(iterable<TKey, T>): Generator<TKey, T>
22 |      */
23 |     public function __invoke(): Closure
24 |     {
25 |         return
26 |             /**
27 |              * @param array<TKey> $keys
28 |              *
29 |              * @return Closure(iterable<TKey, T>): Generator<TKey, T>
30 |              */
31 |             static fn (array $keys): Closure => (new Filter())()(
32 |                 /**
33 |                  * @param T $value
34 |                  * @param TKey $key
35 |                  */
36 |                 static fn (mixed $value, mixed $key): bool => !in_array($key, $keys, true)
37 |             );
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Operation/Dispersion.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Dispersion extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(iterable<TKey, T>): Generator<int, float|int<0,1>>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         /** @var Closure(iterable<TKey, T>): Generator<int, float|int<0,1>> $pipe */
24 |         $pipe = (new Pipe())()(
25 |             (new Normalize())(),
26 |             (new ScanLeft())()(
27 |                 /**
28 |                  * @param array<numeric-string|int<0,1>, T> $acc
29 |                  * @param T $value
30 |                  *
31 |                  * @return list{float|int<0,1>, T}
32 |                  */
33 |                 static function (array $acc, mixed $value, int $key): array {
34 |                     [$c, $v] = $acc;
35 | 
36 |                     return [(0 === $key) ? 0 : (($c * ($key - 1) + (($v === $value) ? 0 : 1)) / $key), $value];
37 |                 }
38 |             )([0, null]),
39 |             (new Drop())()(1),
40 |             (new Map())()(
41 |                 /**
42 |                  * @param array<numeric-string|int<0,1>, T> $value
43 |                  *
44 |                  * @return float|int<0,1>
45 |                  */
46 |                 static fn (array $value): float|int => (0.0 === $value[0] || 1.0 === $value[0]) ? (int) $value[0] : $value[0]
47 |             )
48 |         );
49 | 
50 |         return $pipe;
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/src/Operation/Drop.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Drop extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(int): Closure(iterable<TKey, T>): Generator<TKey, T>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         return (new Limit())()(-1);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Operation/DropWhile.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\collection\Utils\CallbacksArrayReducer;
10 | 
11 | /**
12 |  * @immutable
13 |  *
14 |  * @template TKey
15 |  * @template T
16 |  */
17 | final class DropWhile extends AbstractOperation
18 | {
19 |     /**
20 |      * @return Closure(callable(T, TKey, iterable<TKey, T>): bool ...): Closure(iterable<TKey, T>): Generator<TKey, T>
21 |      */
22 |     public function __invoke(): Closure
23 |     {
24 |         return
25 |             /**
26 |              * @param callable(T, TKey, iterable<TKey, T>):bool ...$callbacks
27 |              *
28 |              * @return Closure(iterable<TKey, T>): Generator<TKey, T>
29 |              */
30 |             static fn (callable ...$callbacks): Closure =>
31 |             /**
32 |              * @param iterable<TKey, T> $iterable
33 |              *
34 |              * @return Generator<TKey, T>
35 |              */
36 |             static function (iterable $iterable) use ($callbacks): Generator {
37 |                 $skip = false;
38 |                 $callback = CallbacksArrayReducer::or()($callbacks);
39 | 
40 |                 foreach ($iterable as $key => $current) {
41 |                     if (false === $skip) {
42 |                         if (false === $callback($current, $key, $iterable)) {
43 |                             $skip = true;
44 | 
45 |                             yield $key => $current;
46 |                         }
47 | 
48 |                         continue;
49 |                     }
50 | 
51 |                     yield $key => $current;
52 |                 }
53 |             };
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/Operation/Every.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\collection\Utils\CallbacksArrayReducer;
10 | 
11 | /**
12 |  * @immutable
13 |  *
14 |  * @template TKey
15 |  * @template T
16 |  */
17 | final class Every extends AbstractOperation
18 | {
19 |     /**
20 |      * @return Closure(...callable(int, T, TKey, iterable<TKey, T>): bool): Closure(iterable<TKey, T>): Generator<int, bool>
21 |      */
22 |     public function __invoke(): Closure
23 |     {
24 |         return
25 |             /**
26 |              * @param callable(int, T, TKey, iterable<TKey, T>): bool ...$predicates
27 |              *
28 |              * @return Closure(iterable<TKey, T>): Generator<int, bool>
29 |              */
30 |             static fn (callable ...$predicates): Closure => static function (iterable $iterable) use ($predicates): Generator {
31 |                 $predicate = CallbacksArrayReducer::or()($predicates);
32 | 
33 |                 /** @var Generator<int, array{0: TKey, 1:T}> $packed */
34 |                 $packed = (new Pack())()($iterable);
35 | 
36 |                 foreach ($packed as $index => [$key, $value]) {
37 |                     if (false === $predicate($index, $value, $key, $iterable)) {
38 |                         return yield $index => false;
39 |                     }
40 |                 }
41 | 
42 |                 yield true;
43 |             };
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Operation/Explode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\collection\Contract\Operation\Splitable;
10 | 
11 | /**
12 |  * @immutable
13 |  *
14 |  * @template TKey
15 |  * @template T
16 |  */
17 | final class Explode extends AbstractOperation
18 | {
19 |     /**
20 |      * @return Closure(array<T>): Closure(iterable<TKey, T>): Generator<int, list<T>>
21 |      */
22 |     public function __invoke(): Closure
23 |     {
24 |         return
25 |             /**
26 |              * @param array<T> $explodes
27 |              *
28 |              * @return Closure(iterable<TKey, T>): Generator<int, list<T>>
29 |              */
30 |             static function (array $explodes): Closure {
31 |                 /** @var Closure(iterable<TKey, T>): Generator<int, list<T>> $split */
32 |                 $split = (new Split())()(Splitable::REMOVE)(
33 |                     ...array_map(
34 |                         /**
35 |                          * @param T $explode
36 |                          */
37 |                         static fn (mixed $explode): Closure =>
38 |                             /**
39 |                              * @param T $value
40 |                              */
41 |                             static fn (mixed $value): bool => $value === $explode,
42 |                         $explodes
43 |                     )
44 |                 );
45 | 
46 |                 // Point free style.
47 |                 return $split;
48 |             };
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/src/Operation/Falsy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Falsy extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(iterable<TKey, T>): Generator<int, bool>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         return (new Every())()(
24 |             /**
25 |              * @param T $value
26 |              */
27 |             static fn (int $index, mixed $value): bool => !(bool) $value
28 |         );
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Operation/Find.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Find extends AbstractOperation
17 | {
18 |     /**
19 |      * @template V
20 |      *
21 |      * @return Closure(V): Closure(callable(T, TKey, iterable<TKey, T>): bool ...): Closure(iterable<TKey, T>): Generator<TKey, T|V>
22 |      */
23 |     public function __invoke(): Closure
24 |     {
25 |         return
26 |             /**
27 |              * @param V $default
28 |              *
29 |              * @return Closure(callable(T, TKey, iterable<TKey, T>): bool ...): Closure(iterable<TKey, T>): Generator<TKey, T|V>
30 |              */
31 |             static fn (mixed $default): Closure =>
32 |                 /**
33 |                  * @param callable(T, TKey, iterable<TKey, T>): bool ...$callbacks
34 |                  *
35 |                  * @return Closure(iterable<TKey, T>): Generator<TKey, T|V>
36 |                  */
37 |                 static function (callable ...$callbacks) use ($default): Closure {
38 |                     /** @var Closure(iterable<TKey, T>): Generator<TKey, T|V> $pipe */
39 |                     $pipe = (new Pipe())()(
40 |                         (new Filter())()(...$callbacks),
41 |                         (new Current())()(0)($default)
42 |                     );
43 | 
44 |                     // Point free style.
45 |                     return $pipe;
46 |                 };
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/Operation/First.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class First extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(iterable<TKey, T>): Generator<TKey, T>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         return (new Head())();
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Operation/FlatMap.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class FlatMap extends AbstractOperation
17 | {
18 |     /**
19 |      * @template IKey
20 |      * @template IValue
21 |      *
22 |      * @return Closure(callable(T, TKey, iterable<TKey, T>): iterable<mixed, mixed>): Closure(iterable<TKey, T>): Generator<mixed, mixed>
23 |      */
24 |     public function __invoke(): Closure
25 |     {
26 |         return
27 |             /**
28 |              * @param callable(T, TKey, iterable<TKey, T>): iterable<mixed, mixed> $callback
29 |              */
30 |             static function (callable $callback): Closure {
31 |                 /** @var Closure(iterable<TKey, T>): Generator<IKey, IValue> $flatMap */
32 |                 $flatMap = (new Pipe())()(
33 |                     (new Map())()($callback),
34 |                     (new Flatten())()(1),
35 |                 );
36 | 
37 |                 // Point free style
38 |                 return $flatMap;
39 |             };
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Operation/Flatten.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Flatten extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(int): Closure(iterable<TKey, T>): Generator<mixed, mixed>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         return
24 |             /**
25 |              * @return Closure(iterable<TKey, T>): Generator<mixed, mixed>
26 |              */
27 |             static fn (int $depth): Closure =>
28 |                 /**
29 |                  * @param iterable<TKey, T> $iterable
30 |                  */
31 |                 static function (iterable $iterable) use ($depth): Generator {
32 |                     foreach ($iterable as $key => $value) {
33 |                         if (!is_iterable($value)) {
34 |                             yield $key => $value;
35 | 
36 |                             continue;
37 |                         }
38 | 
39 |                         yield from (1 !== $depth)
40 |                             ? (new Flatten())()($depth - 1)($value)
41 |                             : $value;
42 |                     }
43 |                 };
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Operation/Flip.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Flip extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(iterable<TKey, T>): Generator<T, TKey>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         return (new Associate())()(
24 |             /**
25 |              * @param TKey $key
26 |              * @param T $value
27 |              *
28 |              * @return T
29 |              */
30 |             static fn (mixed $key, mixed $value): mixed => $value
31 |         )(
32 |             /**
33 |              * @param T $value
34 |              * @param TKey $key
35 |              *
36 |              * @return TKey
37 |              */
38 |             static fn (mixed $value, mixed $key): mixed => $key
39 |         );
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Operation/FoldLeft.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\iterators\ReduceIterableAggregate;
10 | 
11 | /**
12 |  * @immutable
13 |  *
14 |  * @template TKey
15 |  * @template T
16 |  */
17 | final class FoldLeft extends AbstractOperation
18 | {
19 |     /**
20 |      * @template V
21 |      *
22 |      * @return Closure(callable(V, T, TKey, iterable<TKey, T>): V): Closure(V): Closure(iterable<TKey, T>): Generator<int, V>
23 |      */
24 |     public function __invoke(): Closure
25 |     {
26 |         return
27 |             /**
28 |              * @param callable(V, T, TKey, iterable<TKey, T>): V $callback
29 |              *
30 |              * @return Closure(V): Closure(iterable<TKey, T>): Generator<int, V>
31 |              */
32 |             static fn (callable $callback): Closure =>
33 |                 /**
34 |                  * @param V $initial
35 |                  *
36 |                  * @return Closure(iterable<TKey, T>): Generator<int, V>
37 |                  */
38 |                 static fn (mixed $initial): Closure =>
39 |                     /**
40 |                      * @param iterable<TKey, T> $iterable
41 |                      *
42 |                      * @return Generator<int, V>
43 |                      */
44 |                     static fn (iterable $iterable): Generator => yield from new ReduceIterableAggregate($iterable, Closure::fromCallable($callback), $initial);
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Operation/FoldLeft1.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class FoldLeft1 extends AbstractOperation
17 | {
18 |     /**
19 |      * @template V
20 |      *
21 |      * @return Closure(callable((T|V), T, TKey, iterable<TKey, T>): V): Closure(iterable<TKey, T>): Generator<int|TKey, V>
22 |      */
23 |     public function __invoke(): Closure
24 |     {
25 |         return
26 |             /**
27 |              * @param callable((T|V), T, TKey, iterable<TKey, T>): V $callback
28 |              *
29 |              * @return Closure(iterable<TKey, T>): Generator<int|TKey, V>
30 |              */
31 |             static function (callable $callback): Closure {
32 |                 /** @var Closure(iterable<TKey, T>):(Generator<int|TKey, V>) $pipe */
33 |                 $pipe = (new Pipe())()(
34 |                     (new ScanLeft1())()($callback),
35 |                     (new Last())()
36 |                 );
37 | 
38 |                 // Point free style.
39 |                 return $pipe;
40 |             };
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Operation/FoldRight.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class FoldRight extends AbstractOperation
17 | {
18 |     /**
19 |      * @template V
20 |      *
21 |      * @return Closure(callable(V, T, TKey, iterable<TKey, T>): V): Closure(V): Closure(iterable<TKey, T>): Generator<int, V>
22 |      */
23 |     public function __invoke(): Closure
24 |     {
25 |         return
26 |             /**
27 |              * @param callable(V, T, TKey, iterable<TKey, T>): V $callback
28 |              *
29 |              * @return Closure(V): Closure(iterable<TKey, T>): Generator<int, V>
30 |              */
31 |             static fn (callable $callback): Closure =>
32 |                 /**
33 |                  * @param V $initial
34 |                  *
35 |                  * @return Closure(iterable<TKey, T>): Generator<int, V>
36 |                  */
37 |                 static function (mixed $initial = null) use ($callback): Closure {
38 |                     /** @var Closure(iterable<TKey, T>): Generator<int, V> $pipe */
39 |                     $pipe = (new Pipe())()(
40 |                         (new ScanRight())()($callback)($initial),
41 |                         (new Head())()
42 |                     );
43 | 
44 |                     // Point free style.
45 |                     return $pipe;
46 |                 };
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/Operation/FoldRight1.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class FoldRight1 extends AbstractOperation
17 | {
18 |     /**
19 |      * @template V
20 |      *
21 |      * @return Closure(callable((T|V), T, TKey, iterable<TKey, T>): V): Closure(iterable<TKey, T>): Generator<int|TKey, V>
22 |      */
23 |     public function __invoke(): Closure
24 |     {
25 |         return
26 |             /**
27 |              * @param callable((T|V), T, TKey, iterable<TKey, T>): V $callback
28 |              *
29 |              * @return Closure(iterable<TKey, T>): Generator<int|TKey, V>
30 |              */
31 |             static function (callable $callback): Closure {
32 |                 /** @var Closure(iterable<TKey, T>):(Generator<int|TKey, V>) $pipe */
33 |                 $pipe = (new Pipe())()(
34 |                     (new ScanRight1())()($callback),
35 |                     (new Head())()
36 |                 );
37 | 
38 |                 // Point free style.
39 |                 return $pipe;
40 |             };
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Operation/Forget.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | use function in_array;
11 | 
12 | /**
13 |  * @immutable
14 |  *
15 |  * @template TKey
16 |  * @template T
17 |  */
18 | final class Forget extends AbstractOperation
19 | {
20 |     /**
21 |      * @return Closure(array<TKey>): Closure(iterable<TKey, T>): Generator<TKey, T>
22 |      */
23 |     public function __invoke(): Closure
24 |     {
25 |         return
26 |             /**
27 |              * @param array<TKey> $keys
28 |              *
29 |              * @return Closure(iterable<TKey, T>): Generator<TKey, T>
30 |              */
31 |             static fn (array $keys): Closure => (new Filter())()(
32 |                 /**
33 |                  * @param T $value
34 |                  * @param TKey $key
35 |                  */
36 |                 static fn (mixed $value, mixed $key): bool => !in_array($key, $keys, true)
37 |             );
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Operation/Frequency.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Frequency extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(iterable<TKey, T>): Generator<int, T>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         $reduceCallback =
24 |             /**
25 |              * @param array<int, array{0: int, 1: T}> $storage
26 |              * @param T $value
27 |              *
28 |              * @return array<int, array{0: int, 1: T}>
29 |              */
30 |             static function (array $storage, $value): array {
31 |                 $added = false;
32 | 
33 |                 foreach ($storage as $key => $data) {
34 |                     if ($data[1] !== $value) {
35 |                         continue;
36 |                     }
37 | 
38 |                     ++$storage[$key][0];
39 |                     $added = true;
40 | 
41 |                     break;
42 |                 }
43 | 
44 |                 if (true !== $added) {
45 |                     $storage[] = [1, $value];
46 |                 }
47 | 
48 |                 return $storage;
49 |             };
50 | 
51 |         /** @var Closure(iterable<TKey, T>): Generator<int, T> $pipe */
52 |         $pipe = (new Pipe())()(
53 |             (new Reduce())()($reduceCallback)([]),
54 |             (new Flatten())()(1),
55 |             (new Unpack())()
56 |         );
57 | 
58 |         // Point free style.
59 |         return $pipe;
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/src/Operation/Group.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Group extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(iterable<TKey, T>): Generator<int, list<T>>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         return
24 |             /**
25 |              * @param iterable<TKey, T> $iterable
26 |              *
27 |              * @return Generator<int, list<T>>
28 |              */
29 |             static function (iterable $iterable): Generator {
30 |                 $last = [];
31 | 
32 |                 foreach ($iterable as $current) {
33 |                     if ([] === $last) {
34 |                         $last = [$current];
35 | 
36 |                         continue;
37 |                     }
38 | 
39 |                     if (current($last) === $current) {
40 |                         $last[] = $current;
41 | 
42 |                         continue;
43 |                     }
44 | 
45 |                     yield $last;
46 | 
47 |                     $last = [$current];
48 |                 }
49 | 
50 |                 if ([] !== $last) {
51 |                     yield $last;
52 |                 }
53 |             };
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/Operation/Has.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Has extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(callable(T, TKey, iterable<TKey, T>): T ...): Closure(iterable<TKey, T>): Generator<TKey, bool>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         return
24 |             /**
25 |              * @param callable(T, TKey, iterable<TKey, T>): T ...$callbacks
26 |              *
27 |              * @return Closure(iterable<TKey, T>): Generator<TKey, bool>
28 |              */
29 |             static fn (callable ...$callbacks): Closure => (new MatchOne())()(static fn (): bool => true)(
30 |                 ...array_map(
31 |                     static fn (callable $callback): callable =>
32 |                             /**
33 |                              * @param T $value
34 |                              * @param TKey $key
35 |                              * @param iterable<TKey, T> $iterable
36 |                              */
37 |                             static fn (mixed $value, mixed $key, iterable $iterable): bool => $callback($value, $key, $iterable) === $value,
38 |                     $callbacks
39 |                 )
40 |             );
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Operation/Head.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Head extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(iterable<TKey, T>): Generator<TKey, T>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         return (new Limit())()(1)(0);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Operation/Implode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use Stringable;
10 | 
11 | /**
12 |  * @immutable
13 |  *
14 |  * @template TKey
15 |  * @template T
16 |  */
17 | final class Implode extends AbstractOperation
18 | {
19 |     /**
20 |      * @return Closure(string): Closure(iterable<TKey, T>): Generator<TKey, string>
21 |      */
22 |     public function __invoke(): Closure
23 |     {
24 |         return
25 |             /**
26 |              * @return Closure(iterable<TKey, T>): Generator<TKey, string>
27 |              */
28 |             static function (string $glue): Closure {
29 |                 /** @var Closure(iterable<TKey, T>): Generator<TKey, string> $pipe */
30 |                 $pipe = (new Pipe())()(
31 |                     (new Intersperse())()($glue)(1)(0),
32 |                     (new Limit())()(-1)(1),
33 |                     (new Reduce())()(
34 |                         static fn (string $carry, string|Stringable $item): string => $carry .= (string) $item
35 |                     )('')
36 |                 );
37 | 
38 |                 // Point free style.
39 |                 return $pipe;
40 |             };
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Operation/Init.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\iterators\CachingIteratorAggregate;
10 | use loophp\iterators\IterableIteratorAggregate;
11 | 
12 | /**
13 |  * @immutable
14 |  *
15 |  * @template TKey
16 |  * @template T
17 |  */
18 | final class Init extends AbstractOperation
19 | {
20 |     /**
21 |      * @return Closure(iterable<TKey, T>): Generator<TKey, T>
22 |      *
23 |      * @psalm-suppress InvalidArgument
24 |      */
25 |     public function __invoke(): Closure
26 |     {
27 |         $buildCachingIterator =
28 |             /**
29 |              * @return CachingIteratorAggregate<TKey, T>
30 |              */
31 |             static fn (iterable $iterator): CachingIteratorAggregate => new CachingIteratorAggregate((new IterableIteratorAggregate($iterator))->getIterator());
32 | 
33 |         /** @var Closure(iterable<TKey, T>): Generator<TKey, T> $takeWhile */
34 |         $takeWhile = (new Pipe())()(
35 |             $buildCachingIterator,
36 |             (new TakeWhile())()(
37 |                 /**
38 |                  * @param T $value
39 |                  * @param TKey $key
40 |                  * @param CachingIteratorAggregate<TKey, T> $iterator
41 |                  */
42 |                 static fn ($value, $key, CachingIteratorAggregate $iterator): bool => $iterator->hasNext()
43 |             )
44 |         );
45 | 
46 |         // Point free style.
47 |         return $takeWhile;
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/Operation/Inits.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Inits extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(iterable<TKey, T>): Generator<int, list<array{0: TKey, 1: T}>>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         /** @var Closure(iterable<TKey, T>): Generator<int, list<array{0: TKey, 1: T}>> $inits */
24 |         $inits = (new Pipe())()(
25 |             (new Pack())(),
26 |             (new ScanLeft())()(
27 |                 /**
28 |                  * @param list<array{0: TKey, 1: T}> $carry
29 |                  * @param array{0: TKey, 1: T} $value
30 |                  *
31 |                  * @return list<array{0: TKey, 1: T}>
32 |                  */
33 |                 static function (array $carry, array $value): array {
34 |                     $carry[] = $value;
35 | 
36 |                     return $carry;
37 |                 }
38 |             )([]),
39 |             (new Normalize())()
40 |         );
41 | 
42 |         // Point free style.
43 |         return $inits;
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Operation/Intersect.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | use function in_array;
11 | 
12 | /**
13 |  * @immutable
14 |  *
15 |  * @template TKey
16 |  * @template T
17 |  */
18 | final class Intersect extends AbstractOperation
19 | {
20 |     /**
21 |      * @return Closure(array<T>): Closure(iterable<TKey, T>): Generator<TKey, T>
22 |      */
23 |     public function __invoke(): Closure
24 |     {
25 |         return
26 |             /**
27 |              * @param array<T> $values
28 |              *
29 |              * @return Closure(iterable<TKey, T>): Generator<TKey, T>
30 |              */
31 |             static fn (array $values): Closure => (new Filter())()(
32 |                 /**
33 |                  * @param T $value
34 |                  */
35 |                 static fn (mixed $value): bool => in_array($value, $values, true)
36 |             );
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Operation/IntersectKeys.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | use function in_array;
11 | 
12 | /**
13 |  * @immutable
14 |  *
15 |  * @template TKey
16 |  * @template T
17 |  */
18 | final class IntersectKeys extends AbstractOperation
19 | {
20 |     /**
21 |      * @return Closure(array<TKey>): Closure(iterable<TKey, T>): Generator<TKey, T>
22 |      */
23 |     public function __invoke(): Closure
24 |     {
25 |         return
26 |             /**
27 |              * @param array<TKey> $keys
28 |              *
29 |              * @return Closure(iterable<TKey, T>): Generator<TKey, T>
30 |              */
31 |             static fn (array $keys): Closure => (new Filter())()(
32 |                 /**
33 |                  * @param T $value
34 |                  * @param TKey $key
35 |                  */
36 |                 static fn (mixed $value, mixed $key): bool => in_array($key, $keys, true)
37 |             );
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Operation/IsEmpty.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\iterators\IterableIteratorAggregate;
10 | 
11 | /**
12 |  * @immutable
13 |  *
14 |  * @template TKey
15 |  * @template T
16 |  */
17 | final class IsEmpty extends AbstractOperation
18 | {
19 |     /**
20 |      * @return Closure(iterable<TKey, T>): Generator<int, bool>
21 |      */
22 |     public function __invoke(): Closure
23 |     {
24 |         return static fn (iterable $iterable): Generator => yield !(new IterableIteratorAggregate($iterable))->getIterator()->valid();
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Operation/IsNotEmpty.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\iterators\IterableIteratorAggregate;
10 | 
11 | /**
12 |  * @immutable
13 |  *
14 |  * @template TKey
15 |  * @template T
16 |  */
17 | final class IsNotEmpty extends AbstractOperation
18 | {
19 |     /**
20 |      * @return Closure(iterable<TKey, T>): Generator<int, bool>
21 |      */
22 |     public function __invoke(): Closure
23 |     {
24 |         return static fn (iterable $iterable): Generator => yield (new IterableIteratorAggregate($iterable))->getIterator()->valid();
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Operation/Key.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Key extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(int): Closure(iterable<TKey, T>): Generator<int, TKey>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         return
24 |             /**
25 |              * @return Closure(iterable<TKey, T>): Generator<int, TKey>
26 |              */
27 |             static function (int $index): Closure {
28 |                 /** @var Closure(iterable<TKey, T>): Generator<int, TKey> $pipe */
29 |                 $pipe = (new Pipe())()(
30 |                     (new Limit())()(1)($index),
31 |                     (new Flip())()
32 |                 );
33 | 
34 |                 // Point free style.
35 |                 return $pipe;
36 |             };
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Operation/Keys.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Keys extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(iterable<TKey, T>): Generator<int, TKey>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         /** @var Closure(iterable<TKey, T>): Generator<int, TKey> $pipe */
24 |         $pipe = (new Pipe())()(
25 |             (new Flip())(),
26 |             (new Normalize())()
27 |         );
28 | 
29 |         // Point free style.
30 |         return $pipe;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Operation/Last.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Last extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(iterable<TKey, T>): Generator<TKey, T>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         /** @var Closure(iterable<TKey, T>): Generator<TKey, T> $pipe */
24 |         $pipe = (new Pipe())()(
25 |             (new Reverse())(),
26 |             // We could use `Head` here, but I use `Limit` for minor perf boost.
27 |             (new Limit())()(1)(0)
28 |         );
29 | 
30 |         // Point free style.
31 |         return $pipe;
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Operation/Limit.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\iterators\LimitIterableAggregate;
10 | 
11 | /**
12 |  * @immutable
13 |  *
14 |  * @template TKey
15 |  * @template T
16 |  */
17 | final class Limit extends AbstractOperation
18 | {
19 |     /**
20 |      * @return Closure(int): Closure(int): Closure(iterable<TKey, T>): Generator<TKey, T>
21 |      */
22 |     public function __invoke(): Closure
23 |     {
24 |         return
25 |             /**
26 |              * @return Closure(int): Closure(iterable<TKey, T>): Generator<TKey, T>
27 |              */
28 |             static fn (int $count = -1): Closure =>
29 |                 /**
30 |                  * @return Closure(iterable<TKey, T>): Generator<TKey, T>
31 |                  */
32 |                 static fn (int $offset = 0): Closure =>
33 |                     /**
34 |                      * @param iterable<TKey, T> $iterable
35 |                      *
36 |                      * @return Generator<TKey, T>
37 |                      */
38 |                     static fn (iterable $iterable): Generator => yield from new LimitIterableAggregate($iterable, $offset, $count);
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Operation/Lines.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | use const PHP_EOL;
11 | 
12 | /**
13 |  * @immutable
14 |  *
15 |  * @template TKey
16 |  * @template T
17 |  */
18 | final class Lines extends AbstractOperation
19 | {
20 |     /**
21 |      * @return Closure(iterable<TKey, T>): Generator<int, string>
22 |      */
23 |     public function __invoke(): Closure
24 |     {
25 |         /** @var Closure(iterable<TKey, T>): Generator<int, string> $pipe */
26 |         $pipe = (new Pipe())()(
27 |             (new Explode())()([PHP_EOL, "\n", "\r\n"]),
28 |             (new Map())()(
29 |                 /**
30 |                  * @param list<T> $value
31 |                  */
32 |                 static fn (array $value): string => implode('', $value)
33 |             )
34 |         );
35 | 
36 |         // Point free style.
37 |         return $pipe;
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Operation/Map.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\iterators\MapIterableAggregate;
10 | 
11 | /**
12 |  * @immutable
13 |  *
14 |  * @template TKey
15 |  * @template T
16 |  */
17 | final class Map extends AbstractOperation
18 | {
19 |     /**
20 |      * @template V
21 |      *
22 |      * @return Closure(callable(T, TKey, iterable<TKey, T>): mixed): Closure(iterable<TKey, T>): Generator<TKey, mixed>
23 |      */
24 |     public function __invoke(): Closure
25 |     {
26 |         return
27 |             /**
28 |              * @param callable(T, TKey, iterable<TKey, T>): V $callback
29 |              */
30 |             static fn (callable $callback): Closure =>
31 |                 /**
32 |                  * @param iterable<TKey, T> $iterable
33 |                  *
34 |                  * @return Generator<TKey, V>
35 |                  */
36 |                 static fn (iterable $iterable): Generator => yield from new MapIterableAggregate($iterable, Closure::fromCallable($callback));
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Operation/Max.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Max extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(iterable<TKey, T>): Generator<TKey, T>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         $comparator =
24 |             /**
25 |              * @param T $carry
26 |              * @param T $value
27 |              *
28 |              * @return T
29 |              */
30 |             static fn (mixed $carry, mixed $value): mixed => max($value, $carry);
31 | 
32 |         return (new Compare())()($comparator);
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Operation/Merge.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\iterators\ConcatIterableAggregate;
10 | 
11 | /**
12 |  * @immutable
13 |  *
14 |  * @template TKey
15 |  * @template T
16 |  */
17 | final class Merge extends AbstractOperation
18 | {
19 |     /**
20 |      * @return Closure(iterable<TKey, T> ...$sources): Closure(iterable<TKey, T>): Generator<TKey, T>
21 |      */
22 |     public function __invoke(): Closure
23 |     {
24 |         return
25 |             /**
26 |              * @param iterable<TKey, T> ...$sources
27 |              */
28 |             static fn (iterable ...$sources): Closure =>
29 |                 /**
30 |                  * @param iterable<TKey, T> $iterable
31 |                  *
32 |                  * @return Generator<TKey, T>
33 |                  */
34 |                 static fn (iterable $iterable): Generator => yield from new ConcatIterableAggregate([$iterable, ...array_values($sources)]);
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Operation/Min.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Min extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(iterable<TKey, T>): Generator<TKey, T>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         $comparator =
24 |             /**
25 |              * @param T $carry
26 |              * @param T $value
27 |              *
28 |              * @return T
29 |              */
30 |             static fn (mixed $carry, mixed $value): mixed => min($value, $carry);
31 | 
32 |         return (new Compare())()($comparator);
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Operation/Normalize.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\iterators\NormalizeIterableAggregate;
10 | 
11 | /**
12 |  * @immutable
13 |  *
14 |  * @template TKey
15 |  * @template T
16 |  */
17 | final class Normalize extends AbstractOperation
18 | {
19 |     /**
20 |      * @return Closure(iterable<TKey, T>): Generator<int, T>
21 |      */
22 |     public function __invoke(): Closure
23 |     {
24 |         return
25 |             /**
26 |              * @param iterable<TKey, T> $iterable
27 |              *
28 |              * @return Generator<int, T>
29 |              */
30 |             static fn (iterable $iterable): Generator => yield from new NormalizeIterableAggregate($iterable);
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Operation/Nth.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Nth extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(int): Closure(int): Closure(iterable<TKey, T>): Generator<TKey, T>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         return
24 |             /**
25 |              * @return Closure(int): Closure(iterable<TKey, T>): Generator<TKey, T>
26 |              */
27 |             static fn (int $step): Closure =>
28 |                 /**
29 |                  * @return Closure(iterable<TKey, T>): Generator<TKey, T>
30 |                  */
31 |                 static function (int $offset) use ($step): Closure {
32 |                     /** @var Closure(iterable<TKey, T>): Generator<TKey, T> $pipe */
33 |                     $pipe = (new Pipe())()(
34 |                         (new Pack())(),
35 |                         (new Filter())()(
36 |                             /**
37 |                              * @param array{0: TKey, 1: T} $value
38 |                              */
39 |                             static fn (array $value, int $key): bool => (($key % $step) === $offset)
40 |                         ),
41 |                         (new Unpack())()
42 |                     );
43 | 
44 |                     // Point free style.
45 |                     return $pipe;
46 |                 };
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/Operation/Nullsy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | use function in_array;
11 | 
12 | /**
13 |  * @immutable
14 |  *
15 |  * @template TKey
16 |  * @template T
17 |  */
18 | final class Nullsy extends AbstractOperation
19 | {
20 |     /**
21 |      * @var array{0: null, 1: array<mixed>, 2: int, 3: bool, 4: string}
22 |      */
23 |     public const VALUES = [null, [], 0, false, ''];
24 | 
25 |     /**
26 |      * @return Closure(iterable<TKey, T>): Generator<int, bool>
27 |      */
28 |     public function __invoke(): Closure
29 |     {
30 |         return (new Every())()(
31 |             /**
32 |              * @param T $value
33 |              */
34 |             static fn (int $index, mixed $value): bool => in_array((bool) $value, self::VALUES, true)
35 |         );
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Operation/Pack.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\iterators\PackIterableAggregate;
10 | 
11 | /**
12 |  * @immutable
13 |  *
14 |  * @template TKey
15 |  * @template T
16 |  */
17 | final class Pack extends AbstractOperation
18 | {
19 |     /**
20 |      * @return Closure(iterable<TKey, T>): Generator<int, array{0: TKey, 1: T}>
21 |      */
22 |     public function __invoke(): Closure
23 |     {
24 |         return
25 |             /**
26 |              * @param iterable<TKey, T> $iterable
27 |              *
28 |              * @return Generator<int, array{0: TKey, 1: T}>
29 |              */
30 |             static fn (iterable $iterable): Generator => yield from new PackIterableAggregate($iterable);
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Operation/Pad.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Pad extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(int): Closure(T): Closure(iterable<TKey, T>): Generator<int|TKey, T>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         return
24 |             /**
25 |              * @return Closure(T): Closure(iterable<TKey, T>): Generator<int|TKey, T>
26 |              */
27 |             static fn (int $size): Closure =>
28 |                 /**
29 |                  * @param T $padValue
30 |                  *
31 |                  * @return Closure(iterable<TKey, T>): Generator<int|TKey, T>
32 |                  */
33 |                 static fn (mixed $padValue): Closure =>
34 |                     /**
35 |                      * @param iterable<TKey, T> $iterable
36 |                      *
37 |                      * @return Generator<int|TKey, T>
38 |                      */
39 |                     static function (iterable $iterable) use ($size, $padValue): Generator {
40 |                         $y = 0;
41 | 
42 |                         foreach ($iterable as $key => $value) {
43 |                             ++$y;
44 | 
45 |                             yield $key => $value;
46 |                         }
47 | 
48 |                         while ($y++ < $size) {
49 |                             yield $padValue;
50 |                         }
51 |                     };
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/src/Operation/Pair.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Pair extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(iterable<TKey, T>): Generator<T, T|null>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         /** @var Closure(iterable<TKey, T>): Generator<T, T|null> $pipe */
24 |         $pipe = (new Pipe())()(
25 |             (new Normalize())(),
26 |             (new Chunk())()(2),
27 |             (new Associate())()(
28 |                 /**
29 |                  * @param TKey $key
30 |                  * @param array{0: TKey, 1: T} $value
31 |                  *
32 |                  * @return TKey|null
33 |                  */
34 |                 static fn (mixed $key, array $value): mixed => $value[0] ?? null
35 |             )(
36 |                 /**
37 |                  * @param array{0: TKey, 1: T} $value
38 |                  *
39 |                  * @return T|null
40 |                  */
41 |                 static fn (array $value): mixed => $value[1] ?? null
42 |             )
43 |         );
44 | 
45 |         // Point free style.
46 |         return $pipe;
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/Operation/Partition.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\iterators\CachingIteratorAggregate;
10 | use loophp\iterators\ClosureIteratorAggregate;
11 | use loophp\iterators\IterableIteratorAggregate;
12 | 
13 | /**
14 |  * @immutable
15 |  *
16 |  * @template TKey
17 |  * @template T
18 |  */
19 | final class Partition extends AbstractOperation
20 | {
21 |     /**
22 |      * @return Closure(callable(T, TKey, iterable<TKey, T>): bool ...): Closure(iterable<TKey, T>): Generator<int, iterable<TKey, T>>
23 |      */
24 |     public function __invoke(): Closure
25 |     {
26 |         /**
27 |          * @param callable(T, TKey, iterable<TKey, T>): bool ...$callbacks
28 |          *
29 |          * @return Closure(iterable<TKey, T>): Generator<int, iterable<TKey, T>>
30 |          */
31 |         return static fn (callable ...$callbacks): Closure =>
32 |             /**
33 |              * @param iterable<TKey, T> $iterable
34 |              *
35 |              * @return Generator<int, iterable<TKey, T>>
36 |              */
37 |             static function (iterable $iterable) use ($callbacks): Generator {
38 |                 $iteratorAggregate = (new CachingIteratorAggregate((new IterableIteratorAggregate($iterable))->getIterator()));
39 | 
40 |                 yield new ClosureIteratorAggregate((new Filter())()(...$callbacks), [$iteratorAggregate]);
41 | 
42 |                 yield new ClosureIteratorAggregate((new Reject())()(...$callbacks), [$iteratorAggregate]);
43 |             };
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Operation/Pipe.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | 
 9 | /**
10 |  * @immutable
11 |  *
12 |  * @template TKey
13 |  * @template T
14 |  */
15 | final class Pipe extends AbstractOperation
16 | {
17 |     /**
18 |      * @return Closure(callable(iterable<TKey, T>): iterable<TKey, T> ...): Closure(iterable<TKey, T>): iterable<TKey, T>
19 |      */
20 |     public function __invoke(): Closure
21 |     {
22 |         return
23 |             /**
24 |              * @param callable(iterable<TKey, T>): iterable<TKey, T> ...$operations
25 |              *
26 |              * @return Closure(iterable<TKey, T>): iterable<TKey, T>
27 |              */
28 |             static fn (callable ...$operations): Closure => array_reduce(
29 |                 $operations,
30 |                 /**
31 |                  * @param callable(iterable<TKey, T>): iterable<TKey, T> $f
32 |                  * @param callable(iterable<TKey, T>): iterable<TKey, T> $g
33 |                  *
34 |                  * @return Closure(iterable<TKey, T>): iterable<TKey, T>
35 |                  */
36 |                 static fn (callable $f, callable $g): Closure =>
37 |                     /**
38 |                      * @param iterable<TKey, T> $iterable
39 |                      *
40 |                      * @return iterable<TKey, T>
41 |                      */
42 |                     static fn (iterable $iterable): iterable => $g($f($iterable)),
43 |                 static fn (iterable $iterable): iterable => $iterable
44 |             );
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Operation/Prepend.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\iterators\ConcatIterableAggregate;
10 | 
11 | /**
12 |  * @immutable
13 |  *
14 |  * @template TKey
15 |  * @template T
16 |  */
17 | final class Prepend extends AbstractOperation
18 | {
19 |     /**
20 |      * @template U
21 |      *
22 |      * @return Closure(array<U>): Closure(iterable<TKey, T>): iterable<int|TKey, T|U>
23 |      */
24 |     public function __invoke(): Closure
25 |     {
26 |         return
27 |             /**
28 |              * @param array<U> $items
29 |              *
30 |              * @return Closure(iterable<TKey, T>): iterable<int|TKey, T|U>
31 |              */
32 |             static fn (array $items): Closure =>
33 |                 /**
34 |                  * @param iterable<TKey, T> $iterable
35 |                  *
36 |                  * @return Generator<int|TKey, T|U>
37 |                  */
38 |                 static fn (iterable $iterable): Generator => yield from new ConcatIterableAggregate([$items, $iterable]);
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Operation/RSample.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class RSample extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(float): Closure(iterable<TKey, T>): Generator<TKey, T>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         return
24 |             /**
25 |              * @return Closure(iterable<TKey, T>): Generator<TKey, T>
26 |              */
27 |             static function (float $probability): Closure {
28 |                 $filter = (new Filter())()(
29 |                     static fn (): bool => (random_int(0, mt_getrandmax()) / mt_getrandmax()) < $probability
30 |                 );
31 | 
32 |                 // Point free style.
33 |                 return $filter;
34 |             };
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Operation/Random.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\iterators\LimitIterableAggregate;
10 | use loophp\iterators\RandomIterableAggregate;
11 | 
12 | /**
13 |  * @immutable
14 |  *
15 |  * @template TKey
16 |  * @template T
17 |  */
18 | final class Random extends AbstractOperation
19 | {
20 |     /**
21 |      * @return Closure(int): Closure(int): Closure(iterable<TKey, T>): Generator<TKey, T>
22 |      */
23 |     public function __invoke(): Closure
24 |     {
25 |         return
26 |             /**
27 |              * @return Closure(int): Closure(iterable<TKey, T>): Generator<TKey, T>
28 |              */
29 |             static fn (int $seed): Closure =>
30 |                 /**
31 |                  * @return Closure(iterable<TKey, T>): Generator<TKey, T>
32 |                  */
33 |                 static fn (int $size): Closure =>
34 |                     /**
35 |                      * @param iterable<TKey, T> $iterable
36 |                      *
37 |                      * @return Generator<TKey, T>
38 |                      */
39 |                     static function (iterable $iterable) use ($seed, $size): Generator {
40 |                         // Point free style.
41 |                         yield from new LimitIterableAggregate(new RandomIterableAggregate($iterable, $seed), 0, $size);
42 |                     };
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/Operation/Range.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | use const INF;
11 | 
12 | /**
13 |  * @immutable
14 |  *
15 |  * @template TKey
16 |  * @template T
17 |  */
18 | final class Range extends AbstractOperation
19 | {
20 |     /**
21 |      * @return Closure(int|float=): Closure(int|float=): Closure(int|float=): Closure(): Generator<int, int|float>
22 |      */
23 |     public function __invoke(): Closure
24 |     {
25 |         return
26 |             /**
27 |              * @return Closure(int|float=): Closure(int|float=): Closure(): Generator<int, int|float>
28 |              */
29 |             static fn (float|int $start = 0.0): Closure =>
30 |                 /**
31 |                  * @return Closure(int|float=): Closure(): Generator<int, int|float>
32 |                  */
33 |                 static fn (float|int $end = INF): Closure =>
34 |                     /**
35 |                      * @return Closure(): Generator<int, int|float>
36 |                      */
37 |                     static fn (float|int $step = 1.0): Closure =>
38 |                         /**
39 |                          * @return Generator<int, int|float>
40 |                          */
41 |                         static function () use ($start, $end, $step): Generator {
42 |                             for ($current = $start; $current < $end; $current += $step) {
43 |                                 yield (($intCurrent = (int) $current) === $current) ? $intCurrent : $current;
44 |                             }
45 |                         };
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Operation/Reduce.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\iterators\ReduceIterableAggregate;
10 | 
11 | /**
12 |  * @immutable
13 |  *
14 |  * @template TKey
15 |  * @template T
16 |  */
17 | final class Reduce extends AbstractOperation
18 | {
19 |     /**
20 |      * @template V
21 |      *
22 |      * @return Closure(callable(mixed, mixed, mixed, iterable<mixed, mixed>): mixed): Closure(mixed): Closure(iterable<TKey, T>): Generator<int, mixed>
23 |      */
24 |     public function __invoke(): Closure
25 |     {
26 |         return
27 |             /**
28 |              * @param callable(V, T, TKey, iterable<TKey, T>): V $callback
29 |              *
30 |              * @return Closure(V): Closure(iterable<TKey, T>): Generator<int, V>
31 |              */
32 |             static fn (callable $callback): Closure =>
33 |                 /**
34 |                  * @param V $initial
35 |                  *
36 |                  * @return Closure(iterable<TKey, T>): Generator<int, V>
37 |                  */
38 |                 static fn (mixed $initial): Closure =>
39 |                     /**
40 |                      * @param iterable<TKey, T> $iterable
41 |                      *
42 |                      * @return Generator<int, V>
43 |                      */
44 |                     static fn (iterable $iterable): Generator => yield from new ReduceIterableAggregate($iterable, Closure::fromCallable($callback), $initial);
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Operation/Reduction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\iterators\ReductionIterableAggregate;
10 | 
11 | /**
12 |  * @immutable
13 |  *
14 |  * @template TKey
15 |  * @template T
16 |  */
17 | final class Reduction extends AbstractOperation
18 | {
19 |     /**
20 |      * @template V
21 |      *
22 |      * @return Closure(callable(mixed, mixed, mixed, iterable<mixed, mixed>): mixed): Closure(mixed): Closure(iterable<TKey, T>): Generator<TKey|int, mixed>
23 |      */
24 |     public function __invoke(): Closure
25 |     {
26 |         return
27 |             /**
28 |              * @param callable(V, T, TKey, iterable<TKey, T>): V $callback
29 |              *
30 |              * @return Closure(V): Closure(iterable<TKey, T>): Generator<TKey|int, V>
31 |              */
32 |             static fn (callable $callback): Closure =>
33 |                 /**
34 |                  * @param V $initial
35 |                  *
36 |                  * @return Closure(iterable<TKey, T>): Generator<TKey|int, V>
37 |                  */
38 |                 static fn (mixed $initial): Closure =>
39 |                     /**
40 |                      * @param iterable<TKey, T> $iterable
41 |                      *
42 |                      * @return Generator<TKey|int, V>
43 |                      */
44 |                     static fn (iterable $iterable): Generator => yield from new ReductionIterableAggregate($iterable, Closure::fromCallable($callback), $initial);
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Operation/Reverse.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Reverse extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(iterable<TKey, T>): Generator<TKey, T>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         $callback =
24 |             /**
25 |              * @param T $value
26 |              * @param TKey $key
27 |              * @param list<array{0: TKey, 1: T}> $carry
28 |              *
29 |              * @return list<array{0: TKey, 1: T}>
30 |              */
31 |             static fn (array $carry, mixed $value, mixed $key): array => [[$key, $value], ...$carry];
32 | 
33 |         /** @var Closure(iterable<TKey, T>): Generator<TKey, T> $pipe */
34 |         $pipe = (new Pipe())()(
35 |             (new Reduce())()($callback)([]),
36 |             (new Unwrap())(),
37 |             (new Unpack())()
38 |         );
39 | 
40 |         // Point free style.
41 |         return $pipe;
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Operation/ScanLeft.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\iterators\ReductionIterableAggregate;
10 | 
11 | /**
12 |  * @immutable
13 |  *
14 |  * @template TKey
15 |  * @template T
16 |  */
17 | final class ScanLeft extends AbstractOperation
18 | {
19 |     /**
20 |      * @template V
21 |      *
22 |      * @return Closure(callable(mixed, mixed, mixed, iterable<mixed, mixed>): mixed): Closure(mixed): Closure(iterable<TKey, T>): Generator<TKey|int, mixed>
23 |      */
24 |     public function __invoke(): Closure
25 |     {
26 |         return
27 |             /**
28 |              * @param callable(V, T, TKey, iterable<TKey, T>): V $callback
29 |              *
30 |              * @return Closure(V): Closure(iterable<TKey, T>): Generator<TKey|int, V>
31 |              */
32 |             static fn (callable $callback): Closure =>
33 |                 /**
34 |                  * @param V $initial
35 |                  *
36 |                  * @return Closure(iterable<TKey, T>): Generator<TKey|int, V>
37 |                  */
38 |                 static fn (mixed $initial): Closure =>
39 |                     /**
40 |                      * @param iterable<TKey, T> $iterable
41 |                      *
42 |                      * @return Generator<TKey|int, V>
43 |                      */
44 |                     static fn (iterable $iterable): Generator => yield from new ReductionIterableAggregate($iterable, Closure::fromCallable($callback), $initial);
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Operation/ScanRight.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class ScanRight extends AbstractOperation
17 | {
18 |     /**
19 |      * @template V
20 |      *
21 |      * @return Closure(callable(mixed, mixed, mixed, iterable<mixed, mixed>): mixed): Closure(mixed): Closure(iterable<TKey, T>): Generator<TKey|int, mixed>
22 |      */
23 |     public function __invoke(): Closure
24 |     {
25 |         return
26 |             /**
27 |              * @param callable(V, T, TKey, iterable<TKey, T>): V $callback
28 |              *
29 |              * @return Closure(V): Closure(iterable<TKey, T>): Generator<TKey|int, V>
30 |              */
31 |             static fn (callable $callback): Closure =>
32 |                 /**
33 |                  * @param V $initial
34 |                  *
35 |                  * @return Closure(iterable<TKey, T>): Generator<TKey|int, V>
36 |                  */
37 |                 static function (mixed $initial) use ($callback): Closure {
38 |                     /** @var Closure(iterable<TKey, T>): Generator<TKey|int, V> $pipe */
39 |                     $pipe = (new Pipe())()(
40 |                         (new Reverse())(),
41 |                         (new ScanLeft())()($callback)($initial),
42 |                         (new Reverse())()
43 |                     );
44 | 
45 |                     // Point free style.
46 |                     return $pipe;
47 |                 };
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/Operation/ScanRight1.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class ScanRight1 extends AbstractOperation
17 | {
18 |     /**
19 |      * @template V
20 |      *
21 |      * @return Closure(callable((T|V), T, TKey, iterable<TKey, T>): (T|V)): Closure(iterable<TKey, T>): Generator<TKey|int, T|V>
22 |      */
23 |     public function __invoke(): Closure
24 |     {
25 |         return
26 |             /**
27 |              * @param callable((T|V), T, TKey, iterable<TKey, T>): (T|V) $callback
28 |              *
29 |              * @return Closure(iterable<TKey, T>): Generator<TKey|int, T|V>
30 |              */
31 |             static function (callable $callback): Closure {
32 |                 /** @var Closure(iterable<TKey, T>): Generator<TKey|int, T|V> $pipe */
33 |                 $pipe = (new Pipe())()(
34 |                     (new Reverse())(),
35 |                     (new ScanLeft1())()($callback),
36 |                     (new Reverse())()
37 |                 );
38 | 
39 |                 // Point free style.
40 |                 return $pipe;
41 |             };
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Operation/Shuffle.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\iterators\RandomIterableAggregate;
10 | 
11 | /**
12 |  * @immutable
13 |  *
14 |  * @template TKey
15 |  * @template T
16 |  */
17 | final class Shuffle extends AbstractOperation
18 | {
19 |     /**
20 |      * @return Closure(int): Closure(iterable<TKey, T>): Generator<TKey, T>
21 |      */
22 |     public function __invoke(): Closure
23 |     {
24 |         return
25 |             /**
26 |              * @return Closure(iterable<TKey, T>): Generator<TKey, T>
27 |              */
28 |             static fn (int $seed): Closure =>
29 |                 /**
30 |                  * @param iterable<TKey, T> $iterable
31 |                  *
32 |                  * @return Generator<TKey, T>
33 |                  */
34 |                 static fn (iterable $iterable): Generator => yield from new RandomIterableAggregate($iterable, $seed);
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Operation/Slice.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Slice extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(int): Closure(int=): Closure(iterable<TKey, T>): Generator<TKey, T>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         return
24 |             /**
25 |              * @return Closure(int=): Closure(iterable<TKey, T>): Generator<TKey, T>
26 |              */
27 |             static fn (int $offset): Closure =>
28 |                 /**
29 |                  * @return Closure(iterable<TKey, T>): Generator<TKey, T>
30 |                  */
31 |                 static function (int $length = -1) use ($offset): Closure {
32 |                     /** @var Closure(iterable<TKey, T>): Generator<TKey, T> $skip */
33 |                     $skip = (new Limit())()(-1)($offset);
34 | 
35 |                     if (-1 === $length) {
36 |                         return $skip;
37 |                     }
38 | 
39 |                     /** @var Closure(iterable<TKey, T>): Generator<TKey, T> $pipe */
40 |                     $pipe = (new Pipe())()(
41 |                         $skip,
42 |                         (new Limit())()($length)(0)
43 |                     );
44 | 
45 |                     // Point free style.
46 |                     return $pipe;
47 |                 };
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/Operation/Span.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\iterators\CachingIteratorAggregate;
10 | use loophp\iterators\ClosureIteratorAggregate;
11 | use loophp\iterators\IterableIteratorAggregate;
12 | 
13 | /**
14 |  * @immutable
15 |  *
16 |  * @template TKey
17 |  * @template T
18 |  */
19 | final class Span extends AbstractOperation
20 | {
21 |     /**
22 |      * @return Closure(callable(T, TKey, iterable<TKey, T>): bool ...): Closure(iterable<TKey, T>): Generator<int, iterable<TKey, T>>
23 |      */
24 |     public function __invoke(): Closure
25 |     {
26 |         /**
27 |          * @param callable(T, TKey, iterable<TKey, T>): bool ...$callbacks
28 |          *
29 |          * @return Closure(iterable<TKey, T>): Generator<int, iterable<TKey, T>>
30 |          */
31 |         return static fn (callable ...$callbacks): Closure =>
32 |             /**
33 |              * @param iterable<TKey, T> $iterable
34 |              *
35 |              * @return Generator<int, iterable<TKey, T>>
36 |              */
37 |             static function (iterable $iterable) use ($callbacks): Generator {
38 |                 $iteratorAggregate = new CachingIteratorAggregate((new IterableIteratorAggregate($iterable))->getIterator());
39 | 
40 |                 yield new ClosureIteratorAggregate((new TakeWhile())()(...$callbacks), [$iteratorAggregate]);
41 | 
42 |                 yield new ClosureIteratorAggregate((new DropWhile())()(...$callbacks), [$iteratorAggregate]);
43 |             };
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Operation/Strict.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\iterators\IterableIteratorAggregate;
10 | use loophp\iterators\TypedIterableAggregate;
11 | 
12 | /**
13 |  * @immutable
14 |  *
15 |  * @template TKey
16 |  * @template T
17 |  */
18 | final class Strict extends AbstractOperation
19 | {
20 |     /**
21 |      * @return Closure(null|callable(mixed): string): Closure(iterable<TKey, T>): Generator<TKey, T>
22 |      */
23 |     public function __invoke(): Closure
24 |     {
25 |         return
26 |             /**
27 |              * @param null|callable(mixed): string $callback
28 |              *
29 |              * @return Closure(iterable<TKey, T>): Generator<TKey, T>
30 |              */
31 |             static fn (?callable $callback = null): Closure =>
32 |                 /**
33 |                  * @return Generator<TKey, T>
34 |                  */
35 |                 static fn (iterable $iterator): Generator => yield from new TypedIterableAggregate((new IterableIteratorAggregate($iterator))->getIterator(), $callback);
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Operation/Tail.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Tail extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(iterable<TKey, T>): Generator<TKey, T>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         return (new Limit())()(-1)(1);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Operation/Tails.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\iterators\IterableIteratorAggregate;
10 | 
11 | use function array_slice;
12 | 
13 | /**
14 |  * @immutable
15 |  *
16 |  * @template TKey
17 |  * @template T
18 |  */
19 | final class Tails extends AbstractOperation
20 | {
21 |     /**
22 |      * @return Closure(iterable<TKey, T>): Generator<int, list<T>>
23 |      */
24 |     public function __invoke(): Closure
25 |     {
26 |         return
27 |             /**
28 |              * @param iterable<TKey, T> $iterable
29 |              *
30 |              * @return Generator<int, list<T>>
31 |              */
32 |             static function (iterable $iterable): Generator {
33 |                 $initial = iterator_to_array(
34 |                     (new IterableIteratorAggregate($iterable))->getIterator()
35 |                 );
36 | 
37 |                 $reduction =
38 |                     /**
39 |                      * @param list<T> $stack
40 |                      *
41 |                      * @return list<T>
42 |                      */
43 |                     static fn (array $stack): array => array_slice($stack, 1);
44 | 
45 |                 /** @var Closure(iterable<TKey, T>): Generator<int, list<T>> $pipe */
46 |                 $pipe = (new Pipe())()(
47 |                     (new Reduction())()($reduction)($initial),
48 |                     (new Normalize())(),
49 |                 );
50 | 
51 |                 yield from $pipe($iterable);
52 |             };
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/Operation/TakeWhile.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\collection\Utils\CallbacksArrayReducer;
10 | 
11 | /**
12 |  * @immutable
13 |  *
14 |  * @template TKey
15 |  * @template T
16 |  */
17 | final class TakeWhile extends AbstractOperation
18 | {
19 |     /**
20 |      * @return Closure(callable(T, TKey, iterable<TKey, T>): bool ...): Closure(iterable<TKey, T>): Generator<TKey, T>
21 |      */
22 |     public function __invoke(): Closure
23 |     {
24 |         return
25 |             /**
26 |              * @param callable(T, TKey, iterable<TKey, T>): bool ...$callbacks
27 |              *
28 |              * @return Closure(iterable<TKey, T>): Generator<TKey, T>
29 |              */
30 |             static fn (callable ...$callbacks): Closure =>
31 |                 /**
32 |                  * @param iterable<TKey, T> $iterable
33 |                  *
34 |                  * @return Generator<TKey, T>
35 |                  */
36 |                 static function (iterable $iterable) use ($callbacks): Generator {
37 |                     $callback = CallbacksArrayReducer::or()($callbacks);
38 | 
39 |                     foreach ($iterable as $key => $current) {
40 |                         if (false === $callback($current, $key, $iterable)) {
41 |                             break;
42 |                         }
43 | 
44 |                         yield $key => $current;
45 |                     }
46 |                 };
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/Operation/Tap.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Tap extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(callable(T, TKey, iterable<TKey, T>):void ...): Closure(iterable<TKey, T>): Generator<TKey, T>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         return
24 |             /**
25 |              * @param callable(T, TKey, iterable<TKey, T>): void ...$callbacks
26 |              *
27 |              * @return Closure(iterable<TKey, T>): Generator<TKey, T>
28 |              */
29 |             static fn (callable ...$callbacks): Closure => /**
30 |              * @param iterable<TKey, T> $iterable
31 |              *
32 |              * @return Generator<TKey, T>
33 |              */
34 |             static function (iterable $iterable) use ($callbacks): Generator {
35 |                 foreach ($iterable as $key => $value) {
36 |                     foreach ($callbacks as $callback) {
37 |                         $callback($value, $key, $iterable);
38 |                     }
39 | 
40 |                     yield $key => $value;
41 |                 }
42 |             };
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/Operation/Times.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use Iterator;
10 | 
11 | /**
12 |  * @immutable
13 |  *
14 |  * @template TKey
15 |  * @template T
16 |  */
17 | final class Times extends AbstractOperation
18 | {
19 |     /**
20 |      * @return Closure(int): Closure(null|callable(int): (int|T)): Closure(null|Iterator<TKey, T>): Generator<int, int|T>
21 |      */
22 |     public function __invoke(): Closure
23 |     {
24 |         return
25 |             /**
26 |              * @return Closure(null|callable(int): (int|T)): Closure(): Generator<int, int|T>
27 |              */
28 |             static fn (int $number = 0): Closure =>
29 |                 /**
30 |                  * @return Closure(): Generator<int, int|T>
31 |                  */
32 |                 static fn (?callable $callback = null): Closure =>
33 |                     /**
34 |                      * @return Generator<int, int|T>
35 |                      */
36 |                     static function () use ($number, $callback): Generator {
37 |                         if (1 > $number) {
38 |                             return;
39 |                         }
40 | 
41 |                         $callback ??= static fn (int $value): int => $value;
42 | 
43 |                         for ($current = 1; $current <= $number; ++$current) {
44 |                             yield $callback($current);
45 |                         }
46 |                     };
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/Operation/Transpose.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\iterators\MultipleIterableAggregate;
10 | use MultipleIterator;
11 | 
12 | /**
13 |  * @immutable
14 |  *
15 |  * @template TKey
16 |  * @template T
17 |  */
18 | final class Transpose extends AbstractOperation
19 | {
20 |     /**
21 |      * @return Closure(iterable<TKey, T>): Generator<TKey, list<T>>
22 |      */
23 |     public function __invoke(): Closure
24 |     {
25 |         $callbackForKeys =
26 |             /**
27 |              * @param non-empty-array<int, TKey> $key
28 |              *
29 |              * @return TKey
30 |              */
31 |             static fn (array $key): mixed => reset($key);
32 | 
33 |         $callbackForValues =
34 |             /**
35 |              * @param array<int, T> $value
36 |              *
37 |              * @return array<int, T>
38 |              */
39 |             static fn (array $value): array => $value;
40 | 
41 |         /** @var Closure(iterable<TKey, T>): Generator<TKey, list<T>> $pipe */
42 |         $pipe = (new Pipe())()(
43 |             static fn (iterable $iterables): MultipleIterableAggregate => new MultipleIterableAggregate($iterables, MultipleIterator::MIT_NEED_ANY),
44 |             (new Associate())()($callbackForKeys)($callbackForValues)
45 |         );
46 | 
47 |         // Point free style.
48 |         return $pipe;
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/src/Operation/Truthy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Truthy extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(iterable<TKey, T>): Generator<int, bool>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         return (new Every())()(
24 |             /**
25 |              * @param T $value
26 |              */
27 |             static fn (int $index, mixed $value): bool => (bool) $value
28 |         );
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Operation/Unfold.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  */
13 | final class Unfold extends AbstractOperation
14 | {
15 |     /**
16 |      * @template TKey
17 |      * @template T
18 |      *
19 |      * @return Closure(iterable<TKey, T>): Closure(callable(T...): iterable<array-key, T>): Closure(): Generator<int, iterable<array-key, T>>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         return
24 |             /**
25 |              * @param iterable<array-key, T> $parameters
26 |              *
27 |              * @return Closure(callable(T...): iterable<array-key, T>): Closure(): Generator<int, iterable<array-key, T>>
28 |              */
29 |             static fn (iterable $parameters): Closure =>
30 |                 /**
31 |                  * @param callable(T...): iterable<array-key, T> $callback
32 |                  *
33 |                  * @return Closure(): Generator<int, iterable<array-key, T>>
34 |                  */
35 |                 static fn (callable $callback): Closure =>
36 |                     /**
37 |                      * @return Generator<int, iterable<array-key, T>>
38 |                      */
39 |                     static function () use ($parameters, $callback): Generator {
40 |                         while (true) {
41 |                             $parameters = $callback(...$parameters);
42 | 
43 |                             yield $parameters;
44 |                         }
45 |                     };
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Operation/Unlines.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | use const PHP_EOL;
11 | 
12 | /**
13 |  * @immutable
14 |  *
15 |  * @template TKey
16 |  * @template T
17 |  */
18 | final class Unlines extends AbstractOperation
19 | {
20 |     /**
21 |      * @return Closure(iterable<TKey, (T|string)>): Generator<TKey, string>
22 |      */
23 |     public function __invoke(): Closure
24 |     {
25 |         return (new Implode())()(PHP_EOL);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Operation/Unpack.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\iterators\UnpackIterableAggregate;
10 | 
11 | /**
12 |  * @immutable
13 |  *
14 |  * @template TKey
15 |  * @template T
16 |  */
17 | final class Unpack extends AbstractOperation
18 | {
19 |     /**
20 |      * @return Closure(iterable<mixed, array{0: TKey, 1: T}>): Generator<TKey, T>
21 |      */
22 |     public function __invoke(): Closure
23 |     {
24 |         return
25 |            /**
26 |             * @param iterable<mixed, array{0: TKey, 1: T}> $iterable
27 |             */
28 |            static fn (iterable $iterable): Generator => yield from new UnpackIterableAggregate($iterable);
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Operation/Unpair.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Unpair extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(iterable<TKey, T>): Generator<int, (TKey|T), mixed, void>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         return
24 |             /**
25 |              * @param iterable<TKey, T> $iterable
26 |              *
27 |              * @return Generator<int, (TKey|T), mixed, void>
28 |              */
29 |             static function (iterable $iterable): Generator {
30 |                 foreach ($iterable as $key => $value) {
31 |                     yield $key;
32 | 
33 |                     yield $value;
34 |                 }
35 |             };
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Operation/Until.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\collection\Utils\CallbacksArrayReducer;
10 | 
11 | /**
12 |  * @immutable
13 |  *
14 |  * @template TKey
15 |  * @template T
16 |  */
17 | final class Until extends AbstractOperation
18 | {
19 |     /**
20 |      * @return Closure(callable(T, TKey, iterable<TKey, T>): bool ...): Closure(iterable<TKey, T>): Generator<TKey, T>
21 |      */
22 |     public function __invoke(): Closure
23 |     {
24 |         return
25 |             /**
26 |              * @param callable(T, TKey, iterable<TKey, T>): bool ...$callbacks
27 |              *
28 |              * @return Closure(iterable<TKey, T>): Generator<TKey, T>
29 |              */
30 |             static fn (callable ...$callbacks): Closure =>
31 |                 /**
32 |                  * @param iterable<TKey, T> $iterable
33 |                  *
34 |                  * @return Generator<TKey, T>
35 |                  */
36 |                 static function (iterable $iterable) use ($callbacks): Generator {
37 |                     $callback = CallbacksArrayReducer::or()($callbacks);
38 | 
39 |                     foreach ($iterable as $key => $current) {
40 |                         yield $key => $current;
41 | 
42 |                         if ($callback($current, $key, $iterable)) {
43 |                             break;
44 |                         }
45 |                     }
46 |                 };
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/Operation/Unwindow.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Unwindow extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(iterable<TKey, list<T>>): Generator<TKey, T|null>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         /** @var Closure(iterable<TKey, list<T>>): Generator<TKey, T|null> $pipe */
24 |         $pipe = (new Pipe())()(
25 |             (new Map())()(
26 |                 /**
27 |                  * @param list<T> $iterable
28 |                  *
29 |                  * @return Generator<TKey, T>
30 |                  */
31 |                 static fn (iterable $iterable): Generator => (new Last())()($iterable)
32 |             ),
33 |             (new Map())()(
34 |                 /**
35 |                  * @param Generator<TKey, T> $iterable
36 |                  *
37 |                  * @return T|null
38 |                  */
39 |                 static fn (Generator $iterable): mixed => $iterable->current()
40 |             ),
41 |         );
42 | 
43 |         // Point free style.
44 |         return $pipe;
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Operation/Unwords.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Unwords extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(iterable<TKey, (T|string)>): Generator<TKey, string>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         return (new Implode())()(' ');
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Operation/Unwrap.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Unwrap extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(iterable<TKey, T>): Generator<mixed, mixed>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         /** @var Closure(iterable<TKey, T>): Generator<mixed, mixed> $flatten */
24 |         $flatten = (new Flatten())()(1);
25 | 
26 |         // Point free style.
27 |         return $flatten;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Operation/Unzip.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Unzip extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(iterable<TKey, list<T>>): Generator<int, list<T>>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         $reduceCallback =
24 |             /**
25 |              * @param array<int, list<T>> $carry
26 |              * @param iterable<TKey, T> $value
27 |              *
28 |              * @return array<int, list<T>>
29 |              */
30 |             static function (array $carry, iterable $value): array {
31 |                 $index = 0;
32 | 
33 |                 foreach ($value as $carry[$index++][]);
34 | 
35 |                 return $carry;
36 |             };
37 | 
38 |         /** @var Closure(iterable<TKey, list<T>>): Generator<int, list<T>> $pipe */
39 |         $pipe = (new Pipe())()(
40 |             (new Reduce())()($reduceCallback)([]),
41 |             (new Flatten())()(1)
42 |         );
43 | 
44 |         // Point free style.
45 |         return $pipe;
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Operation/Window.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\iterators\LimitIterableAggregate;
10 | use loophp\iterators\ReductionIterableAggregate;
11 | 
12 | use function array_slice;
13 | 
14 | /**
15 |  * @immutable
16 |  *
17 |  * @template TKey
18 |  * @template T
19 |  */
20 | final class Window extends AbstractOperation
21 | {
22 |     /**
23 |      * @return Closure(int): Closure(iterable<TKey, T>): Generator<TKey|int, list<T>>
24 |      */
25 |     public function __invoke(): Closure
26 |     {
27 |         return
28 |             /**
29 |              * @return Closure(iterable<TKey, T>): Generator<TKey|int, list<T>>
30 |              */
31 |             static fn (int $size): Closure =>
32 |                 /**
33 |                  * @param iterable<TKey, T> $iterable
34 |                  *
35 |                  * @return Generator<TKey|int, list<T>>
36 |                  */
37 |                 static fn (iterable $iterable): Generator => yield from new LimitIterableAggregate(new ReductionIterableAggregate(
38 |                     $iterable,
39 |                     /**
40 |                      * @param list<T> $stack
41 |                      * @param T $current
42 |                      *
43 |                      * @return list<T>
44 |                      */
45 |                     static fn (array $stack, mixed $current): array => array_slice([...$stack, $current], ++$size * -1),
46 |                     []
47 |                 ), 1);
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/Operation/Words.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Words extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(iterable<TKey, T>): Generator<TKey, string>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         /** @var Closure(iterable<TKey, T>): Generator<TKey, string> $pipe */
24 |         $pipe = (new Pipe())()(
25 |             (new Explode())()(["\t", "\n", ' ']),
26 |             (new Map())()(
27 |                 /**
28 |                  * @param list<string> $value
29 |                  */
30 |                 static fn (array $value): string => implode('', $value)
31 |             ),
32 |             (new Compact())()([])
33 |         );
34 | 
35 |         // Point free style.
36 |         return $pipe;
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Operation/Wrap.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | 
10 | /**
11 |  * @immutable
12 |  *
13 |  * @template TKey
14 |  * @template T
15 |  */
16 | final class Wrap extends AbstractOperation
17 | {
18 |     /**
19 |      * @return Closure(iterable<TKey, T>): Generator<int, array<TKey, T>>
20 |      */
21 |     public function __invoke(): Closure
22 |     {
23 |         /** @var Closure(iterable<TKey, T>): Generator<int, array<TKey, T>> $pipe */
24 |         $pipe = (new Pipe())()(
25 |             (new Map())()(
26 |                 /**
27 |                  * @param T $value
28 |                  * @param TKey $key
29 |                  *
30 |                  * @return array<TKey, T>
31 |                  */
32 |                 static fn (mixed $value, mixed $key): array => [$key => $value]
33 |             ),
34 |             (new Normalize())()
35 |         );
36 | 
37 |         // Point free style.
38 |         return $pipe;
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Operation/Zip.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Operation;
 6 | 
 7 | use Closure;
 8 | use Generator;
 9 | use loophp\iterators\MultipleIterableAggregate;
10 | use MultipleIterator;
11 | 
12 | /**
13 |  * @immutable
14 |  *
15 |  * @template TKey
16 |  * @template T
17 |  */
18 | final class Zip extends AbstractOperation
19 | {
20 |     /**
21 |      * @template UKey
22 |      * @template U
23 |      *
24 |      * @return Closure(iterable<UKey, U>...): Closure(iterable<TKey, T>): Generator<list<TKey|UKey|null>, list<T|U|null>>
25 |      */
26 |     public function __invoke(): Closure
27 |     {
28 |         return
29 |             /**
30 |              * @param iterable<UKey, U> ...$iterables
31 |              *
32 |              * @return Closure(iterable<TKey, T>): Generator<list<TKey|UKey|null>, list<T|U|null>>
33 |              */
34 |             static fn (iterable ...$iterables): Closure =>
35 |                 /**
36 |                  * @param iterable<TKey, T> $iterable
37 |                  *
38 |                  * @return Generator<list<TKey|UKey|null>, list<T|U|null>>
39 |                  */
40 |                 static fn (iterable $iterable): Generator => yield from new MultipleIterableAggregate([$iterable, ...array_values($iterables)], MultipleIterator::MIT_NEED_ANY);
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Utils/CallbacksArrayReducer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace loophp\collection\Utils;
 6 | 
 7 | use Closure;
 8 | 
 9 | /**
10 |  * @internal
11 |  *
12 |  * @immutable
13 |  */
14 | final class CallbacksArrayReducer
15 | {
16 |     /**
17 |      * @return Closure(array<array-key, callable(mixed...): bool>): Closure(mixed...): bool
18 |      */
19 |     public static function or(): Closure
20 |     {
21 |         return
22 |             /**
23 |              * @param array<array-key, callable(mixed...): bool> $callbacks
24 |              *
25 |              * @return Closure(mixed...): bool
26 |              */
27 |             static fn (array $callbacks): Closure => static fn (mixed ...$parameters): bool => array_reduce(
28 |                 $callbacks,
29 |                 /**
30 |                  * @param callable(mixed...): bool $callable
31 |                  */
32 |                 static fn (bool $carry, callable $callable): bool => $carry || $callable(...$parameters),
33 |                 false
34 |             );
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------