\LazyCollectionStream

__call()

__call(string  $name, array  $args) : mixed

Call a registered method

Parameters

Throws

\LazyCollection\Exceptions\InvalidMethodException

Returns

__callStatic()

__callStatic(string  $name, array  $args) : mixed

Call a registered factory

Parameters

Throws

\LazyCollection\Exceptions\InvalidFactoryException

Returns

registerMethod()

registerMethod(string  $name, callable  $method) 

Register an extension method

Parameters

Throws

\LazyCollection\Exceptions\InvalidMethodException

registerFactory()

registerFactory(string  $name, callable  $factory) 

Register a stream factory

Parameters

Throws

\LazyCollection\Exceptions\InvalidFactoryException

getIterator()

getIterator() 

fromIterable()

fromIterable(\iterable  $it, boolean  $isAssoc = null) : \LazyCollection\Stream

Make a stream from an iterable

Parameters

Returns

range()

range(integer  $start, integer  $end = null, integer  $step = 1) : \LazyCollection\Stream

Make a stream from a range of integers

Parameters

Returns

splitBy()

splitBy(string  $str, string  $separator = "", boolean  $removeEmptyStrings = true) : \LazyCollection\Stream

Make a stream by splitting a string in parts

Parameters

Returns

splitByRegex()

splitByRegex(string  $str, string  $re, boolean  $removeEmptyStrings = true) : \LazyCollection\Stream

Make a stream by splitting a string in parts using a regular expression

Parameters

Returns

map()

map(callable  $mapper) : \LazyCollection\Stream

Transform each value using the mapper function

Parameters

Returns

peek()

peek(callable  $cb) : \LazyCollection\Stream

Execute a callback on each value

Parameters

Returns

flatten()

flatten() : \LazyCollection\Stream

Flattens a stream of iterable to a stream of data (noop for associative)

Returns

flatMap()

flatMap(callable  $mapper) : \LazyCollection\Stream

Maps a stream to a stream of iterable then flattens its (associative will only map)

Parameters

Returns

mapFlattened()

mapFlattened(callable  $mapper) : \LazyCollection\Stream

Flattens the stream then maps it (associative will only map)

Parameters

Returns

reverse()

reverse() : \LazyCollection\Stream

Reverses the order of the stream (eager, works only for finite streams)

Returns

filter()

filter(callable  $predicate) : \LazyCollection\Stream

Filters only elements satisfying the given predicate

Parameters

Returns

filterNot()

filterNot(callable  $predicate) : \LazyCollection\Stream

Filters only elements that do not satisfy the given predicate

Parameters

Returns

filterOut()

filterOut(callable  $predicate) : \LazyCollection\Stream

Alias for filterNot

Parameters

Returns

notNull()

notNull() : \LazyCollection\Stream

Filters only elements non null

Returns

falsy()

falsy() : \LazyCollection\Stream

Filters only elements that are considered falsy

Returns

truthy()

truthy() : \LazyCollection\Stream

Filters only elements that are considered truthy (i.e. not falsy)

Returns

instanceOf()

instanceOf(string  $className) : \LazyCollection\Stream

Keep only the instances of the given class

Parameters

Returns

notInstanceOf()

notInstanceOf(string  $className) : \LazyCollection\Stream

Keep only the items that are not instances of the given class

Parameters

Returns

then()

then(\iterable  $it) : \LazyCollection\Stream

Streams the elements of the stream then the elements of the iterable

Parameters

Returns

zipWith()

zipWith(\Stream  $rhs) : \LazyCollection\Stream

Transform a pair of stream into a stream of pairs (of shortest length)

Parameters

Returns

takeWhile()

takeWhile(callable  $predicate) : \LazyCollection\Stream

Takes elements while the predicate is satisfied

Parameters

Returns

takeUntil()

takeUntil(callable  $predicate) : \LazyCollection\Stream

Takes elements until the predicate is satisfied

Parameters

Returns

take()

take(integer  $maxAmount) : \LazyCollection\Stream

Takes at most the first $maxAmount elements

