Interface Illuminate\Support\Enumerable

`extends`	`Arrayable<TKey, TValue>, Countable, IteratorAggregate<TKey, TValue>, Jsonable, JsonSerializable`


					
	public
					static

make<TMakeKey is array-key, TMakeValue>(
	Arrayable<TMakeKey, TMakeValue>|iterable<TMakeKey, TMakeValue>|null $items = [],
): static<TMakeKey, TMakeValue>

Create a new collection instance if the value isn't one already.

Implemented by

Illuminate\Support\LazyCollection::make()

#


					
	public
					static

times(int $number, callable|null $callback = null): static

Create a new instance by invoking the callback a given amount of times.

#


					
	public
					static

range(int $from, int $to, int $step = 1): static

Create a collection with the given range.

Implemented by

#


					
	public
					static

wrap<TWrapValue>(iterable<array-key, TWrapValue>|TWrapValue $value): static<array-key, TWrapValue>

Wrap the given value in a collection if applicable.

#


					
	public
					static

unwrap<TUnwrapKey is array-key, TUnwrapValue>(
	array<TUnwrapKey, TUnwrapValue>|static<TUnwrapKey, TUnwrapValue> $value,
): array<TUnwrapKey, TUnwrapValue>

Get the underlying items from the given collection if applicable.

#


					
	public
					static

empty(): static

Create a new instance with no items.

#


					
	public

all(): array

Get all items in the enumerable.

Implemented by

#


					
	public

Alias for the "avg" method.

#


					
	public

median(string|array<array-key, string>|null $key = null): float|int|null

Get the median of a given key.

Implemented by

#


					
	public

mode(string|array<array-key, string>|null $key = null): array<int, float|int>|null

Get the mode of a given key.

Implemented by

#


					
	public

collapse(): static<int, mixed>

Collapse the items into a single enumerable.

Implemented by

#


					
	public

some((callable(TValue, TKey): bool)|TValue|string $key, mixed $operator = null, mixed $value = null): bool

Alias for the "contains" method.

#


					
	public

containsStrict((callable(TValue): bool)|TValue|array-key $key, TValue|null $value = null): bool

Determine if an item exists, using strict comparison.

Implemented by

#


					
	public

Get the average value of a given key.

#


					
	public

contains((callable(TValue, TKey): bool)|TValue|string $key, mixed $operator = null, mixed $value = null): bool

Determine if an item exists in the enumerable.

Implemented by

#


					
	public

doesntContain(mixed $key, mixed $operator = null, mixed $value = null): bool

Determine if an item is not contained in the collection.

Implemented by

#


					
	public

crossJoin<TCrossJoinKey, TCrossJoinValue>(
	Arrayable<TCrossJoinKey, TCrossJoinValue>|iterable<TCrossJoinKey, TCrossJoinValue> ...$lists,
): static<int, array<int, TValue|TCrossJoinValue>>

Cross join with the given lists, returning all possible permutations.

Implemented by

#


					
	public

dd(mixed ...$args): never

Dump the collection and end the script.

#


					
	public

dump(mixed ...$args): $this

Dump the collection.

#


					
	public

diff(Arrayable<array-key, TValue>|iterable<array-key, TValue> $items): static

Get the items that are not present in the given items.

Implemented by

#


					
	public

diffUsing(
	Arrayable<array-key, TValue>|iterable<array-key, TValue> $items,
	callable(TValue, TValue): int $callback,
): static

Get the items that are not present in the given items, using the callback.

Implemented by

#


					
	public

diffAssoc(Arrayable<TKey, TValue>|iterable<TKey, TValue> $items): static

Get the items whose keys and values are not present in the given items.

Implemented by

#


					
	public

diffAssocUsing(Arrayable<TKey, TValue>|iterable<TKey, TValue> $items, callable(TKey, TKey): int $callback): static

Get the items whose keys and values are not present in the given items, using the callback.

Implemented by

#


					
	public

diffKeys(Arrayable<TKey, mixed>|iterable<TKey, mixed> $items): static

Get the items whose keys are not present in the given items.

Implemented by

#


					
	public

