971 lines
28 KiB
PHP
971 lines
28 KiB
PHP
<?php
|
|
|
|
/**
|
|
* Wrapper for PHP array and provide functional-style operations.
|
|
*/
|
|
class Collection implements ArrayAccess, Countable
|
|
{
|
|
/**
|
|
* Compare strings in alphabetical order, except that multi-digit numbers are ordered as a
|
|
* single character. Only used when comparing strings.
|
|
*/
|
|
const COMPARE_NATRUAL = 1;
|
|
|
|
/**
|
|
* Elements will be campared in a case-insensitive manner. Only used when comparing strings.
|
|
*/
|
|
const FOLD_CASE = 2;
|
|
|
|
/**
|
|
* Private constructor.
|
|
* The Collection class should be initialized with static method Collection::init($data).
|
|
*/
|
|
private function __construct() {}
|
|
|
|
/**
|
|
* Adds all elements of the given elements collection to this Collection.
|
|
*
|
|
* @param array|Collection $elements
|
|
* @return void
|
|
*/
|
|
function addAll($elements) {}
|
|
|
|
/**
|
|
* Returns true if all elements match the given predicate.
|
|
*
|
|
* @param callable $predicate ($value, $key) -> bool
|
|
* @return bool
|
|
*/
|
|
function all($predicate) {}
|
|
|
|
/**
|
|
* Returns true if at least one element matches the given predicate.
|
|
*
|
|
* @param callable $predicate ($value, $key) -> bool
|
|
* @return bool
|
|
*/
|
|
function any($predicate) {}
|
|
|
|
/**
|
|
* Returns a collection containing key-value pairs provided by transform function applied
|
|
* to elements of the given collection.
|
|
*
|
|
* @param callable $transform ($value, $key) -> Pair
|
|
* @return Collection
|
|
*/
|
|
function associate($transform) {}
|
|
|
|
/**
|
|
* Populates and returns the destination collection with key-value pairs provided by transform
|
|
* function applied to each element of the given collection.
|
|
*
|
|
* @param Collection $destination
|
|
* @param callable $transform ($value, $key) -> Pair
|
|
* @return Collection
|
|
*/
|
|
function associateTo($destination, $transform) {}
|
|
|
|
/**
|
|
* Returns a collection containing the elements from the given collection indexed by the key
|
|
* returned from keySelector function applied to each element.
|
|
*
|
|
* @param callable $key_selector ($value, $key) -> $new_key
|
|
* @return Collection
|
|
*/
|
|
function associateBy($key_selector) {}
|
|
|
|
/**
|
|
* Populates and returns the destination collection with key-value pairs, where key is
|
|
* provided by the keySelector function applied to each element of the given collection
|
|
* and value is the element itself.
|
|
*
|
|
* @param Collection $destination
|
|
* @param callable $key_selector ($value, $key) -> $new_key
|
|
* @return Collection
|
|
*/
|
|
function associateByTo($destination, $key_selector) {}
|
|
|
|
/**
|
|
* Returns an average value of elements in the collection.
|
|
*
|
|
* @return double|null
|
|
*/
|
|
function average() {}
|
|
|
|
/**
|
|
* Searches the array or the range of the array for the provided element using the
|
|
* binary search algorithm.
|
|
*
|
|
* The array is expected to be packed and sorted into ascending order, otherwise the
|
|
* result is undefined.
|
|
*
|
|
* @param mixed $element
|
|
* @param int $flags[optional]
|
|
* @param int $from_index[optional]
|
|
* @param int $to_index[optional]
|
|
* @return int|null
|
|
*/
|
|
function binarySearch($element, $flags, $from_index, $to_index) {}
|
|
|
|
/**
|
|
* Searches the array or the range of the array for the provided element using the
|
|
* binary search algorithm, where the element equals to the one returned by the
|
|
* corresponding selector function.
|
|
*
|
|
* The array is expected to be packed and sorted into ascending order, otherwise the
|
|
* result is undefined.
|
|
*
|
|
* @param mixed $element
|
|
* @param callable $selector ($value, $key) -> $new_value
|
|
* @param int $flags[optional]
|
|
* @param int $from_index[optional]
|
|
* @param int $to_index[optional]
|
|
* @return int|null
|
|
*/
|
|
function binarySearchBy($element, $selector, $flags, $from_index, $to_index) {}
|
|
|
|
/**
|
|
* Splits this collection into a collection of arrays each not exceeding the given size.
|
|
*
|
|
* If the transform function is provided, apply it on each array.
|
|
*
|
|
* @param int $size
|
|
* @param callable $transform[optional] ($value, $key) -> $new_value
|
|
* @return Collection
|
|
*/
|
|
function chunked($size, $transform) {}
|
|
|
|
/**
|
|
* Checks if all key-value pairs in the specified collection are contained in this collection.
|
|
*
|
|
* @param array|Collection $other
|
|
* @return bool
|
|
*/
|
|
function containsAll($other) {}
|
|
|
|
/**
|
|
* Checks if all keys in the specified collection are contained in this collection.
|
|
*
|
|
* @param array|Collection $other
|
|
* @return bool
|
|
*/
|
|
function containsAllKeys($other) {}
|
|
|
|
/**
|
|
* Checks if all values in the specified collection are contained in this collection.
|
|
*
|
|
* @param array|Collection $other
|
|
* @return bool
|
|
*/
|
|
function containsAllValues($other) {}
|
|
|
|
/**
|
|
* Checks if the collection contains the given key.
|
|
*
|
|
* @param int|string $key
|
|
* @return bool
|
|
*/
|
|
function containsKey($key) {}
|
|
|
|
/**
|
|
* Check if the collection maps one or more keys to the specified value.
|
|
*
|
|
* @param mixed $element
|
|
* @return bool
|
|
*/
|
|
function containsValue($element) {}
|
|
|
|
/**
|
|
* Returns new collection which is a copy of the original collection.
|
|
*
|
|
* @param int $new_size[optional]
|
|
* @return Collection
|
|
*/
|
|
function copyOf($new_size) {}
|
|
|
|
/**
|
|
* Returns new collection which is a copy of range of original collection.
|
|
*
|
|
* @param int $from_index
|
|
* @param int $to_index
|
|
* @return Collection
|
|
*/
|
|
function copyOfRange($from_index, $to_index) {}
|
|
|
|
/**
|
|
* Returns the number of elements in this collection.
|
|
*
|
|
* @return int
|
|
*/
|
|
function count() {}
|
|
|
|
/**
|
|
* Returns a collection containing only distinct elements from the given collection.
|
|
*
|
|
* If the collection is an ordinary array, the element order in the returned collection is
|
|
* guaranteed to be preserved, and integer index will be reordered.
|
|
*
|
|
* @return Collection
|
|
*/
|
|
function distinct() {}
|
|
|
|
/**
|
|
* Returns a collection containing only elements from the given collection having distinct
|
|
* values returned by the given selector function.
|
|
*
|
|
* If the collection is an ordinary array, the element order in the returned collection is
|
|
* guaranteed to be preserved, and integer index will be reordered.
|
|
*
|
|
* @param callable $selector ($value, $key) -> $new_value
|
|
* @return Collection
|
|
*/
|
|
function distinctBy($selector) {}
|
|
|
|
/**
|
|
* Returns a list containing all elements except first n elements.
|
|
*
|
|
* @param int $n
|
|
* @return Collection
|
|
*/
|
|
function drop($n) {}
|
|
|
|
/**
|
|
* Returns a collection containing all elements except last n elements.
|
|
*
|
|
* @param int $n
|
|
* @return Collection
|
|
*/
|
|
function dropLast($n) {}
|
|
|
|
/**
|
|
* Returns a collection containing all elements except last elements that satisfy
|
|
* the given predicate.
|
|
*
|
|
* @param callable $predicate ($value, $key) -> bool
|
|
* @return Collection
|
|
*/
|
|
function dropLastWhile($predicate) {}
|
|
|
|
/**
|
|
* Returns a collection containing all elements except first elements that satisfy
|
|
* the given predicate.
|
|
*
|
|
* @param $predicate $predicate ($value, $key) -> bool
|
|
* @return Collection
|
|
*/
|
|
function dropWhile($predicate) {}
|
|
|
|
/**
|
|
* Fills original collection with the provided value.
|
|
*
|
|
* @param mixed $element
|
|
* @param int $from_index[optional]
|
|
* @param int $to_index[optional]
|
|
* @return void
|
|
*/
|
|
function fill($element, $from_index, $to_index) {}
|
|
|
|
/**
|
|
* Returns a collection containing only elements matching the given predicate.
|
|
*
|
|
* @param callable $predicate ($value, $key) -> bool
|
|
* @return Collection
|
|
*/
|
|
function filter($predicate) {}
|
|
|
|
/**
|
|
* Returns a collection containing only elements not matching the given predicate.
|
|
*
|
|
* @param callable $predicate ($value, $key) -> bool
|
|
* @return Collection
|
|
*/
|
|
function filterNot($predicate) {}
|
|
|
|
/**
|
|
* Appends all elements not matching the given predicate to the given destination.
|
|
*
|
|
* @param Collection $destination
|
|
* @param callable $predicate ($value, $key) -> bool
|
|
* @return Collection
|
|
*/
|
|
function filterNotTo($destination, $predicate) {}
|
|
|
|
/**
|
|
* Appends all elements matching the given predicate to the given destination.
|
|
*
|
|
* @param Collection $destination
|
|
* @param callable $predicate ($value, $key) -> bool
|
|
* @return Collection
|
|
*/
|
|
function filterTo($destination, $predicate) {}
|
|
|
|
/**
|
|
* Returns the first element matching the given predicate, or null if no such
|
|
* element was found.
|
|
*
|
|
* @param callable $predicate[optional] ($value, $key) -> bool
|
|
* @return mixed
|
|
*/
|
|
function first($predicate) {}
|
|
|
|
/**
|
|
* Returns a collection of all elements yielded from results of transform function
|
|
* being invoked on each element of original collection.
|
|
*
|
|
* @param callable $transform ($value, $key) -> array|Collection
|
|
* @return Collection
|
|
*/
|
|
function flatMap($transform) {}
|
|
|
|
/**
|
|
* Appends all elements yielded from results of transform function being invoked on each element of
|
|
* original collection, to the given destination.
|
|
*
|
|
* @param Collection $destination
|
|
* @param callable $transform ($value, $key) -> array|Collection
|
|
* @return Collection
|
|
*/
|
|
function flatMapTo($destination, $transform) {}
|
|
|
|
/**
|
|
* Returns a single list of all elements from all collections in the given collection.
|
|
*
|
|
* @return Collection
|
|
*/
|
|
function flatten() {}
|
|
|
|
/**
|
|
* Accumulates value starting with initial value and applying operation from left to
|
|
* right to current accumulator value and each element.
|
|
*
|
|
* @param mixed $initial
|
|
* @param callable $operation ($acc, $value, $key) -> $new_acc
|
|
* @return mixed
|
|
*/
|
|
function fold($initial, $operation) {}
|
|
|
|
/**
|
|
* Accumulates value starting with initial value and applying operation from right to
|
|
* left to each element and current accumulator value.
|
|
*
|
|
* @param mixed $initial
|
|
* @param callable $operation ($acc, $value, $key) -> $new_acc
|
|
* @return mixed
|
|
*/
|
|
function foldRight($initial, $operation) {}
|
|
|
|
/**
|
|
* Performs the given action on each element.
|
|
*
|
|
* @param callable $action ($value, $key) -> void
|
|
* @return void
|
|
*/
|
|
function forEach($action) {}
|
|
|
|
/**
|
|
* Returns an element at the given key or the result of calling the `default` function
|
|
* if the index is out of bounds of this collection.
|
|
*
|
|
* @param int|string $key
|
|
* @param callable $default[optional] ($key) -> $value
|
|
* @return Collection
|
|
*/
|
|
function get($key, $default) {}
|
|
|
|
/**
|
|
* Groups values by the key returned by the given transform function applied to the element
|
|
* and returns a collection where each group key is associated with a list of corresponding values.
|
|
*
|
|
* Key should be either string or integer. If the transform function returns a Pair, the
|
|
* original value will be mapped to the new value.
|
|
*
|
|
* @param callable $transform ($value, $key) -> $new_key | Pair($new_key, $new_value)
|
|
* @return Collection
|
|
*/
|
|
function groupBy($transform) {}
|
|
|
|
/**
|
|
* Groups values by the key returned by the given transform function applied to the element and
|
|
* puts to the destination collection each group key associated with a list of corresponding values.
|
|
*
|
|
* Key should be either string or integer. If the transform function returns a Pair, the
|
|
* original value will be mapped to the new value.
|
|
*
|
|
* @param Collection $destination
|
|
* @param callable $transform ($value, $key) -> $new_key | Pair($new_key, $new_value)
|
|
* @return Collection
|
|
*/
|
|
function groupByTo($destination, $transform) {}
|
|
|
|
/**
|
|
* Returns first key of element, or null if the collection does not contain element.
|
|
*
|
|
* @param mixed $element
|
|
* @return int|string|null
|
|
*/
|
|
function indexOf($element) {}
|
|
|
|
/**
|
|
* Returns key of the first element matching the given predicate, or null if the collection
|
|
* does not contain such element.
|
|
*
|
|
* @param callable $predicate[optional] ($value) -> bool
|
|
* @return int|string|null
|
|
*/
|
|
function indexOfFirst($predicate) {}
|
|
|
|
/**
|
|
* Returns key of the last element matching the given predicate, or null if the collection
|
|
* does not contain such element.
|
|
*
|
|
* @param callable $predicate[optional] ($value) -> bool
|
|
* @return int|string|null
|
|
*/
|
|
function indexOfLast($predicate) {}
|
|
|
|
/**
|
|
* Initialize collection with given data.
|
|
*
|
|
* @param array|Collection $elements[optional]
|
|
* @return Collection
|
|
*/
|
|
static function init($elements) {}
|
|
|
|
/**
|
|
* Returns a collection containing all key-value pairs that are contained by both this collection
|
|
* and the specified collection.
|
|
*
|
|
* @param array|Collection $other
|
|
* @return Collection
|
|
*/
|
|
function intersect($other) {}
|
|
|
|
/**
|
|
* Returns a collection containing all elements with keys contained by both this collection
|
|
* and the specified collection. Values are that of the original collection.
|
|
*
|
|
* @param array|Collection $other
|
|
* @return Collection
|
|
*/
|
|
function intersectKeys($other) {}
|
|
|
|
/**
|
|
* Returns a collection containing all elements with values contained by both this collection
|
|
* and the specified collection. Keys are that of the original collection.
|
|
*
|
|
* Duplicate values will be removed.
|
|
*
|
|
* @param array|Collection $other
|
|
* @return Collection
|
|
*/
|
|
function intersectValues($other) {}
|
|
|
|
/**
|
|
* Returns true if the collection is empty.
|
|
*
|
|
* @return bool
|
|
*/
|
|
function isEmpty() {}
|
|
|
|
/**
|
|
* Check whether the collection wraps a packed hashtable (regular array).
|
|
*
|
|
* @return bool
|
|
*/
|
|
function isPacked() {}
|
|
|
|
/**
|
|
* Return a collection of all keys in the collection.
|
|
*
|
|
* @return Collection
|
|
*/
|
|
function keys() {}
|
|
|
|
/**
|
|
* Returns the last element matching the given predicate, or null if no such
|
|
* element was found.
|
|
*
|
|
* @param callable $predicate[optional] ($value, $key) -> bool
|
|
* @return mixed
|
|
*/
|
|
function last($predicate) {}
|
|
|
|
/**
|
|
* Returns last key of element, or null if the collection does not contain element.
|
|
*
|
|
* @param mixed $element
|
|
* @return int|string|null
|
|
*/
|
|
function lastIndexOf($element) {}
|
|
|
|
/**
|
|
* Returns a collection containing an array of values obtained by applying the transform function
|
|
* to each element of the original collection.
|
|
*
|
|
* @param callable $transform ($value, $key) -> $new_value
|
|
* @return Collection
|
|
*/
|
|
function map($transform) {}
|
|
|
|
/**
|
|
* Populates the given destination collection with an array of values obtained by applying the
|
|
* transform function to each element of the original collection.
|
|
*
|
|
* @param Collection $destination
|
|
* @param callable $transform ($value, $key) -> $new_value
|
|
* @return Collection
|
|
*/
|
|
function mapTo($destination, $transform) {}
|
|
|
|
/**
|
|
* Returns the largest element or null if there are no elements. The collection should contain
|
|
* only one type of numeric elements(int/double).
|
|
*
|
|
* @param int $flags[optional]
|
|
* @return mixed
|
|
*/
|
|
function max($flags) {}
|
|
|
|
/**
|
|
* Returns the first element yielding the largest value of the given function or null if
|
|
* there are no elements.
|
|
*
|
|
* @param callable $selector ($value, $key) -> $new_value
|
|
* @param int $flags[optional]
|
|
* @return mixed
|
|
*/
|
|
function maxBy($selector, $flags) {}
|
|
|
|
/**
|
|
* Returns the first element having the largest value according to the provided comparator or
|
|
* null if there are no elements.
|
|
*
|
|
* @param callable $comparator (Pair($key, $value), Pair($key, $value)) -> int
|
|
* @return mixed
|
|
*/
|
|
function maxWith($comparator) {}
|
|
|
|
/**
|
|
* Returns the largest element or null if there are no elements. The collection should contain
|
|
* only one type of numeric elements(int/double).
|
|
*
|
|
* @param int $flags[optional]
|
|
* @return mixed
|
|
*/
|
|
function min($flags) {}
|
|
|
|
/**
|
|
* Returns the first element yielding the smallest value of the given function or null if
|
|
* there are no elements.
|
|
*
|
|
* @param callable $selector ($value, $key) -> $new_value
|
|
* @param int $flags[optional]
|
|
* @return mixed
|
|
*/
|
|
function minBy($selector, $flags) {}
|
|
|
|
/**
|
|
* Returns the first element having the smallest value according to the provided comparator or
|
|
* null if there are no elements.
|
|
*
|
|
* @param callable $comparator (Pair($key, $value), Pair($key, $value)) -> int
|
|
* @return mixed
|
|
*/
|
|
function minWith($comparator) {}
|
|
|
|
/**
|
|
* Returns a list containing all key-value pairs of the original collection except the ones contained
|
|
* in the given elements collection.
|
|
*
|
|
* @param array|Collection $elements
|
|
* @return Collection
|
|
*/
|
|
function minus($elements) {}
|
|
|
|
/**
|
|
* Returns true if no elements match the given predicate.
|
|
*
|
|
* @param callable $predicate ($value, $key) -> bool
|
|
* @return bool
|
|
*/
|
|
function none($predicate) {}
|
|
|
|
/**
|
|
* Performs the given action on each element and returns the collection itself afterwards.
|
|
*
|
|
* @param callable $action ($value, $key) -> void
|
|
* @return Collection
|
|
*/
|
|
function onEach($action) {}
|
|
|
|
/**
|
|
* Splits the original collection into pair of collections, where first collection contains
|
|
* elements for which predicate yielded true, while second collection contains elements for
|
|
* which predicate yielded false.
|
|
*
|
|
* @param callable $predicate ($value, $key) -> bool
|
|
* @return Pair
|
|
*/
|
|
function partition($predicate) {}
|
|
|
|
/**
|
|
* Creates a new collection by replacing or elements to this collection from a given collection.
|
|
*
|
|
* @param array|Collection $elements
|
|
* @return Collection
|
|
*/
|
|
function plus($elements) {}
|
|
|
|
/**
|
|
* Puts all the elements of the given collection into this collection.
|
|
*
|
|
* @param array|Collection $elements
|
|
* @return void
|
|
*/
|
|
function putAll($elements) {}
|
|
|
|
/**
|
|
* Accumulates value starting with the first element and applying operation from left to right to
|
|
* current accumulator value and each element.
|
|
*
|
|
* @param callable $operation ($acc, $value, $key) -> $new_acc
|
|
* @return mixed
|
|
*/
|
|
function reduce($operation) {}
|
|
|
|
/**
|
|
* Accumulates value starting with the last element and applying operation from right to left to
|
|
* each element and current accumulator value.
|
|
*
|
|
* @param callable $operation ($acc, $value, $key) -> $new_acc
|
|
* @return mixed
|
|
*/
|
|
function reduceRight($operation) {}
|
|
|
|
/**
|
|
* Removes the entry for the specified key only if it is currently mapped to the specified value.
|
|
*
|
|
* @param int|string $key
|
|
* @param mixed $value[optional]
|
|
* @return bool
|
|
*/
|
|
function remove($key, $value) {}
|
|
|
|
/**
|
|
* Removes elements of this collection whose values exists in the given collection.
|
|
*
|
|
* @param array|Collection $elements[optional]
|
|
* @return void
|
|
*/
|
|
function removeAll($elements) {}
|
|
|
|
/**
|
|
* Removes all elements from this collection that match the given predicate.
|
|
*
|
|
* @param callable $predicate ($value, $key) -> bool
|
|
* @return void
|
|
*/
|
|
function removeWhile($predicate) {}
|
|
|
|
/**
|
|
* Retains elements of this collection whose values exists in the given collection.
|
|
*
|
|
* @param array|Collection $elements
|
|
* @return void
|
|
*/
|
|
function retainAll($elements) {}
|
|
|
|
/**
|
|
* Retains all elements from this collection that match the given predicate.
|
|
*
|
|
* @param callable $predicate ($value, $key) -> bool
|
|
* @return void
|
|
*/
|
|
function retainWhile($predicate) {}
|
|
|
|
/**
|
|
* Reverses elements in the collection in-place.
|
|
*
|
|
* @return void
|
|
*/
|
|
function reverse() {}
|
|
|
|
/**
|
|
* Returns a collection with elements in reversed order.
|
|
*
|
|
* @return Collection
|
|
*/
|
|
function reversed() {}
|
|
|
|
/**
|
|
* Add a key-value pair to the array. If the key exists, update it.
|
|
*
|
|
* @param int|string $key
|
|
* @param mixed $value
|
|
* @return void
|
|
*/
|
|
function set($key, $value) {}
|
|
|
|
/**
|
|
* Randomly shuffles elements in this collection. Keys will be discarded.
|
|
*
|
|
* @return void
|
|
*/
|
|
function shuffle() {}
|
|
|
|
/**
|
|
* Returns a shuffled copy of this collection. Keys will be discarded.
|
|
*
|
|
* @return Collection
|
|
*/
|
|
function shuffled() {}
|
|
|
|
/**
|
|
* Returns the single element matching the given predicate, or null if there is no or more than
|
|
* one matching element.
|
|
*
|
|
* @param callable $predicate ($value, $key) -> bool
|
|
* @return mixed
|
|
*/
|
|
function single($predicate) {}
|
|
|
|
/**
|
|
* Returns a list containing elements at specified keys.
|
|
*
|
|
* @param array|Collection $keys
|
|
* @return Collection
|
|
*/
|
|
function slice($keys) {}
|
|
|
|
/**
|
|
* Sorts the collection in-place according to the specified order of its elements.
|
|
*
|
|
* @param int $flags[optional]
|
|
* @return void
|
|
*/
|
|
function sort($flags) {}
|
|
|
|
/**
|
|
* Sorts elements in the collection in-place according to the specified order of the value returned
|
|
* by specified selector function.
|
|
*
|
|
* @param callable $selector ($value, $key) -> $new_value
|
|
* @param int $flags[optional]
|
|
* @return void
|
|
*/
|
|
function sortBy($selector, $flags) {}
|
|
|
|
/**
|
|
* Sorts elements in the collection in-place descending according to the specified order of the
|
|
* value returned by specified selector function.
|
|
*
|
|
* @param callable $selector ($value, $key) -> $new_value
|
|
* @param int $flags[optional]
|
|
* @return void
|
|
*/
|
|
function sortByDescending($selector, $flags) {}
|
|
|
|
/**
|
|
* Sorts elements in the collection in-place descending according to the specified order.
|
|
*
|
|
* @param int $flags[optional]
|
|
* @return void
|
|
*/
|
|
function sortDescending($flags) {}
|
|
|
|
/**
|
|
* Sorts elements in the collection in-place according to the order specified with comparator.
|
|
*
|
|
* @param callable $comparator (Pair($key, $value), Pair($key, $value)) -> int
|
|
* @return void
|
|
*/
|
|
function sortWith($comparator) {}
|
|
|
|
/**
|
|
* Returns a collection of all elements sorted according to the specified order.
|
|
*
|
|
* @param int $flags[optional]
|
|
* @return Collection
|
|
*/
|
|
function sorted($flags) {}
|
|
|
|
/**
|
|
* Returns a collection of all elements sorted according to the specified order of the
|
|
* value returned by specified selector function.
|
|
*
|
|
* @param callable $selector ($value, $key) -> $new_value
|
|
* @param int $flags[optional]
|
|
* @return Collection
|
|
*/
|
|
function sortedBy($selector, $flags) {}
|
|
|
|
/**
|
|
* Returns a collection of all elements sorted descending according to the specified order
|
|
* of the value returned by specified selector function.
|
|
*
|
|
* @param callable $selector ($value, $key) -> $new_value
|
|
* @param int $flags[optional]
|
|
* @return Collection
|
|
*/
|
|
function sortedByDescending($selector, $flags) {}
|
|
|
|
/**
|
|
* Returns a collection of all elements sorted descending according to the specified order.
|
|
*
|
|
* @param callable $selector ($value, $key) -> $new_value
|
|
* @param int $flags[optional]
|
|
* @return Collection
|
|
*/
|
|
function sortedDescending($selector, $flags) {}
|
|
|
|
/**
|
|
* Returns a collection of all elements sorted according to the specified comparator.
|
|
*
|
|
* @param callable $comparator (Pair($key, $value), Pair($key, $value)) -> int
|
|
* @return Collection
|
|
*/
|
|
function sortedWith($comparator) {}
|
|
|
|
/**
|
|
* Returns a collection containing all distinct elements that are contained by this
|
|
* collection and not contained by the specified collection.
|
|
*
|
|
* @param array|Collection $other
|
|
* @return Collection
|
|
*/
|
|
function subtract($other) {}
|
|
|
|
/**
|
|
* Returns the sum of all elements in the collection.
|
|
*
|
|
* All elements should be of the same type, int or double. Otherwise result is undefined.
|
|
*
|
|
* @return int|double|null
|
|
*/
|
|
function sum() {}
|
|
|
|
/**
|
|
* Returns the sum of all values produced by selector function applied to each element
|
|
* in the collection.
|
|
*
|
|
* All return values of the selector function should be of the same type, int or double.
|
|
* Otherwise result is undefined.
|
|
*
|
|
* @param callable $selector ($value, $key) -> int|double
|
|
* @return int|double|null
|
|
*/
|
|
function sumBy($selector) {}
|
|
|
|
/**
|
|
* Returns a collection containing first n elements.
|
|
*
|
|
* @param int $n
|
|
* @return Collection
|
|
*/
|
|
function take($n) {}
|
|
|
|
/**
|
|
* Returns a list containing last n elements.
|
|
*
|
|
* @param int $n
|
|
* @return Collection
|
|
*/
|
|
function takeLast($n) {}
|
|
|
|
/**
|
|
* Returns a collection containing last elements satisfying the given predicate.
|
|
*
|
|
* @param callable $predicate ($value, $key) -> bool
|
|
* @return Collection
|
|
*/
|
|
function takeLastWhile($predicate) {}
|
|
|
|
/**
|
|
* Returns a collection containing first elements satisfying the given predicate.
|
|
*
|
|
* @param callable $predicate ($value, $key) -> bool
|
|
* @return Collection
|
|
*/
|
|
function takeWhile($predicate) {}
|
|
|
|
/**
|
|
* Returns the array wrapped by this collection.
|
|
*
|
|
* @return array
|
|
*/
|
|
function toArray() {}
|
|
|
|
/**
|
|
* Appends all elements to the given destination collection.
|
|
*
|
|
* @param Collection $destination
|
|
* @return Collection
|
|
*/
|
|
function toCollection($destination) {}
|
|
|
|
/**
|
|
* Convert collection to a collection of pairs with keys being first and values being second.
|
|
*
|
|
* @return Collection
|
|
*/
|
|
function toPairs() {}
|
|
|
|
/**
|
|
* Returns a collection containing all distinct elements from both collections.
|
|
*
|
|
* @param array|Collection $other
|
|
*/
|
|
function union($other) {}
|
|
|
|
/**
|
|
* Return a collection of all values of the collection.
|
|
*
|
|
* @return Collection
|
|
*/
|
|
function values() {}
|
|
|
|
/**
|
|
* Returns a collection of snapshots of the window of the given size sliding along this
|
|
* collection with the given step, where each snapshot is an array.
|
|
*
|
|
* If provided, the transform function will be applied to each snapshot.
|
|
*
|
|
* The wrapped array must be packed.
|
|
*
|
|
* @param int $size
|
|
* @param int $step[optional] = 1
|
|
* @param bool $partial_windows[optional] = false
|
|
* @param callable $transform[optional] ($value, $key) -> $new_value
|
|
* @return Collection
|
|
*/
|
|
function windowed($size, $step, $partial_windows, $transform) {}
|
|
|
|
/**
|
|
* Returns a collection of pairs built from the elements of this array and other array
|
|
* with the same index. The returned collection has length of the shortest array.
|
|
*
|
|
* If the transform function is provided, return a collection of the return values of
|
|
* the transform function applied to each pair of elements.
|
|
*
|
|
* Both arrays must be packed.
|
|
*
|
|
* @param array|Collection $other
|
|
* @param callable $transform[optional] ($v1, $v2) -> $new_value
|
|
* @return Collection
|
|
*/
|
|
function zip($other, $transform) {}
|
|
|
|
/**
|
|
* Returns a list of pairs of each two adjacent elements in this collection.
|
|
*
|
|
* If the transform function is provided, return a collection of the return values of
|
|
* the transform function applied to each pair of elements.
|
|
*
|
|
* The wrapped array must be packed.
|
|
*
|
|
* @param callable $transform[optional] ($v1, $v2) -> $new_value
|
|
* @return Collection
|
|
*/
|
|
function zipWithNext($transform) {}
|
|
}
|