Parameters

Returns

skipWhile()

skipWhile(callable  $predicate) : \LazyCollection\Stream

Skips elements while the predicate is satisfied

Parameters

Returns

skipUntil()

skipUntil(callable  $predicate) : \LazyCollection\Stream

Skips elements until the predicate is satisfied

Parameters

Returns

skip()

skip(integer  $maxAmount) : \LazyCollection\Stream

Skips at most the first $maxAmount elements

Parameters

Returns

subStream()

subStream(integer  $startIndex, integer  $endIndex) : \LazyCollection\Stream

Skips $startIndex elements and takes $endIndex-$startIndex elements

Parameters

Returns

uniqueBy()

uniqueBy(callable  $idExtractor) : \LazyCollection\Stream

Remove elements/duplicates that have the same id by the $idExtractor

Parameters

Returns

unique()

unique() : \LazyCollection\Stream

Remove duplicates

Returns

sortBy()

sortBy(callable  $idExtractor) : \LazyCollection\Stream

Sorts the elements by comparing the extracted IDs (ascending order)

Parameters

Returns

sort()

sort() : \LazyCollection\Stream

Sorts the elements in ascending order

Returns

sortByDescending()

sortByDescending(callable  $idExtractor) : \LazyCollection\Stream

Sorts the elements by comparing the extracted IDs (descending order)

Parameters

Returns

sortDescending()

sortDescending() : \LazyCollection\Stream

Sorts the elements in descending order

Returns

sortWith()

sortWith(callable  $comparator) : \LazyCollection\Stream

Sorts the elements using the given comparator

Parameters

Returns

chunks()

chunks(integer  $size) : \LazyCollection\Stream

Split the stream in a stream of chunks (which size is at most $size)

Parameters

Returns

forEach()

forEach(callable  $cb) : void

Execute a callback on each element

Parameters

reduce()

reduce(callable  $reducer, mixed  $init = null) : mixed|null

Reduces the stream to a single value via the reducer (if no init is provided then it will be the first element)

Parameters

Returns

count()

count(callable  $predicate = [Helpers::class, mixed  $"yes"]) : integer

Counts the amount of elements that satisfy the predicate (if no predicate is provided, will count the amount of elements)

Parameters

Returns

toArray()

toArray() : array

Consume the stream and put the values in an array

Returns

toJSON()

toJSON() : string

Consume the stream and transforms it into JSON

Returns

associateBy()