diffKeysUsing(Arrayable<TKey, mixed>|iterable<TKey, mixed> $items, callable(TKey, TKey): int $callback): static

Get the items whose keys are not present in the given items, using the callback.

Implemented by

#


					
	public

duplicates((callable(TValue): bool)|string|null $callback = null, bool $strict = false): static

Retrieve duplicate items.

Implemented by

#


					
	public

duplicatesStrict((callable(TValue): bool)|string|null $callback = null): static

Retrieve duplicate items using strict comparison.

Implemented by

#


					
	public

each(callable(TValue, TKey): mixed $callback): $this

Execute a callback over each item.

#


					
	public

eachSpread(callable $callback): static

Execute a callback over each nested chunk of items.

#


					
	public

every((callable(TValue, TKey): bool)|TValue|string $key, mixed $operator = null, mixed $value = null): bool

Determine if all items pass the given truth test.

#


					
	public

except(Enumerable<array-key, TKey>|array<array-key, TKey> $keys): static

Get all items except for those with the specified keys.

Implemented by

#


					
	public

filter((callable(TValue): bool)|null $callback = null): static

Run a filter over each of the items.

Implemented by

#


					
	public

when<TWhenReturnType is null>(
	bool $value,
	(callable($this): TWhenReturnType)|null $callback = null,
	(callable($this): TWhenReturnType)|null $default = null,
): $this|TWhenReturnType

Apply the callback if the given "value" is (or resolves to) truthy.

#


					
	public

whenEmpty<TWhenEmptyReturnType>(
	callable($this): TWhenEmptyReturnType $callback,
	(callable($this): TWhenEmptyReturnType)|null $default = null,
): $this|TWhenEmptyReturnType

Apply the callback if the collection is empty.

#


					
	public

whenNotEmpty<TWhenNotEmptyReturnType>(
	callable($this): TWhenNotEmptyReturnType $callback,
	(callable($this): TWhenNotEmptyReturnType)|null $default = null,
): $this|TWhenNotEmptyReturnType

Apply the callback if the collection is not empty.

#


					
	public

unless<TUnlessReturnType>(
	bool $value,
	callable($this): TUnlessReturnType $callback,
	(callable($this): TUnlessReturnType)|null $default = null,
): $this|TUnlessReturnType

Apply the callback if the given "value" is (or resolves to) falsy.

#


					
	public

unlessEmpty<TUnlessEmptyReturnType>(
	callable($this): TUnlessEmptyReturnType $callback,
	(callable($this): TUnlessEmptyReturnType)|null $default = null,
): $this|TUnlessEmptyReturnType

Apply the callback unless the collection is empty.

#


					
	public

unlessNotEmpty<TUnlessNotEmptyReturnType>(
	callable($this): TUnlessNotEmptyReturnType $callback,
	(callable($this): TUnlessNotEmptyReturnType)|null $default = null,
): $this|TUnlessNotEmptyReturnType

Apply the callback unless the collection is not empty.

#


					
	public

where(string $key, mixed $operator = null, mixed $value = null): static

Filter items by the given key value pair.

#


					
	public

whereNull(string|null $key = null): static

Filter items where the value for the given key is null.

#


					
	public

whereNotNull(string|null $key = null): static

Filter items where the value for the given key is not null.

#


					
	public

whereStrict(string $key, mixed $value): static

Filter items by the given key value pair using strict comparison.

#


					
	public

whereIn(string $key, Arrayable|iterable $values, bool $strict = false): static

Filter items by the given key value pair.

#


					
	public

whereInStrict(string $key, Arrayable|iterable $values): static

Filter items by the given key value pair using strict comparison.

#


					
	public

whereBetween(string $key, Arrayable|iterable $values): static

Filter items such that the value of the given key is between the given values.

#


					
	public

whereNotBetween(string $key, Arrayable|iterable $values): static

Filter items such that the value of the given key is not between the given values.

#


					
	public

whereNotIn(string $key, Arrayable|iterable $values, bool $strict = false): static

Filter items by the given key value pair.

#


					
	public

whereNotInStrict(string $key, Arrayable|iterable $values): static

Filter items by the given key value pair using strict comparison.

#


					
	public

