Documentation

Application

Table of Contents

Classes

ShouldNotBeImplementedInWrapper
Attribute to mark methods that are not supposed to be implemented by Wrapper.
Placeholder
Object used in currying functions to omit some parameter.
Wrapper
This class is a wrapper for arrays, so you can chain functions from that library in nice fashion.

Constants

_  = '\\Wojciech\\Phlambda\\_'
__  = '\\Wojciech\\Phlambda\\__'
_and  = '\\Wojciech\\Phlambda\\_and'
_or  = '\\Wojciech\\Phlambda\\_or'
above  = '\\Wojciech\\Phlambda\\above'
add  = '\\Wojciech\\Phlambda\\add'
adjust  = '\\Wojciech\\Phlambda\\adjust'
all  = '\\Wojciech\\Phlambda\\all'
any  = '\\Wojciech\\Phlambda\\any'
append  = '\\Wojciech\\Phlambda\\append'
below  = '\\Wojciech\\Phlambda\\below'
both  = '\\Wojciech\\Phlambda\\both'
clamp  = '\\Wojciech\\Phlambda\\clamp'
collectBy  = '\\Wojciech\\Phlambda\\collectBy'
concat  = '\\Wojciech\\Phlambda\\concat'
curry  = '\\Wojciech\\Phlambda\\curry'
curry1  = '\\Wojciech\\Phlambda\\curry1'
curry2  = '\\Wojciech\\Phlambda\\curry2'
curry3  = '\\Wojciech\\Phlambda\\curry3'
curryN  = '\\Wojciech\\Phlambda\\curryN'
dec  = '\\Wojciech\\Phlambda\\dec'
diff  = '\\Wojciech\\Phlambda\\diff'
divide  = '\\Wojciech\\Phlambda\\divide'
drop  = '\\Wojciech\\Phlambda\\drop'
dropLast  = '\\Wojciech\\Phlambda\\dropLast'
dropLastWhile  = '\\Wojciech\\Phlambda\\dropLastWhile'
dropRepeats  = '\\Wojciech\\Phlambda\\dropRepeats'
either  = '\\Wojciech\\Phlambda\\either'
endsWith  = '\\Wojciech\\Phlambda\\endsWith'
filter  = '\\Wojciech\\Phlambda\\filter'
flat  = '\\Wojciech\\Phlambda\\flat'
flatMap  = '\\Wojciech\\Phlambda\\flatMap'
inc  = '\\Wojciech\\Phlambda\\inc'
map  = '\\Wojciech\\Phlambda\\map'
matches  = '\\Wojciech\\Phlambda\\matches'
multiply  = '\\Wojciech\\Phlambda\\multiply'
neither  = '\\Wojciech\\Phlambda\\neither'
not  = '\\Wojciech\\Phlambda\\not'
ofType  = '\\Wojciech\\Phlambda\\ofType'
reduce  = '\\Wojciech\\Phlambda\\reduce'
startsWith  = '\\Wojciech\\Phlambda\\startsWith'
subtract  = '\\Wojciech\\Phlambda\\subtract'
sum  = '\\Wojciech\\Phlambda\\sum'
toString  = '\\Wojciech\\Phlambda\\toString'
tuples  = '\\Wojciech\\Phlambda\\tuples'

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.
curry()  : callable
Returns currying function. Uses reflection to automatically detect number of parameters given callback is accepting.
curryN()  : callable
Returns currying function expecting n parameters.
curry3()  : callable
Returns currying function awaiting 3 arguments.
curry2()  : callable
Returns currying function awaiting 2 arguments.
curry1()  : callable
Returns currying function awaiting 1 argument.
__()  : Placeholder
Returns placeholder for omitting some arguments in currying functions.
_and()  : callable
Function returns `true` if both arguments are `true`;
both()  : callable
Function calling two provided functions and returning the `&&` of the results.
either()  : callable
Function calling two provided functions and returning the `||` of the results.
not()  : callable
Function returns inverted result of the input.
neither()  : callable
Function calling two provided functions and returning true when both are returning false.
_or()  : callable
Function returns `true` if at least one arguments is `true`;
add()  : callable|float|int
Returns sum of two numbers.
subtract()  : callable|float|int
Returns subtraction of two numbers.
dec()  : callable|float|int
Decreases number by 1.
inc()  : callable|float|int
Increases number by 1.
divide()  : callable|float|int
Divides two numbers.
multiply()  : callable|float|int
Multiplies two numbers.
sum()  : callable|float|int
Returns sum of all elements.
below()  : callable
Returns function checking if given value is below expected.
above()  : callable
Returns function checking if given value is above expected.
ofType()  : callable
Returns function that check if value is instance of given type.
clamp()  : callable|mixed
Restricts value to given minimum and maximum.
toString()  : string|callable
Converts value to string.
startsWith()  : bool|callable
Returns true if given `$item` starts with `$expected` value.
endsWith()  : bool|callable
Returns true if given `$item` ends with `$expected` value.
matches()  : bool|callable
Test regular expression against a sting. Returns all matching elements or empty array if there aren't any.

