Documentation

array.php

Functions

adjust() : callable|array<string|int, mixed>: Return copy of an array with replaced element at given index.
all() : callable|bool: Returns true if all elements from the array match the predicate, false if there is any which doesn't.
any() : callable|array<string|int, mixed>: Return true if any element matches given predicate.
append() : callable|array<string|int, mixed>: Return copy of an array with given element appended at the end.
concat() : string|array<string|int, mixed>|callable: Concat two elements arrays or strings.
collectBy() : array<string|int, mixed>|callable: Splits a list into sub-list based on the result of calling a key-returning function.
diff() : callable|array<string|int, mixed>: Returns elements from first array, that are not present in second
drop() : callable|array<string|int, mixed>|string: Return copy of an array/string but without first `n` elements of the given `input`.
dropLast() : callable|array<string|int, mixed>|string: Return copy of an array or string but without `n` last elements of the given `input`.
dropLastWhile() : callable|array<string|int, mixed>|string: Return copy of an array or string but without tailing elements which match predicate.
dropRepeats() : callable|array<string|int, mixed>: Return copy of an array but without repeating elements.
filter() : callable|array<string|int, mixed>: Iterates over each element of given array and returns only those who matches given predicate.
flatMap() : callable|array<string|int, mixed>: Works like map but result is single dimension array.
flat() : callable|array<string|int, mixed>: Makes single dimension array from mulit-dimension one.
map() : callable|array<string|int, mixed>: Applies given function to each element of the array and return new one with the results.
reduce() : mixed: Reduces array to single value using provided callback.
tuples() : mixed: Returns new list, composed of n-tuples of consecutive elements.
_() : Wrapper: Wraps array with Wrapper object.

adjust()

Return copy of an array with replaced element at given index.


    
                    adjust(int|callable|array<string|int, mixed>|Placeholder ...$v) : callable|array<string|int, mixed>

Applies a function to the value at given index, returning new copy of the input array with the element at given index replaced with the result of the function. Index is 0 based, and negative numbers can be used to point element from the end of the array (-1 is last element, -2 is one before last and so on). If index is greater than the size of array unchanged copy is returned.

Basic usage may look like this:

adjust(inc(), 2, [1, 2, 3]); // it will return [1, 2, 4]

adjust(inc(), -1, [1, 2, 3]); // it will return [1, 2, 4]

Parameters

$v : int|callable|array<string|int, mixed>|Placeholder

Return values

callable|array<string|int, mixed> —

If all arguments are given result is returned. Passing just some or none will result in currying function return.

all()

Returns true if all elements from the array match the predicate, false if there is any which doesn't.


    
                    all(mixed ...$v) : callable|bool

It checks all the array elements with given predicate and returns true if all matches. False is returned when at least one is not matching.

Basic usage may look like this:

all(below(4), [1,2,3]); // it will return true

You can also use it that way:

$below18 = all(below(18)); // it will return currying function
if ($below18($someUsers)) { // you can use that in code like normal function
 ...
};

Parameters

$v : mixed

Return values

callable|bool —

If all arguments are given result is returned. Passing just some or none will result in currying function return.

any()

Return true if any element matches given predicate.


    
                    any(mixed ...$v) : callable|array<string|int, mixed>

It checks all the array elements with given predicate and returns true if any matches.

Basic usage may look like this:

any(above(1), [1, 2, 3]); // it will return true

any(below(0), [1, 2, 3]); // it will return false

Parameters

$v : mixed

Return values

callable|array<string|int, mixed> —

If all arguments are given result is returned. Passing just some or none will result in currying function return.

append()

Return copy of an array with given element appended at the end.


    
                    append(mixed ...$v) : callable|array<string|int, mixed>

Appends element to the end of the given array and returns new array.

Basic usage may look like this:

append(4, [1, 2, 3]); // it will return [1, 2, 3, 4]

append([4], [1, 2, 3]); // it will return [1, 2, 3, [4]]

Parameters

$v : mixed

Return values

callable|array<string|int, mixed> —

If all arguments are given result is returned. Passing just some or none will result in currying function return.

concat()

Concat two elements arrays or strings.


    
                    concat(string|array<string|int, mixed> ...$v) : string|array<string|int, mixed>|callable

This function concat given parameters and return single value. Returned value is of same type as passed arguments. If two strings are passed, string is returned. Same if you use arrays.

Example use:

concat('12', '34')  // Returns '1234'

concat([1], [2])  // Returns [1,2]

concat([], [])  // Returns []

Note: for array concat array_merge is used so if you want to know how keys will behave see it's documentation.

Parameters

$v : string|array<string|int, mixed>

Return values