whereInstanceOf<TWhereInstanceOf>(
	class-string<TWhereInstanceOf>|array<array-key, class-string<TWhereInstanceOf>> $type,
): static<TKey, TWhereInstanceOf>

Filter the items, removing any items that don't match the given type(s).

#


					
	public

first<TFirstDefault>(
	(callable(TValue, TKey): bool)|null $callback = null,
	TFirstDefault|(Closure(): TFirstDefault) $default = null,
): TValue|TFirstDefault

Get the first item from the enumerable passing the given truth test.

Implemented by

#


					
	public

firstWhere(string $key, mixed $operator = null, mixed $value = null): TValue|null

Get the first item by the given key value pair.

#


					
	public

flatten(int $depth = INF): static

Get a flattened array of the items in the collection.

Implemented by

#


					
	public

flip(): static<TValue, TKey>

Flip the values with their keys.

Implemented by

#


					
	public

get<TGetDefault>(TKey $key, TGetDefault|(Closure(): TGetDefault) $default = null): TValue|TGetDefault

Get an item from the collection by key.

Implemented by

#


					
	public

groupBy<TGroupKey is array-key>(
	(callable(TValue, TKey): TGroupKey)|array|string $groupBy,
	bool $preserveKeys = false,
): static<($groupBy is string ? array-key : ($groupBy is array ? array-key : TGroupKey)), static<($preserveKeys is true ? TKey : int), ($groupBy is array ? mixed : TValue)>>

Group an associative array by a field or using a callback.

Implemented by

#


					
	public

keyBy<TNewKey is array-key>(
	(callable(TValue, TKey): TNewKey)|array|string $keyBy,
): static<($keyBy is string ? array-key : ($keyBy is array ? array-key : TNewKey)), TValue>

Key an associative array by a field or using a callback.

Implemented by

#


					
	public

has(TKey|array<array-key, TKey> $key): bool

Determine if an item exists in the collection by key.

Implemented by

#


					
	public

hasAny(mixed $key): bool

Determine if any of the keys exist in the collection.

Implemented by

#


					
	public

implode((callable(TValue, TKey): mixed)|string $value, string|null $glue = null): string

Concatenate values of a given key as a string.

Implemented by

#


					
	public

intersect(Arrayable<TKey, TValue>|iterable<TKey, TValue> $items): static

Intersect the collection with the given items.

Implemented by

#


					
	public

intersectUsing(
	Arrayable<array-key, TValue>|iterable<array-key, TValue> $items,
	callable(TValue, TValue): int $callback,
): static

Intersect the collection with the given items, using the callback.

Implemented by

#


					
	public

intersectAssoc(Arrayable<TKey, TValue>|iterable<TKey, TValue> $items): static

Intersect the collection with the given items with additional index check.

Implemented by

#


					
	public

intersectAssocUsing(
	Arrayable<array-key, TValue>|iterable<array-key, TValue> $items,
	callable(TValue, TValue): int $callback,
): static

Intersect the collection with the given items with additional index check, using the callback.

Implemented by

#


					
	public

intersectByKeys(Arrayable<TKey, mixed>|iterable<TKey, mixed> $items): static

Intersect the collection with the given items by key.

Implemented by

#


					
	public

isEmpty(): bool

Determine if the collection is empty or not.

Implemented by

#


					
	public

isNotEmpty(): bool

Determine if the collection is not empty.

#


					
	public

containsOneItem(): bool

Determine if the collection contains a single item.

Implemented by

#


					
	public

join(string $glue, string $finalGlue = ''): string

Join all items from the collection using a string. The final items can use a separate glue string.

Implemented by

#


					
	public

keys(): static<int, TKey>

Get the keys of the collection items.

Implemented by

#


					
	public

last<TLastDefault>(
	(callable(TValue, TKey): bool)|null $callback = null,
	TLastDefault|(Closure(): TLastDefault) $default = null,
): TValue|TLastDefault

Get the last item from the collection.

Implemented by

#


					
	public

map<TMapValue>(callable(TValue, TKey): TMapValue $callback): static<TKey, TMapValue>

Run a map over each of the items.

Implemented by

#


					
	public

mapSpread(callable $callback): static

Run a map over each nested chunk of items.