Constants

_

public mixed _ = '\\Wojciech\\Phlambda\\_'

__

public mixed __ = '\\Wojciech\\Phlambda\\__'

_and

public mixed _and = '\\Wojciech\\Phlambda\\_and'

_or

public mixed _or = '\\Wojciech\\Phlambda\\_or'

above

public mixed above = '\\Wojciech\\Phlambda\\above'

add

public mixed add = '\\Wojciech\\Phlambda\\add'

adjust

public mixed adjust = '\\Wojciech\\Phlambda\\adjust'

all

public mixed all = '\\Wojciech\\Phlambda\\all'

any

public mixed any = '\\Wojciech\\Phlambda\\any'

append

public mixed append = '\\Wojciech\\Phlambda\\append'

below

public mixed below = '\\Wojciech\\Phlambda\\below'

both

public mixed both = '\\Wojciech\\Phlambda\\both'

clamp

public mixed clamp = '\\Wojciech\\Phlambda\\clamp'

collectBy

public mixed collectBy = '\\Wojciech\\Phlambda\\collectBy'

concat

public mixed concat = '\\Wojciech\\Phlambda\\concat'

curry

public mixed curry = '\\Wojciech\\Phlambda\\curry'

curry1

public mixed curry1 = '\\Wojciech\\Phlambda\\curry1'

curry2

public mixed curry2 = '\\Wojciech\\Phlambda\\curry2'

curry3

public mixed curry3 = '\\Wojciech\\Phlambda\\curry3'

curryN

public mixed curryN = '\\Wojciech\\Phlambda\\curryN'

dec

public mixed dec = '\\Wojciech\\Phlambda\\dec'

diff

public mixed diff = '\\Wojciech\\Phlambda\\diff'

divide

public mixed divide = '\\Wojciech\\Phlambda\\divide'

drop

public mixed drop = '\\Wojciech\\Phlambda\\drop'

dropLast

public mixed dropLast = '\\Wojciech\\Phlambda\\dropLast'

dropLastWhile

public mixed dropLastWhile = '\\Wojciech\\Phlambda\\dropLastWhile'

dropRepeats

public mixed dropRepeats = '\\Wojciech\\Phlambda\\dropRepeats'

either

public mixed either = '\\Wojciech\\Phlambda\\either'

endsWith

public mixed endsWith = '\\Wojciech\\Phlambda\\endsWith'

filter

public mixed filter = '\\Wojciech\\Phlambda\\filter'

flat

public mixed flat = '\\Wojciech\\Phlambda\\flat'

flatMap

public mixed flatMap = '\\Wojciech\\Phlambda\\flatMap'

inc

public mixed inc = '\\Wojciech\\Phlambda\\inc'

map

public mixed map = '\\Wojciech\\Phlambda\\map'

matches

public mixed matches = '\\Wojciech\\Phlambda\\matches'

multiply

public mixed multiply = '\\Wojciech\\Phlambda\\multiply'

neither

public mixed neither = '\\Wojciech\\Phlambda\\neither'

not

public mixed not = '\\Wojciech\\Phlambda\\not'