string|array<string|int, mixed>|callable —

If all arguments are given result is returned. Returned type will be same as passed parameters. Passing just some or none will result in currying function return.

collectBy()

Splits a list into sub-list based on the result of calling a key-returning function.


    
                    collectBy(callable|array<string|int, mixed> ...$v) : array<string|int, mixed>|callable

Example use:

collectBy(
fn ($x) => $x['type'],
[
['type' => 'dinner', 'item' => 'burger'],
['type' => 'breakfast', 'item' => 'coffee'],
['type' => 'dinner', 'item' => 'soup'],
['type' => 'breakfast', 'item' => 'cinnabon'],
]
);
Will return:
[
[
['type' => 'dinner', 'item' => 'burger'],
['type' => 'dinner', 'item' => 'soup'],
],
[
['type' => 'breakfast', 'item' => 'coffee'],
['type' => 'breakfast', 'item' => 'cinnabon'],
]
]

Parameters

$v : callable|array<string|int, mixed>

Return values

array<string|int, mixed>|callable —

If all arguments are given result is returned. Returned type will be same as passed parameters. Passing just some or none will result in currying function return.

diff()

Returns elements from first array, that are not present in second


    
                    diff(array<string|int, mixed> ...$v) : callable|array<string|int, mixed>

It works just like array_diff.

Basic usage may look like this:

diff([1, 2, 3], [3, 4, 5]); // it will return [1, 2]

Parameters

$v : array<string|int, mixed>

Return values

callable|array<string|int, mixed> —

If all arguments are given result is returned. Passing just some or none will result in currying function return. Type of array will be same as type of returned values from given callback.

drop()

Return copy of an array/string but without first `n` elements of the given `input`.


    
                    drop(int|string|array<string|int, mixed> ...$v) : callable|array<string|int, mixed>|string

Number of the elements can exceed size of the given array/string, in that case empty array/string will be returned. If negative number will be given, unchanged array/string is returned. For strings, mbstring functions are used.

Basic usage may look like this:

drop(1, [1, 2, 3]); // it will return [2, 3]

drop(3, [1, 2, 3]); // it will return []

drop(2, '123'); // it will return '3'

Parameters

$v : int|string|array<string|int, mixed>

Return values

callable|array<string|int, mixed>|string —

If all arguments are given result is returned. Passing just some or none will result in currying function return.

dropLast()

Return copy of an array or string but without `n` last elements of the given `input`.


    
                    dropLast(int|string|array<string|int, mixed> ...$v) : callable|array<string|int, mixed>|string

Basic usage may look like this:

dropLast(1, [1, 2, 3]); // it will return [1, 2]

dropLast(2, '123'); // it will return '12'

dropLast(3, '123'); // it will return ''

Parameters

$v : int|string|array<string|int, mixed>

Return values

callable|array<string|int, mixed>|string —

If all arguments are given result is returned. Passing just some or none will result in currying function return.

dropLastWhile()

Return copy of an array or string but without tailing elements which match predicate.


    
                    dropLastWhile(callable|string|array<string|int, mixed> ...$v) : callable|array<string|int, mixed>|string

It passes each value from the right to the supplied predicate function, skipping elements until the predicate function returns false. The predicate function is applied to one argument: (value).

Basic usage may look like this:

dropLastWhile(below(4), [1, 2, 3, 4, 3, 2, 1]); // it will return [1, 2, 3, 4]

 dropLastWhile(fn($x) => $x !== 'f', 'abcdefedcba' // it will return 'abcdef'

Parameters

$v : callable|string|array<string|int, mixed>

Return values

callable|array<string|int, mixed>|string —

If all arguments are given result is returned. Passing just some or none will result in currying function return.

dropRepeats()

Return copy of an array but without repeating elements.


    
                    dropRepeats(array<string|int, mixed> ...$v) : callable|array<string|int, mixed>

Keep in mind that your keys won't be preserved. Elements are considered as repeated when they are the same (===). Note: array_unique is not used in that case as it's not strictly comparing elements - it seems 1 and '1' as same values. The current implementation is foreach building new array and using in_array which maybe not the fastest solution.

Basic usage may look like this:

dropRepeats([1, 1, '1', 2, 3]); // it will return [1, '1', 2, 3]

Parameters

$v : array<string|int, mixed>

Return values

callable|array<string|int, mixed> —

If all arguments are given result is returned. Passing just some or none will result in currying function return.

filter()

Iterates over each element of given array and returns only those who matches given predicate.


    
                    filter(array<string|int, mixed>|callable ...$v) : callable|array<string|int, mixed>

Basic usage may look like this:

filter(below(3), [1, 2, 3]); // it will return [1, 2]

Parameters

$v : array<string|int, mixed>|callable

Return values

callable|array<string|int, mixed> —

If all arguments are given result is returned. Passing just some or none will result in currying function return.

flatMap()

Works like map but result is single dimension array.


    
                    flatMap(array<string|int, mixed>|callable ...$v) : callable|array<string|int, mixed>

It's like map but if callback returns array it is merged into result.

Basic usage may look like this:

$duplicate = fn ($x) => [$x, $x];
flatMap($duplicate, [1, 2, 3]); // it will return [1, 1, 2, 2, 3, 3]

Parameters

$v : array<string|int, mixed>|callable

Return values

callable|array<string|int, mixed> —

If all arguments are given result is returned. Passing just some or none will result in currying function return.

flat()

Makes single dimension array from mulit-dimension one.


    
                    flat(mixed ...$v) : callable|array<string|int, mixed>

It makes multi-dimension array flatter. If first argument will be true, it will do this recursively.

Basic usage may look like this:

flat(false, [[1], [2], [3]]); // it will return [1, 2, 3]
flat(true, [[1], [2], [3]]); // it will return [1, 2, 3]
flat(false, [[[1]], [[2]], [[3]]]); // it will return [[1], [2], [3]]
flat(true, [[[1]], [[2]], [[3]]]); // it will return [1, 2, 3]

Parameters

$v : mixed

Return values

callable|array<string|int, mixed> —

If all arguments are given result is returned. Passing just some or none will result in currying function return.

map()

Applies given function to each element of the array and return new one with the results.


    
                    map(mixed ...$v) : callable|array<string|int, mixed>

It works like array_map. Exactly like this.

Basic usage may look like this:

map(toString(), [1, 2, 3]); // it will return ['1', '2', '3']

Parameters

$v : mixed

Return values

callable|array<string|int, mixed> —

If all arguments are given result is returned. Passing just some or none will result in currying function return. Type of array will be same as type of returned values from given callback.

reduce()

Reduces array to single value using provided callback.


    
                    reduce(mixed ...$v) : mixed

This function iterates through whole array accumulating its values together using given callback. It also requires initial value but this can be set to null, but keep in mind that if you will use null as initial value and pass empty array, exception will be thrown.

Example use:

reduce(concat(), '1', ['2', '3', '4'])  // Returns '1234'

reduce(concat(), null, ['2', '3', '4'])  // Returns '234'

reduce(concat(), '')  // Returns currying function accepting array as param

Parameters

$v : mixed

Return values

mixed —

If all arguments are given result is returned. Returned type will be same as $fn callback. Passing just some or none will result in currying function return.

tuples()

Returns new list, composed of n-tuples of consecutive elements.


    
                    tuples(mixed ...$v) : mixed

If n is greater than the length of the list, an empty list is returned. Keys are preserved.

Example use:

tuples(2, [1, 2, 3, 4, 5])  // Returns [1, 2], [2, 3], [3, 4], [4, 5]]

tuples(2, ['a' => 1, 2, 'c' => 3, 4, 5])  // Returns ['a' => 1, 2], [2, 'c' => 3], ['c' => 3, 4], [4, 5]]

tuples(3, [1, 2, 3, 4, 5])  // Returns [[1, 2, 3], [2, 3, 4], [3, 4, 5]]

tuples(7, [1, 2, 3, 4, 5])  // Returns []

Parameters

$v : mixed

Return values

mixed —

If all arguments are given result is returned. Returned type will be same as $fn callback. Passing just some or none will result in currying function return.

_()

Wraps array with Wrapper object.


    
                    _(array<string|int, mixed> $array) : Wrapper

Example:

_([1,2,3,4,5])
  ->all(above(2))
  ->drop(1)
  ->reduce(add(), 0);

Parameters

$array : array<string|int, mixed>

Return values

Wrapper —

array.php

Tags

Table of Contents

Functions

Functions

adjust()

Parameters

Return values

all()

Parameters

Tags

Return values

any()

Parameters

Tags

Return values

append()

Parameters

Tags

Return values

concat()

Parameters

Tags

Return values

collectBy()

Parameters

Return values

diff()

Parameters

Tags

Return values

drop()

Parameters

Tags

Return values

dropLast()

Parameters

Tags

Return values

dropLastWhile()

Parameters

Tags

Return values

dropRepeats()

Parameters

Return values

filter()

Parameters

Return values

flatMap()

Parameters

Tags

Return values

flat()

Parameters

Tags

Return values

map()

Parameters

Tags

Return values

reduce()

Parameters

Tags

Return values

tuples()

Parameters

Return values

_()

Parameters

Tags

Return values