#


					
	public

mapToDictionary<TMapToDictionaryKey is array-key, TMapToDictionaryValue>(
	callable(TValue, TKey): array<TMapToDictionaryKey, TMapToDictionaryValue> $callback,
): static<TMapToDictionaryKey, array<int, TMapToDictionaryValue>>

Run a dictionary map over the items.

The callback should return an associative array with a single key/value pair.

Implemented by

#


					
	public

mapToGroups<TMapToGroupsKey is array-key, TMapToGroupsValue>(
	callable(TValue, TKey): array<TMapToGroupsKey, TMapToGroupsValue> $callback,
): static<TMapToGroupsKey, static<int, TMapToGroupsValue>>

Run a grouping map over the items.

The callback should return an associative array with a single key/value pair.

#


					
	public

mapWithKeys<TMapWithKeysKey is array-key, TMapWithKeysValue>(
	callable(TValue, TKey): array<TMapWithKeysKey, TMapWithKeysValue> $callback,
): static<TMapWithKeysKey, TMapWithKeysValue>

Run an associative map over each of the items.

The callback should return an associative array with a single key/value pair.

Implemented by

#


					
	public

flatMap<TFlatMapKey is array-key, TFlatMapValue>(
	callable(TValue, TKey): (Collection<TFlatMapKey, TFlatMapValue>|array<TFlatMapKey, TFlatMapValue>) $callback,
): static<TFlatMapKey, TFlatMapValue>

Map a collection and flatten the result by a single level.

#


					
	public

mapInto<TMapIntoValue>(class-string<TMapIntoValue> $class): static<TKey, TMapIntoValue>

Map the values into a new class.

#


					
	public

merge(Arrayable<TKey, TValue>|iterable<TKey, TValue> $items): static

Merge the collection with the given items.

Implemented by

#


					
	public

mergeRecursive<TMergeRecursiveValue>(
	Arrayable<TKey, TMergeRecursiveValue>|iterable<TKey, TMergeRecursiveValue> $items,
): static<TKey, TValue|TMergeRecursiveValue>

Recursively merge the collection with the given items.

Implemented by

#


					
	public

combine<TCombineValue>(
	Arrayable<array-key, TCombineValue>|iterable<array-key, TCombineValue> $values,
): static<TValue, TCombineValue>

Create a collection by using this collection for keys and another for its values.

Implemented by

#


					
	public

union(Arrayable<TKey, TValue>|iterable<TKey, TValue> $items): static

Union the collection with the given items.

Implemented by

#


					
	public

min((callable(TValue): mixed)|string|null $callback = null): mixed

Get the min value of a given key.

#


					
	public

max((callable(TValue): mixed)|string|null $callback = null): mixed

Get the max value of a given key.

#


					
	public

nth(int $step, int $offset = 0): static

Create a new collection consisting of every n-th element.

Implemented by

#


					
	public

only(Enumerable<array-key, TKey>|array<array-key, TKey>|string $keys): static

Get the items with the specified keys.

Implemented by

#


					
	public

forPage(int $page, int $perPage): static

"Paginate" the collection by slicing it into a smaller collection.

#


					
	public

partition(
	(callable(TValue, TKey): bool)|TValue|string $key,
	mixed $operator = null,
	mixed $value = null,
): static<int<0, 1>, static<TKey, TValue>>

Partition the collection into two arrays using the given callback or key.

Implemented by

Illuminate\Database\Eloquent\Collection::partition()

#


					
	public

concat<TConcatKey is array-key, TConcatValue>(
	iterable<TConcatKey, TConcatValue> $source,
): static<TKey|TConcatKey, TValue|TConcatValue>

Push all of the given items onto the collection.

Implemented by

#


					
	public

random(int|null $number = null): static<int, TValue>|TValue

Get one or a specified number of items randomly from the collection.

Throws

InvalidArgumentException

Implemented by

#


					
	public

reduce<TReduceInitial, TReduceReturnType>(
	callable(TReduceInitial|TReduceReturnType, TValue, TKey): TReduceReturnType $callback,
	TReduceInitial $initial = null,
): TReduceInitial|TReduceReturnType

Reduce the collection to a single value.