associateBy(callable  $valueFactory = [Helpers::class, mixed  $"identity"], callable  $keyFactory = [Helpers::class) : array

Create an associative array by generating key and value separately

Parameters

Returns

associate()

associate(callable  $factory) : array

Create an associative array by generating a [$key, $value] pair

Parameters

Returns

groupBy()

groupBy(callable  $keyExtractor) : array

Group an array of associative arrays into an associative array of arrays

Parameters

Returns

join()

join(array  $options) : string

Join to string using prefix, separator, suffix, stringifier, strlen and substr options

Parameters

Returns

partition()

partition(callable  $predicate) : array

Partitions the values based on the predicate (true is left, false is right)

Parameters

Returns

sum()

sum(mixed  $init = null) : \LazyCollection\number|null

Computes the sum of all the elements

Parameters

Returns

sumBy()

sumBy(callable  $mapper, mixed  $init = null) : \LazyCollection\number|null

Computes the sum of all the mapped elements

Parameters

Returns

average()

average() : \LazyCollection\number

Computes the average of all the elements

Returns

unzip()

unzip() : array

Unzips a stream of pair into a pair of arrays

Returns

all()

all(callable  $predicate) : boolean

Determine whether or not all the elements satisfy the predicate

Parameters

Returns

none()

none(callable  $predicate) : boolean

Determine whether or not none of the elements satisfy the predicate

Parameters

Returns

any()

any(callable  $predicate) : boolean

Determine whether or any of the elements satisfy the predicate

Parameters

Returns

notAll()

notAll(callable  $predicate) : boolean

Determine whether or any of the elements does not satisfy the predicate

Parameters

Returns

first()

first(callable  $predicate = [Helpers::class, mixed  $"yes"]) : mixed

Get the first element that match the predicate (or the very first if no predicate is provided) or throw if none

Parameters

Returns

firstOr()

firstOr(mixed  $default, callable  $predicate = [Helpers::class, mixed  $"yes"]) : mixed

Get the first element that match the predicate or the default element if none

Parameters

Returns

firstOrNull()

firstOrNull(callable  $predicate = [Helpers::class, mixed  $"yes"]) : mixed|null

Get the first element that match the predicate or null if none

Parameters

Returns

last()

last(callable  $predicate = [Helpers::class, mixed  $"yes"]) : mixed

Get the last element that match the predicate (or the very first if no predicate is provided) or throw if none

Parameters

Returns

lastOr()

lastOr(mixed  $default, callable  $predicate = [Helpers::class, mixed  $"yes"]) : mixed

Get the last element that match the predicate or the default element if none

Parameters

Returns

lastOrNull()

lastOrNull(callable  $predicate = [Helpers::class, mixed  $"yes"]) : mixed|null

Get the first element last match the predicate or null if none

Parameters

Returns

atIndex()

atIndex(integer  $i) : mixed

Get the element at index $i or throw if none

Parameters

Returns

atIndexOr()

atIndexOr(integer  $i, mixed  $default) : mixed

Get the $i element or the default if none

Parameters

Returns

atIndexOrNull()

atIndexOrNull(integer  $i) : mixed|null

Get the $i element or null if none

Parameters

Returns

indexOfFirst()

indexOfFirst(callable  $predicate) : integer

Get the index of the first element that satisfies the predicate, or -1

Parameters

Returns

indexOf()

indexOf(mixed  $needle) : integer

Get the first index of the $needle, or -1

Parameters

Returns

indexOfLast()

indexOfLast(callable  $predicate) : integer

Get the index of the last element that satisfies the predicate, or -1

Parameters

Returns

lastIndexOf()

lastIndexOf(mixed  $needle) : integer

Get the last index of the $needle, or -1

Parameters

Returns

maxBy()

maxBy(callable  $mapper) : mixed|null

Get the max value determined by comparing mapped values

Parameters

Returns

max()

max() : mixed|null

Get the max value

Returns

maxWith()

maxWith(callable  $comparator) : mixed|null

Get the max value using a custom comparator

Parameters

Returns

minBy()

minBy(callable  $mapper) : mixed|null

Get the min value determined by comparing mapped values

Parameters

Returns

min()

min() : mixed|null

Get the min value

Returns

minWith()

minWith(callable  $comparator) : mixed|null

Get the min value using a custom comparator

Parameters

Returns

single()

single(callable  $predicate = [Helpers::class, mixed  $"yes"]) : mixed

Get the single element that satisfies the predicate (if no predicate is given, the single element), or throws

Parameters

Returns

singleOr()

singleOr(mixed  $default, callable  $predicate = [Helpers::class, mixed  $"yes"]) : mixed

Get the single element that satisfies the predicate (if no predicate is given, the single element), or get the default

Parameters

Returns

singleOrNull()

singleOrNull(callable  $predicate = [Helpers::class, mixed  $"yes"]) : mixed

Get the single element that satisfies the predicate (if no predicate is given, the single element), or null

Parameters

Returns

contains()

contains(mixed  $needle) : boolean

Determine whether or not the stream contains the $needle

Parameters

Returns

__construct()

__construct(\Generator  $gen, boolean  $associative = false) 

Construct a stream from its generator

Parameters

pipe()

pipe(callable  $generatorFactory, boolean  $associative = false) : self

Construct a consumer stream from this stream

Parameters

Returns

hasMethod()

hasMethod(string  $name) : boolean

Determine whether or not a method is registered with the given name

Parameters

Returns

hasFactory()

hasFactory(string  $name) : boolean

Determine whether or not a factory is registered with the given name

Parameters

Returns