ofType

public mixed ofType = '\\Wojciech\\Phlambda\\ofType'

reduce

public mixed reduce = '\\Wojciech\\Phlambda\\reduce'

startsWith

public mixed startsWith = '\\Wojciech\\Phlambda\\startsWith'

subtract

public mixed subtract = '\\Wojciech\\Phlambda\\subtract'

sum

public mixed sum = '\\Wojciech\\Phlambda\\sum'

toString

public mixed toString = '\\Wojciech\\Phlambda\\toString'

tuples

public mixed tuples = '\\Wojciech\\Phlambda\\tuples'

Functions

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
Tags
see
any()
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
Tags
see
all()
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
Tags
see
concat()
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>
Tags
see
array_merge()
see
append()
throws
InvalidArgumentException

When both parameters are not of same type

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>
Tags
see
array_diff()
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>
Tags
see
dropLast()
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

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:

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>
Tags
see

drop(), dropLastWhile()

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>
Tags
see

drop(), dropLast()

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
Tags
see
map()
see
flat()
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
Tags
see
flatMap()
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
Tags
see
flatMap()
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
Tags
throws
InvalidArgumentException

When array is empty and null initial value was passed.

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>
Tags
see
Wrapper
Return values
Wrapper —

curry()

Returns currying function. Uses reflection to automatically detect number of parameters given callback is accepting.

curry(callable $callback) : callable
Parameters
$callback : callable

callable to be curried

Tags
throws
ReflectionException
Return values
callable —

curryN()

Returns currying function expecting n parameters.

curryN(int $argumentsCount, callable $callback) : callable
Parameters
$argumentsCount : int
$callback : callable
Return values
callable —

curry3()

Returns currying function awaiting 3 arguments.

curry3(callable $callback) : callable
Parameters
$callback : callable

Callable accepting exactly 3 parameters.

Return values
callable —

curry2()

Returns currying function awaiting 2 arguments.

curry2(callable $callback) : callable
Parameters
$callback : callable

Callable accepting exactly 2 parameters.

Return values
callable —

curry1()

Returns currying function awaiting 1 argument.

curry1(callable $callback) : callable
Parameters
$callback : callable

Callable accepting exactly 1 parameter.

Return values
callable —

_and()

Function returns `true` if both arguments are `true`;

_and(bool ...$v) : callable

Example:

_and(true, true); // it will return true
Parameters
$v : bool
Tags
see
both()
Return values
callable —

both()

Function calling two provided functions and returning the `&&` of the results.

both(callable ...$v) : callable

This functions accepts two predicates and then return function accepting one parameter and calling both predicates with that parameter. Then && of both results is returned. Keep in mind that if first function will return false second one won't be call.

Example:

both('is_number', below(3))(1) // it will return true
filter(both(above(18), below(30), [11, 19, 26, 40]); // it will return [19, 26]
Parameters
$v : callable
Tags
see
_and()
Return values
callable —

either()

Function calling two provided functions and returning the `||` of the results.

either(callable ...$v) : callable

This functions accepts two predicates and then return function accepting one parameter and calling both predicates with that parameter. Then || of both results is returned. Keep in mind that both given functions will be called.

Example:

either(above(5), below(3))(1) // it will return true
filter(either(above(18), below(30), [11, 19, 26, 40]); // it will return [11, 19, 26, 40]
Parameters
$v : callable
Tags
see

_or(), neither()

Return values
callable —

not()

Function returns inverted result of the input.

not(bool|callable $input) : callable

When callback is given it will return function that will run that callback and return inverted result. Note that this callback is supposed to return boolean.

Example:

not(true); // it will return false
not(false); // it will return true
not(above(5)); // it will return function accepting number and returning true if that number is not
above 5
Parameters
$input : bool|callable
Return values
callable —

neither()

Function calling two provided functions and returning true when both are returning false.

neither(callable ...$v) : callable

This functions accepts two predicates and then return function accepting one parameter and calling both predicates with that parameter. Then negation of && operation on both results is returned. Keep in mind that if first function will return false second one won't be call.

Example:

neither(above(5), below(3))(4) // it will return true
neither(above(1), below(3))(4) // it will return false
Parameters
$v : callable
Tags
see

either(), not()

Return values
callable —

_or()

Function returns `true` if at least one arguments is `true`;

_or(bool ...$v) : callable

Example:

_or(false, true); // it will return true
_or(false, false); // it will return false
Parameters
$v : bool
Tags
see
either()
Return values
callable —

add()

Returns sum of two numbers.

add(mixed ...$v) : callable|float|int

Returns float if at least one number is float.

Parameters
$v : mixed
Return values
callable|float|int —

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

subtract()

Returns subtraction of two numbers.

subtract(mixed ...$v) : callable|float|int

Returns float if at least one number is float.

Parameters
$v : mixed
Return values
callable|float|int —

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

dec()

Decreases number by 1.

dec(mixed ...$v) : callable|float|int

Return type is same as given number.

Parameters
$v : mixed
Return values
callable|float|int —

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

inc()

Increases number by 1.

inc(mixed ...$v) : callable|float|int

Return type is same as given number.

Parameters
$v : mixed
Return values
callable|float|int —

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

divide()

Divides two numbers.

divide(mixed ...$v) : callable|float|int

Returns float if at least one number is float.

Parameters
$v : mixed
Return values
callable|float|int —

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

multiply()

Multiplies two numbers.

multiply(mixed ...$v) : callable|float|int

Returns float if at least one number is float.

Parameters
$v : mixed
Return values
callable|float|int —

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

sum()

Returns sum of all elements.

sum(mixed ...$v) : callable|float|int

Returns float if at least one number is float.

Parameters
$v : mixed
Return values
callable|float|int —

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

below()

Returns function checking if given value is below expected.

below(float|int $expected) : callable
Parameters
$expected : float|int
Return values
callable —

above()

Returns function checking if given value is above expected.

above(float|int $expected) : callable
Parameters
$expected : float|int
Return values
callable —

ofType()

Returns function that check if value is instance of given type.

ofType(string $type) : callable

To check generic types pass:

  • int
  • float
  • bool
  • string
  • array
  • object
Parameters
$type : string
Return values
callable —

clamp()

Restricts value to given minimum and maximum.

clamp(mixed ...$v) : callable|mixed

Can be used with anything comparable like int, string, \DateTime, etc.

Basic usage may look like this:

clamp(1, 10, 0); // it will return 1
clamp(1, 10, 15); // it will return 10
clamp(1, 10, 6); // it will return 6
Parameters
$v : mixed
Return values
callable|mixed —

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

toString()

Converts value to string.

toString(mixed ...$v) : string|callable 
toString(1) // it will return '1'
toString(true) // it will return '1'
toString(null) // it will return ''
Parameters
$v : mixed
Return values
string|callable —

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

startsWith()

Returns true if given `$item` starts with `$expected` value.

startsWith(mixed ...$v) : bool|callable 
startsWith('Lorem ipsum', 'Lorem ipsum 123') // it will return true
startsWith(' Lorem ipsum', 'Lorem ipsum 123') // it will return false
startsWith('lorem ipsum', 'Lorem ipsum 123') // it will return false
Parameters
$v : mixed
Return values
bool|callable —

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

endsWith()

Returns true if given `$item` ends with `$expected` value.

endsWith(mixed ...$v) : bool|callable 
endsWith('123', 'Lorem ipsum 123') // it will return true
endsWith('123 ', 'Lorem ipsum 123') // it will return false
endsWith('M 123', 'Lorem ipsum 123') // it will return false
Parameters
$v : mixed
Return values
bool|callable —

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

matches()

Test regular expression against a sting. Returns all matching elements or empty array if there aren't any.

matches(string ...$v) : bool|callable 
matches('/([a-z]a)/', 'bananas') // it will return ['ba', 'na', 'na']
matches('/a/', 'b') // it will return []
Parameters
$v : string
Return values
bool|callable —

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


        

        
    




    

    

                                

                

                            
    

        On this page

        
    


                

                                

    

        

            
Search results