#


					
	public

reduceSpread(callable $callback, mixed ...$initial): array

Reduce the collection to multiple aggregate values.

Throws

UnexpectedValueException

#


					
	public

replace(Arrayable<TKey, TValue>|iterable<TKey, TValue> $items): static

Replace the collection items with the given items.

Implemented by

#


					
	public

replaceRecursive(Arrayable<TKey, TValue>|iterable<TKey, TValue> $items): static

Recursively replace the collection items with the given items.

Implemented by

#


					
	public

reverse(): static

Reverse items order.

Implemented by

#


					
	public

search(TValue|(callable(TValue, TKey): bool) $value, bool $strict = false): TKey|bool

Search the collection for a given value and return the corresponding key if successful.

Implemented by

#


					
	public

before(TValue|(callable(TValue, TKey): bool) $value, bool $strict = false): TValue|null

Get the item before the given item.

Implemented by

#


					
	public

after(TValue|(callable(TValue, TKey): bool) $value, bool $strict = false): TValue|null

Get the item after the given item.

Implemented by

#


					
	public

shuffle(): static

Shuffle the items in the collection.

Implemented by

#


					
	public

sliding(int $size = 2, int $step = 1): static<int, static>

Create chunks representing a "sliding window" view of the items in the collection.

Implemented by

#


					
	public

skip(int $count): static

Skip the first {$count} items.

Implemented by

#


					
	public

skipUntil(TValue|(callable(TValue, TKey): bool) $value): static

Skip items in the collection until the given condition is met.

Implemented by

#


					
	public

skipWhile(TValue|(callable(TValue, TKey): bool) $value): static

Skip items in the collection while the given condition is met.

Implemented by

#


					
	public

slice(int $offset, int|null $length = null): static

Get a slice of items from the enumerable.

Implemented by

#


					
	public

split(int $numberOfGroups): static<int, static>

Split a collection into a certain number of groups.

Implemented by

#


					
	public

sole((callable(TValue, TKey): bool)|string $key = null, mixed $operator = null, mixed $value = null): TValue

Get the first item in the collection, but only if exactly one item exists. Otherwise, throw an exception.

Throws

`Illuminate\Support\ItemNotFoundException`
`Illuminate\Support\MultipleItemsFoundException`

Implemented by

#


					
	public

firstOrFail((callable(TValue, TKey): bool)|string $key = null, mixed $operator = null, mixed $value = null): TValue

Get the first item in the collection but throw an exception if no matching items exist.

Throws

Illuminate\Support\ItemNotFoundException

Implemented by

#


					
	public

chunk(int $size): static<int, static>

Chunk the collection into chunks of the given size.

Implemented by

#


					
	public

chunkWhile(callable(TValue, TKey, static<int, TValue>): bool $callback): static<int, static<int, TValue>>

Chunk the collection into chunks with a callback.

Implemented by

#


					
	public

splitIn(int $numberOfGroups): static<int, static>

Split a collection into a certain number of groups, and fill the first groups completely.

Implemented by

#


					
	public

sort((callable(TValue, TValue): int)|null|int $callback = null): static

Sort through each item with a callback.

Implemented by

#


					
	public

sortDesc(int $options = SORT_REGULAR): static

Sort items in descending order.

Implemented by

#


					
	public

sortBy(
	array<array-key, (callable(TValue, TValue): mixed)|(callable(TValue, TKey): mixed)|string|array{string, string}>|(callable(TValue, TKey): mixed)|string $callback,
	int $options = SORT_REGULAR,
	bool $descending = false,
): static

Sort the collection using the given callback.

Implemented by

#


					
	public

sortByDesc(
	array<array-key, (callable(TValue, TValue): mixed)|(callable(TValue, TKey): mixed)|string|array{string, string}>|(callable(TValue, TKey): mixed)|string $callback,
	int $options = SORT_REGULAR,
): static

Sort the collection in descending order using the given callback.

Implemented by

#


					
	public

sortKeys(int $options = SORT_REGULAR, bool $descending = false): static

Sort the collection keys.

Implemented by

#


					
	public

sortKeysDesc(int $options = SORT_REGULAR): static

Sort the collection keys in descending order.

