public static assertCollection ( $collection, $callee, $parameterPosition ) |
/** * Recombines arrays by index (column) and applies a callback optionally * * When the input collections are different lengths the resulting collections * will all have the length which is required to fit all the keys * * @param $args array|Traversable $collection One or more callbacks * @return array */ function zip_all(...$args) { /** @var callable|null $callback */ $callback = null; if (is_callable(end($args))) { $callback = array_pop($args); } foreach ($args as $position => $arg) { InvalidArgumentException::assertCollection($arg, __FUNCTION__, $position + 1); } $resultKeys = []; foreach ($args as $arg) { foreach ($arg as $index => $value) { $resultKeys[] = $index; } } $resultKeys = array_unique($resultKeys); $result = []; foreach ($resultKeys as $key) { $zipped = []; foreach ($args as $arg) { $zipped[] = isset($arg[$key]) ? $arg[$key] : null; } $result[$key] = $zipped; } if ($callback !== null) { foreach ($result as $key => $column) { $result[$key] = $callback(...$column); } } return $result; }
/** * Iterates over a collection of elements, yielding each in turn to a callback function. Each invocation of $callback * is called with three arguments: (element, index, collection) * * @param Traversable|array $collection * @param callable $callback * @return null */ function each($collection, callable $callback) { InvalidArgumentException::assertCollection($collection, __FUNCTION__, 1); foreach ($collection as $index => $element) { $callback($element, $index, $collection); } }
/** * Recombines arrays by index and applies a callback optionally * * @param $args array|Traversable $collection One or more callbacks * @return array */ function zip($arg) { $args = func_get_args(); $callback = null; if (is_callable(end($args))) { $callback = array_pop($args); } foreach ($args as $position => $arg) { InvalidArgumentException::assertCollection($arg, __FUNCTION__, $position + 1); } $result = []; foreach ((array) reset($args) as $index => $value) { $zipped = []; foreach ($args as $arg) { $zipped[] = isset($arg[$index]) ? $arg[$index] : null; } if ($callback !== null) { /** @var callable $callback */ // $zipped = $callback(...$zipped); $zipped = call_user_func_array($callback, $zipped); } $result[] = $zipped; } return $result; }
/** * Iterates over a collection of elements, yielding each in turn to a callback function. Each invocation of $callback * is called with three arguments: (element, index, collection) * * @param Traversable|array $collection * @param callable $callback * @return null */ function each($collection, $callback) { InvalidArgumentException::assertCollection($collection, __FUNCTION__, 1); InvalidArgumentException::assertCallback($callback, __FUNCTION__, 2); foreach ($collection as $index => $element) { call_user_func($callback, $element, $index, $collection); } }
public function testHashIterator() { $flat = flat_map(new ArrayIterator(['ka' => 'a', 'kb' => ['b'], 'kc' => ['C' => 'c'], 'kd' => [['d']], 'ke' => null, null]), function ($v, $k, $collection) { InvalidArgumentException::assertCollection($collection, __FUNCTION__, 3); return $v; }); $this->assertSame(['a', 'b', 'c', ['d']], $flat); }
/** * Alias for Functional\first * * @param Traversable|array $collection * @param callable $callback * @return mixed */ function head($collection, $callback = null) { InvalidArgumentException::assertCollection($collection, __FUNCTION__, 1); if ($callback !== null) { InvalidArgumentException::assertCallback($callback, __FUNCTION__, 2); } return first($collection, $callback); }
public function testDuplicateKeys() { $fn = function ($v, $k, $collection) { InvalidArgumentException::assertCollection($collection, __FUNCTION__, 3); return $k[0]; }; $this->assertSame(['k' => 'val2'], reindex($this->hash, $fn)); }
/** * @param Traversable|array $collection * @param callable $callback * @param mixed $initial * @return array */ function reduce_left($collection, callable $callback, $initial = null) { InvalidArgumentException::assertCollection($collection, __FUNCTION__, 1); foreach ($collection as $index => $value) { $initial = $callback($value, $index, $collection, $initial); } return $initial; }
/** * Produces a new array of elements by mapping each element in collection through a transformation function (callback). * Callback arguments will be element, index, collection * * @param Traversable|array $collection * @param callable $callback * @return array */ function map($collection, callable $callback) { InvalidArgumentException::assertCollection($collection, __FUNCTION__, 1); $aggregation = []; foreach ($collection as $index => $element) { $aggregation[$index] = $callback($element, $index, $collection); } return $aggregation; }
/** * Takes a nested combination of collections and returns their contents as a single, flat array. * Does not preserve indexs. * * @param Traversable|array $collection * @return array */ function flatten($collection) { Exceptions\InvalidArgumentException::assertCollection($collection, __FUNCTION__, 1); $it = new RecursiveIteratorIterator(new RecursiveArrayIterator($collection)); $result = array(); foreach ($it as $val) { $result[] = $val; } return $result; }
/** * Returns true if all of the elements in the collection pass the callback falsy test. Opposite of Functional\all(). * Callback arguments will be element, index, collection. * * @param Traversable|array $collection * @param callable $callback * @return bool */ function none($collection, callable $callback) { InvalidArgumentException::assertCollection($collection, __FUNCTION__, 1); foreach ($collection as $index => $element) { if ($callback($element, $index, $collection)) { return false; } } return true; }
/** * Returns true if the collection contains the given value. If the third parameter is * true values will be compared in strict mode * * @param Traversable|array $collection * @param mixed $value * @param bool $strict * @return bool */ function contains($collection, $value, $strict = true) { InvalidArgumentException::assertCollection($collection, __FUNCTION__, 1); foreach ($collection as $element) { if ($value === $element || !$strict && $value == $element) { return true; } } return false; }
/** * Produces a new array of elements by mapping each element in collection through a transformation function (callback). * Callback arguments will be element, index, collection * * @param Traversable|array $collection * @param callable $callback * @return array */ function map($collection, $callback) { InvalidArgumentException::assertCollection($collection, __FUNCTION__, 1); InvalidArgumentException::assertCallback($callback, __FUNCTION__, 2); $aggregation = array(); foreach ($collection as $index => $element) { $aggregation[$index] = call_user_func($callback, $element, $index, $collection); } return $aggregation; }
/** * Partitions a collection by callback result. The truthy partition is the first one * (array index "0"), the falsy the second one (array index "1") * * @param Traversable|array $collection * @param callable $callback * @return array */ function partition($collection, callable $callback) { InvalidArgumentException::assertCollection($collection, __FUNCTION__, 1); $partitions = [0 => [], 1 => []]; foreach ($collection as $index => $element) { $partitionKey = $callback($element, $index, $collection) ? 0 : 1; $partitions[$partitionKey][$index] = $element; } return $partitions; }
/** * Returns true if all elements of the collection are strictly true * * @param Traversable|array $collection * @return bool */ function true($collection) { InvalidArgumentException::assertCollection($collection, __FUNCTION__, 1); foreach ($collection as $value) { if ($value !== true) { return false; } } return true; }
/** * Takes a collection and returns the quotient of all elements * * @param Traversable|array $collection * @param integer|float $initial * @return integer|float */ function ratio($collection, $initial = 1) { InvalidArgumentException::assertCollection($collection, __FUNCTION__, 1); $result = $initial; foreach ($collection as $value) { if (is_numeric($value)) { $result /= $value; } } return $result; }
function test() { $fn = function ($v, $k, $collection) { Exceptions\InvalidArgumentException::assertCollection($collection, __FUNCTION__, 1); return $v > 2; }; $this->assertSame(array(2 => 3, 3 => 4), tail($this->array, $fn)); $this->assertSame(array(2 => 3, 3 => 4), tail($this->iterator, $fn)); $this->assertSame(array(), tail($this->badArray, $fn)); $this->assertSame(array(), tail($this->badIterator, $fn)); }
function test() { $fn = function ($v, $k, $collection) { Exceptions\InvalidArgumentException::assertCollection($collection, __FUNCTION__, 3); return $k . $v; }; $this->assertSame(array('0value', '1value'), map($this->array, $fn)); $this->assertSame(array('0value', '1value'), map($this->iterator, $fn)); $this->assertSame(array('k1' => 'k1val1', 'k2' => 'k2val2'), map($this->hash, $fn)); $this->assertSame(array('k1' => 'k1val1', 'k2' => 'k2val2'), map($this->hashIterator, $fn)); }
public function test() { $fn = function ($v, $k, $collection) { InvalidArgumentException::assertCollection($collection, __FUNCTION__, 1); return $v == 'first' && $k == 0 || $v == 'third' && $k == 2; }; $this->assertSame('third', last($this->list, $fn)); $this->assertSame('third', last($this->listIterator, $fn)); $this->assertNull(last($this->badArray, $fn)); $this->assertNull(last($this->badIterator, $fn)); }
public function test() { $fn = function ($v, $k, $collection) { InvalidArgumentException::assertCollection($collection, __FUNCTION__, 3); return is_int($k) ? $k % 2 == 0 : $v[3] % 2 == 0 ? 'foo' : ''; }; $this->assertSame(['foo' => [0 => 'value1', 2 => 'value3'], '' => [1 => 'value2', 3 => 'value4']], group($this->list, $fn)); $this->assertSame(['foo' => [0 => 'value1', 2 => 'value3'], '' => [1 => 'value2', 3 => 'value4']], group($this->listIterator, $fn)); $this->assertSame(['' => ['k1' => 'val1', 'k3' => 'val3'], 'foo' => ['k2' => 'val2']], group($this->hash, $fn)); $this->assertSame(['' => ['k1' => 'val1', 'k3' => 'val3'], 'foo' => ['k2' => 'val2']], group($this->hashIterator, $fn)); }
/** * @dataProvider getAliases */ function test($functionName) { $callback = function ($v, $k, $collection) { Exceptions\InvalidArgumentException::assertCollection($collection, __FUNCTION__, 1); return $v == 'second' && $k == 1; }; $this->assertSame('second', $functionName($this->array, $callback)); $this->assertSame('second', $functionName($this->iterator, $callback)); $this->assertNull($functionName($this->badArray, $callback)); $this->assertNull($functionName($this->badIterator, $callback)); }
function test() { $fn = function ($v, $k, $collection) { Exceptions\InvalidArgumentException::assertCollection($collection, __FUNCTION__, 3); return $v == 'wrong' && strlen($k) > 0; }; $this->assertSame(array(0 => 'value', 2 => 'value'), reject($this->array, $fn)); $this->assertSame(array(0 => 'value', 2 => 'value'), reject($this->iterator, $fn)); $this->assertSame(array('k1' => 'value', 'k3' => 'value'), reject($this->hash, $fn)); $this->assertSame(array('k1' => 'value', 'k3' => 'value'), reject($this->hashIterator, $fn)); }
/** * Looks through each element in the collection, returning the last one that passes a truthy test (callback). * Callback arguments will be element, index, collection * * @param Traversable|array $collection * @param callable $callback * @return mixed */ function last($collection, callable $callback = null) { InvalidArgumentException::assertCollection($collection, __FUNCTION__, 1); $match = null; foreach ($collection as $index => $element) { if ($callback === null || $callback($element, $index, $collection)) { $match = $element; } } return $match; }
public function test() { $fn = function ($v, $k, $collection) { InvalidArgumentException::assertCollection($collection, __FUNCTION__, 3); return $v == 'wrong' && strlen($k) > 0; }; $this->assertSame([0 => 'value', 2 => 'value'], reject($this->list, $fn)); $this->assertSame([0 => 'value', 2 => 'value'], reject($this->listIterator, $fn)); $this->assertSame(['k1' => 'value', 'k3' => 'value'], reject($this->hash, $fn)); $this->assertSame(['k1' => 'value', 'k3' => 'value'], reject($this->hashIterator, $fn)); }
function test() { $fn = function ($v, $k, $collection) { Exceptions\InvalidArgumentException::assertCollection($collection, __FUNCTION__, 3); return is_int($k) ? $k % 2 == 0 : $v[3] % 2 == 0; }; $this->assertSame(array(array(0 => 'value1', 2 => 'value3'), array(1 => 'value2')), partition($this->array, $fn)); $this->assertSame(array(array(0 => 'value1', 2 => 'value3'), array(1 => 'value2')), partition($this->iterator, $fn)); $this->assertSame(array(array('k2' => 'val2'), array('k1' => 'val1', 'k3' => 'val3')), partition($this->hash, $fn)); $this->assertSame(array(array('k2' => 'val2'), array('k1' => 'val1', 'k3' => 'val3')), partition($this->hashIterator, $fn)); }
/** * @dataProvider getAliases */ function test($functionName) { $callback = function ($v, $k, $collection) { Exceptions\InvalidArgumentException::assertCollection($collection, __FUNCTION__, 3); return $v == 'value' && strlen($k) > 0; }; $this->assertSame(array('value', 2 => 'value'), $functionName($this->array, $callback)); $this->assertSame(array('value', 2 => 'value'), $functionName($this->iterator, $callback)); $this->assertSame(array('k1' => 'value', 'k3' => 'value'), $functionName($this->hash, $callback)); $this->assertSame(array('k1' => 'value', 'k3' => 'value'), $functionName($this->hashIterator, $callback)); }
/** * Returns true if every value in the collection passes the callback truthy test. Opposite of Functional\none(). * Callback arguments will be element, index, collection * * @param Traversable|array $collection * @param callable $callback * @return bool */ function every($collection, $callback) { InvalidArgumentException::assertCollection($collection, __FUNCTION__, 1); InvalidArgumentException::assertCallback($callback, __FUNCTION__, 2); foreach ($collection as $index => $element) { if (!call_user_func($callback, $element, $index, $collection)) { return false; } } return true; }
public function test() { $fn = function ($v, $k, $collection) { InvalidArgumentException::assertCollection($collection, __FUNCTION__, 3); return $k . $v; }; $this->assertSame(['0value', '1value'], map($this->list, $fn)); $this->assertSame(['0value', '1value'], map($this->listIterator, $fn)); $this->assertSame(['k1' => 'k1val1', 'k2' => 'k2val2'], map($this->hash, $fn)); $this->assertSame(['k1' => 'k1val1', 'k2' => 'k2val2'], map($this->hashIterator, $fn)); }
public function test() { $fn = function ($v, $k, $collection) { InvalidArgumentException::assertCollection($collection, __FUNCTION__, 1); return $v > 2; }; $this->assertSame([2 => 3, 3 => 4], tail($this->list, $fn)); $this->assertSame([2 => 3, 3 => 4], tail($this->listIterator, $fn)); $this->assertSame([], tail($this->badArray, $fn)); $this->assertSame([], tail($this->badIterator, $fn)); }
/** * @dataProvider getAliases */ public function test($functionName) { $callback = function ($v, $k, $collection) { InvalidArgumentException::assertCollection($collection, __FUNCTION__, 3); return $v == 'value' && strlen($k) > 0; }; $this->assertSame(['value', 2 => 'value'], $functionName($this->list, $callback)); $this->assertSame(['value', 2 => 'value'], $functionName($this->listIterator, $callback)); $this->assertSame(['k1' => 'value', 'k3' => 'value'], $functionName($this->hash, $callback)); $this->assertSame(['k1' => 'value', 'k3' => 'value'], $functionName($this->hashIterator, $callback)); }