Implemented by

#


					
	public

sortKeysUsing(callable(TKey, TKey): int $callback): static

Sort the collection keys using a callback.

Implemented by

#


					
	public

sum((callable(TValue): mixed)|string|null $callback = null): mixed

Get the sum of the given values.

#


					
	public

take(int $limit): static

Take the first or last {$limit} items.

Implemented by

#


					
	public

takeUntil(TValue|(callable(TValue, TKey): bool) $value): static

Take items in the collection until the given condition is met.

Implemented by

#


					
	public

takeWhile(TValue|(callable(TValue, TKey): bool) $value): static

Take items in the collection while the given condition is met.

Implemented by

#


					
	public

tap(callable(TValue): mixed $callback): $this

Pass the collection to the given callback and then return it.

#


					
	public

pipe<TPipeReturnType>(callable($this): TPipeReturnType $callback): TPipeReturnType

Pass the enumerable to the given callback and return the result.

#


					
	public

pipeInto<TPipeIntoValue>(class-string<TPipeIntoValue> $class): TPipeIntoValue

Pass the collection into a new class.

#


					
	public

pipeThrough(array<callable> $pipes): mixed

Pass the collection through a series of callable pipes and return the result.

#


					
	public

pluck(string|array<array-key, string> $value, string|null $key = null): static<array-key, mixed>

Get the values of a given key.

Implemented by

#


					
	public

reject((callable(TValue, TKey): bool)|bool|TValue $callback = true): static

Create a collection of all elements that do not pass a given truth test.

#


					
	public

undot(): static

Convert a flatten "dot" notation array into an expanded array.

Implemented by

#


					
	public

unique((callable(TValue, TKey): mixed)|string|null $key = null, bool $strict = false): static

Return only unique items from the collection array.

Implemented by

#


					
	public

uniqueStrict((callable(TValue, TKey): mixed)|string|null $key = null): static

Return only unique items from the collection array using strict comparison.

#


					
	public

values(): static<int, TValue>

Reset the keys on the underlying array.

Implemented by

#


					
	public

pad<TPadValue>(int $size, TPadValue $value): static<int, TValue|TPadValue>

Pad collection to the specified length with a value.

Implemented by

#


					
	public

getIterator(): Traversable<TKey, TValue>

Get the values iterator.

#


					
	public

count(): int

Count the number of items in the collection.

#


					
	public

countBy((callable(TValue, TKey): array-key)|string|null $countBy = null): static<array-key, int>

Count the number of items in the collection by a field or using a callback.

Implemented by

#


					
	public

zip<TZipValue>(
	Arrayable<array-key, TZipValue>|iterable<array-key, TZipValue> ...$items,
): static<int, static<int, TValue|TZipValue>>

Zip the collection together with one or more arrays.

e.g. new Collection([1, 2, 3])->zip([4, 5, 6]); => [[1, 4], [2, 5], [3, 6]]

Implemented by

#


					
	public

collect(): Collection<TKey, TValue>

Collect the values into a collection.

#


					
	public

toArray(): array<TKey, mixed>

Get the collection of items as a plain array.

#


					
	public

jsonSerialize(): mixed

Convert the object into something JSON serializable.

#


					
	public

toJson(int $options = 0): string

Get the collection of items as JSON.

#


					
	public

getCachingIterator(int $flags = CachingIterator::CALL_TOSTRING): CachingIterator

Get a CachingIterator instance.

#


					
	public

__toString(): string

Convert the collection to its string representation.

#


					
	public

escapeWhenCastingToString(bool $escape = true): $this

Indicate that the model's string representation should be escaped when __toString is invoked.

#


					
	public
					static

proxy(string $method): void

Add a method to the list of proxied methods.

#


					
	public

__get(string $key): mixed

Dynamically access collection proxies.

Throws

Exception

#

Namespaces

Classes

Interfaces

Traits

Exceptions

Interface Illuminate\Support\Enumerable

<TKey is array-key, out TValue>

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Throws

Implemented by

Throws

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Implemented by

Throws

Implemented by

Throws

Implemented by

Implemented by

Implemented by

Implemented by

`<TKey is array-key, out TValue>`