Noz\Collection

Complexity

Total Complexity

120

Size/Duplication

Total Lines	1110
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

0%

Importance

Changes

0

73 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	14	3
A	__invoke()	0	20	1
A	setData()	0	5	1
A	getData()	0	4	1
A	count()	0	4	1
A	current()	0	4	1
A	key()	0	4	1
A	next()	0	9	2
A	rewind()	0	6	1
A	valid()	0	4	1
A	sort()	0	9	2
A	sortkeys()	0	9	2
A	has()	0	4	1
A	set()	0	6	1
A	delete()	0	6	1
A	indexOf()	0	9	3
A	keys()	0	4	1
A	values()	0	4	1
A	pad()	0	6	1
A	map()	0	9	2
A	transform()	0	6	1
A	each()	0	11	3
A	filter()	0	15	4
A	exclude()	0	16	4
B	first()	0	16	5
A	last()	0	8	1
A	reverse()	0	4	1
A	unique()	0	4	1
A	factory()	0	4	1
A	isNumeric()	0	9	3
A	hasOffset()	0	9	2
A	getOffsetKey()	0	13	3
A	getOffset()	0	4	1
A	pairs()	0	10	1
A	frequency()	0	12	2
A	add()	0	7	2
A	get()	0	8	2
A	retrieve()	0	7	2
A	prepend()	0	7	1
A	append()	0	7	1
A	chunk()	0	17	3
A	combine()	0	16	2
B	diff()	0	20	5
A	diffKeys()	0	9	1
A	nth()	0	6	1
A	except()	0	4	1
A	flip()	0	4	1
A	intersect()	0	9	1
A	intersectKeys()	0	9	1
A	isEmpty()	0	7	2
A	only()	0	4	1
A	pipe()	0	4	1
A	random()	0	4	1
A	indicesOf()	0	8	1
A	shuffle()	0	4	1
A	slice()	0	4	1
B	split()	0	34	5
A	union()	0	9	1
B	zip()	0	27	2
A	fold()	0	9	2
A	foldl()	0	4	1
A	all()	0	9	2
A	none()	0	9	2
A	increment()	0	6	1
A	decrement()	0	6	1
A	sum()	0	4	1
A	average()	0	4	1
A	mode()	0	8	2
A	median()	0	17	2
A	max()	0	4	1
A	min()	0	4	1
A	counts()	0	4	1
A	unserialize()	0	4	1

<?php
/*
 * Nozavroni/Collections
 * Just another collections library for PHP5.6+.
 *
 * @copyright Copyright (c) 2016 Luke Visinoni <luke.visinoni@gmail.com>
 * @author    Luke Visinoni <luke.visinoni@gmail.com>
 * @license   https://github.com/nozavroni/collections/blob/master/LICENSE The MIT License (MIT)
 */
namespace Noz;

use InvalidArgumentException;
use Noz\Immutable\Sequence;
use OutOfBoundsException;

use ArrayIterator;
use Countable;
use Iterator;
use ReflectionFunction;
use Traversable;

use Noz\Contracts\Arrayable;
use Noz\Contracts\Invokable;
use Noz\Contracts\CollectionInterface;

use Noz\Traits\IsArrayable;
use Noz\Traits\IsContainer;
use Noz\Traits\IsSerializable;

use function
    Noz\is_traversable,
    Noz\typeof,
    Noz\collect,
    Noz\is_arrayable,
    Noz\to_array,
    Noz\traversable_to_array,
    Noz\normalize_offset;

/**
 * Class Collection.
 *
 * This is the abstract class that all other collection classes are based on.
 * Although it's possible to use a completely custom Collection class by simply
 * implementing the "Collectable" interface, extending this class gives you a
 * whole slew of convenient methods for free.
 *
 * @package Noz\Immutable
 *
 * @author Luke Visinoni <luke.visinoni@gmail.com>
 * @copyright Copyright (c) 2016 Luke Visinoni <luke.visinoni@gmail.com>
 *
 * @todo Implement Serializable, other Interfaces
 */
class Collection implements
    CollectionInterface,
    Arrayable,
    Invokable,
    Countable,
    Iterator
{
    use IsArrayable,
        IsContainer,
        IsSerializable;

    /**
     * @var array The collection of data this object represents
     */
    private $data = [];

    /**
     * @var bool True unless we have advanced past the end of the data array
     */
    protected $isValid = true;

    /**
     * AbstractCollection constructor.
     *
     * @param mixed $data The data to wrap
     */
    public function __construct($data = null)
    {
        if (is_null($data)) {
            $data = [];
        }
        if (!is_traversable($data)) {
            throw new InvalidArgumentException(sprintf(
                'Invalid input for %s. Expecting traversable data, got "%s".',
                __METHOD__,
                typeof($data)
            ));
        }
        $this->setData($data);
    }

    public function __invoke()
    {
//        $args = collect(func_get_args());

57% of this comment could be valid code. Did you maybe forget this after debugging?

//        if ($args->hasOffset(0)) {
//            if ($args->hasOffset(1)) {
//                // two args only...
//                return $this->set($args->getOffset(0), $args->getOffset(1));
//            }
//            // one arg only...
//            $arg1 = $args->getOffset(0);
//            if (is_scalar($arg1)) {
//                return $this->get($arg1);
//            }
//            if (is_traversable($arg1)) {
//                return $this->union($arg1);
//            }
//            // @todo Should probably throw ane invalid arg exception here...
//        }
        return $this->toArray();
    }

    /**
     * Set underlying data array.
     *
     * Sets the collection data. This method should NEVER be called anywhere other than in __construct().
     *
     * @param array|Traversable $data The data to wrap
     */
    private function setData($data)
    {
        $this->data = traversable_to_array($data);
        $this->rewind();
    }

    /**
     * Get copy of underlying data array.
     *
     * Returns a copy of this collection's underlying data array. It returns a copy because collections are supposed to
     * be immutable. Nothing outside of the constructor should ever have direct access to the actual underlying array.
     *
     * @return array
     */
    protected function getData()
    {
        return $this->data;
    }

    /**
     * @inheritDoc
     */
    public function count()
    {
        return count($this->getData());
    }

    /**
     * Return the current element.
     *
     * Returns the current element in the collection. The internal array pointer
     * of the data array wrapped by the collection should not be advanced by this
     * method. No side effects. Return current element only.
     *
     * @return mixed
     */
    public function current()
    {
        return current($this->data);
    }

    /**
     * Return the current key.
     *
     * Returns the current key in the collection. No side effects.
     *
     * @return mixed
     */
    public function key()
    {
        return key($this->data);
    }

    /**
     * Advance the internal pointer forward.
     *
     * Although this method will return the current value after advancing the
     * pointer, you should not expect it to. The interface does not require it
     * to return any value at all.
     *
     * @return mixed
     */
    public function next()
    {
        $next = next($this->data);
        $key  = key($this->data);
        if (isset($key)) {
            return $next;
        }
        $this->isValid = false;
    }

    /**
     * Rewind the internal pointer.
     *
     * Return the internal pointer to the first element in the collection. Again,
     * this method is not required to return anything by its interface, so you
     * should not count on a return value.
     *
     * @return mixed
     */
    public function rewind()
    {
        $this->isValid = !empty($this->data);

        return reset($this->data);
    }

    /**
     * Is internal pointer in a valid position?
     *
     * If the internal pointer is advanced beyond the end of the collection, this method will return false.
     *
     * @return bool True if internal pointer isn't past the end
     */
    public function valid()
    {
        return $this->isValid;
    }

    /**
     * @inheritDoc
     */
    public function sort($alg = null)
    {
        if (is_null($alg)) {
            $alg = 'strnatcasecmp';
        }
        uasort($this->data, $alg);

        return $this;
    }

    /**
     * @inheritDoc
     */
    public function sortkeys($alg = null)
    {
        if (is_null($alg)) {
            $alg = 'strnatcasecmp';
        }
        uksort($this->data, $alg);

        return $this;
    }

    /**
     * Does this collection have a value at given index?
     *
     * @param mixed $index The index to check
     *
     * @return bool
     */
    public function has($index)
    {
        return array_key_exists($index, $this->getData());
    }

    /**
     * Set value at given index.
     *
     * This method simulates setting a value in this collection, but because collections are immutable, it actually
     * returns a copy of this collection with the value in the new collection set to specified value.
     *
     * @param mixed $index The index to set a value at
     * @param mixed $val   The value to set $index to
     *
     * @return $this
     */
    public function set($index, $val)
    {
        $this->data[$index] = $val;

        return $this;
    }

    /**
     * Unset (delete) value at the given index.
     *
     * Get copy of collection with given index removed.
     *
     * @param mixed $index The index to unset
     *
     * @return Collection
     */
    public function delete($index)
    {
        unset($this->data[$index]);

        return $this;
    }

    /**
     * Get index of a value.
     *
     * Given a value, this method will return the index of the first occurrence of that value.
     *
     * @param mixed $value Value to get the index of
     *
     * @return int|null|string
     */
    public function indexOf($value)
    {
        return $this->fold(function($carry, $val, $key) use ($value) {
            if (is_null($carry) && $val == $value) {
                return $key;
            }
            return $carry;
        });
    }

    /**
     * Get this collection's keys as a collection.
     *
     * @return Collection Containing this collection's keys
     */
    public function keys()
    {
        return static::factory(array_keys($this->getData()));
    }

    /**
     * Get this collection's values as a collection.
     *
     * This method returns this collection's values but completely re-indexed (numerically).
     *
     * @return Collection Containing this collection's values
     */
    public function values()
    {
        return static::factory(array_values($this->getData()));
    }

    /**
     * Pad collection to a certain size.
     *
     * Returns a new collection, padded to the given size, with the given value.
     *
     * @param int   $size The number of items that should be in the collection
     * @param mixed $with The value to pad the collection with
     *
     * @return Collection A new collection padded to specified length
     */
    public function pad($size, $with = null)
    {
        $this->data = array_pad($this->data, $size, $with);

        return $this;
    }

    /**
     * Apply a callback to each item in collection.
     *
     * Applies a callback to each item in collection and returns a new collection
     * containing each iteration's return value.
     *
     * @param callable $mapper The callback to apply
     *
     * @return Collection A new collection with callback return values
     */
    public function map(callable $mapper)
    {
        $iter = 0;
        $transform = [];
        foreach ($this as $key => $val) {
            $transform[$key] = $mapper($val, $key, $iter++);
        }
        return static::factory($transform);
    }

    /**
     * Like map, except done in-place.
     *
     * @param callable $transformer A transformer callback
     *
     * @return $this
     */
    public function transform(callable $transformer)
    {
        $this->data = $this->map($transformer);

It seems like $this->map($transformer) of type object<Noz\Collection> is incompatible with the declared type array of property $data.

        return $this;
    }

    /**
     * Iterate over each item in the collection, calling $callback on it. Return false to stop iterating.
     *
     * @param callable    $callback A callback to use
     *
     * @return $this
     */
    public function each(callable $callback)
    {
        $iter = 0;
        foreach ($this as $key => $val) {
            if (!$callback($val, $key, $iter++)) {
                break;
            }
        }

        return $this;
    }

    /**
     * Filter the collection.
     *
     * Using a callback function, this method will filter out unwanted values, returning
     * a new collection containing only the values that weren't filtered.
     *
     * @param callable $predicate The callback function used to filter

Should the type for parameter $predicate not be null|callable? Also, consider making the array more specific, something like array<String>, or String[].

     *
     * @return Collection A new collection with only values that weren't filtered
     */
    public function filter(callable $predicate = null)
    {
        if (is_null($predicate)) {
            $filtered = array_filter($this->data);
        } else {
            $iter     = 0;
            $filtered = [];
            foreach($this as $key => $val) {
                if ($predicate($val, $key, $iter++)) {
                    $filtered[$key] = $val;
                }
            }
        }
        return static::factory($filtered);
    }

    /**
     * Filter the collection.
     *
     * Using a callback function, this method will filter out unwanted values, returning
     * a new collection containing only the values that weren't filtered.
     *
     * @param callable $predicate The callback function used to filter

Should the type for parameter $predicate not be null|callable? Also, consider making the array more specific, something like array<String>, or String[].

     *
     * @return Collection A new collection with only values that weren't filtered
     */
    public function exclude(callable $predicate = null)
    {
        if (is_null($predicate)) {
            $predicate = function($val) {
                return (bool) $val != false;

It seems like you are loosely comparing two booleans. Considering using the strict comparison !== instead.

            };
        }
        $iter = 0;
        $excluded = [];
        foreach ($this as $key => $val) {
            if (!$predicate($val, $key, $iter++)) {
                $excluded[$key] = $val;
            }
        }
        return static::factory($excluded);
    }

    /**
     * Return the first item that meets given criteria.
     *
     * Using a callback function, this method will return the first item in the collection
     * that causes the callback function to return true.
     *
     * @param callable|null $predicate The callback function
     * @param mixed|null    $default   The default return value
     *
     * @return mixed
     */
    public function first(callable $predicate = null, $default = null)
    {
        if (is_null($predicate)) {
            if ($this->hasOffset(0)) {
                return $this->getOffset(0);
            }
        } else {
            foreach($this as $index => $value) {
                if ($predicate($value, $index)) {
                    return $value;
                }
            }
        }

        return $default;
    }

    /**
     * Return the last item that meets given criteria.
     *
     * Using a callback func`tion, this method will return the last item in the collection
     * that causes the callback function to return true.
     *
     * @param callable|null $callback The callback function
     * @param mixed|null    $default  The default return value
     *
     * @return mixed
     */
    public function last(callable $callback = null, $default = null)
    {
        $reverse = $this->reverse();
//        if (is_null($callback)) {

60% of this comment could be valid code. Did you maybe forget this after debugging?

//            return $reverse->getOffset(0);
//        }
        return $reverse->first($callback, $default);
    }

    /**
     * Returns collection in reverse order.
     *
     * @return Collection This collection in reverse order.
     */
    public function reverse()
    {
        return static::factory(array_reverse($this->getData(), true));
    }

    /**
     * Get unique items.
     *
     * Returns a collection of all the unique items in this collection.
     *
     * @return Collection This collection with duplicate items removed
     */
    public function unique()
    {
        return static::factory(array_unique($this->getData()));
    }

    /**
     * Collection factory method.
     *
     * This method will analyze input data and determine the most appropriate Collection
     * class to use. It will then instantiate said Collection class with the given
     * data and return it.
     *
     * @param mixed $data The data to wrap
     *
     * @return Collection A collection containing $data
     */
    public static function factory($data = null)
    {
        return new Collection($data);
    }

    /**
     * Determine if structure contains all numeric values.
     *
     * @return bool
     */
    public function isNumeric()
    {
        foreach ($this as $val) {
            if (!is_numeric($val)) {
                return false;
            }
        }
        return true;
    }

    /**
     * @inheritdoc
     */
    public function hasOffset($offset)
    {
        try {
            $this->getOffsetKey($offset);
            return true;
        } catch (OutOfBoundsException $e) {
            return false;
        }
    }

    /**
     * @inheritdoc
     */
    public function getOffsetKey($offset)
    {
        $offset = normalize_offset($offset, $this);

$this is of type this<Noz\Collection>, but the function expects a integer|array|object<Noz\traversable>|null.

        if (!is_null($key = $this->fold(function($carry, $val, $key, $iter) use ($offset) {
            if ($iter++ === $offset) {
                return $key;
            }
            return $carry;
        }))) {
            return $key;
        }
        throw new OutOfBoundsException("Offset does not exist: $offset");
    }

    /**
     * @inheritdoc
     */
    public function getOffset($offset)
    {
        return $this->retrieve($this->getOffsetKey($offset));
    }

    /**
     * Get each key/value as an array pair.
     *
     * Returns a collection of arrays where each item in the collection is [key,value]
     *
     * @return Collection
     */
    public function pairs()
    {
        return static::factory(array_map(
            function ($key, $val) {
                return [$key, $val];
            },
            array_keys($this->getData()),
            array_values($this->getData())
        ));
    }

    // END Iterator methods

    /**
     * Counts how many times each value occurs in a collection.
     *
     * Returns a new collection with values as keys and how many times that
     * value appears in the collection. Works best with scalar values but will
     * attempt to work on collections of objects as well.
     *
     * @return Collection
     */
    public function frequency()
    {
        return static::factory($this->fold(
            function($carry, $val, $key, $iter) {

The parameter $key is not used and could be removed.

The parameter $iter is not used and could be removed.

                if (!isset($carry[$val])) {
                    $carry[$val] = 0;
                }
                $carry[$val]++;
                return $carry;
            }
        ), []);

The call to Collection::factory() has too many arguments starting with array().

    }

    /**
     * @inheritDoc
     */
    public function add($index, $value)
    {
        if (!$this->has($index)) {
            return $this->set($index, $value);
        }
        return static::factory($this);
    }

    /**
     * @inheritdoc
     * @todo Maybe read would be a better name for this?
     */
    public function get($index, $default = null)
    {
        try {
            return $this->retrieve($index);
        } catch (OutOfBoundsException $e) {
            return $default;
        }
    }

    /**
     * @inheritdoc
     * @todo Maybe read would be a better name for this?
     */
    public function retrieve($index)
    {
        if (!$this->has($index)) {
            throw new OutOfBoundsException(__CLASS__ . ' could not retrieve value at index ' . $index);
        }
        return $this->getData()[$index];
    }

    /**
     * @inheritDoc
     */
    public function prepend($item)
    {
        $data = $this->getData();
        array_unshift($data, $item);

        return static::factory($data);
    }

    /**
     * @inheritDoc
     */
    public function append($item)
    {
        $data = $this->getData();
        array_push($data, $item);

        return static::factory($data);
    }

    /**
     * @inheritDoc
     */
    public function chunk($size)
    {
        return static::factory($this->fold(function($chunks, $val, $key, $iter) use ($size) {
            if (is_null($chunks)) {
                $chunks = [];
            }
            if ($iter % $size == 0) {
                // start new chunk
                array_push($chunks, []);
            }
            $chunk = array_pop($chunks);
            array_push($chunk, $val);
            array_push($chunks, $chunk);

            return $chunks;
        }));
    }

    public function combine($values)
    {
        if (!is_traversable($values)) {
            throw new InvalidArgumentException(sprintf(
                'Expecting traversable data for %s but got %s.',
                __METHOD__,
                typeof($values)
            ));
        }
        return static::factory(
            array_combine(
                $this->keys()->toArray(),
                with(new Collection($values))->values()->toArray()
            )
        );
    }

    /**
     * @inheritDoc
     */
    public function diff($data, callable $equals = null)
    {
        $diff = [];
        $orig = $this->getData();
        $cmpr = to_array($data);

        if (is_null ($equals)) {
            $equals = function($a, $b) {
                return $a == $b;
            };
        }
        foreach ($orig as $key => $val) {
            foreach ($cmpr as $cmpKey => $cmpVal) {
                if (!$equals($val, $cmpVal)) {
                    $diff[$cmpKey] = $cmpVal;
                }
            }
        }
        return $diff;
    }

    /**
     * @inheritDoc
     */
    public function diffKeys($data, callable $equals = null)
    {
        return static::factory(
            array_diff_key(
                $this->getData(),
                to_array($data)
            )
        );
    }

    /**
     * @inheritDoc
     */
    public function nth($nth, $offset = null)
    {
        return $this->slice($offset)->filter(function($val, $key, $iter) use ($nth) {
            return $iter % $nth == 0;
        });
    }

    /**
     * @inheritDoc
     */
    public function except($indexes)
    {
        return $this->diffKeys(static::factory($indexes)->flip());
    }

    /**
     * @inheritDoc
     */
    public function flip()
    {
        return static::factory(array_flip($this->getData()));
    }

    /**
     * @inheritDoc
     */
    public function intersect($data)
    {
        return static::factory(
            array_intersect(
                $this->toArray(),
                collect($data)->toArray()

It seems like $data defined by parameter $data on line 802 can also be of type object<Noz\Contracts\CollectionInterface>; however, Noz\collect() does only seem to accept array|object<Iterator>|null, maybe add an additional type check?

            )
        );
    }

    /**
     * @inheritDoc
     */
    public function intersectKeys($data)
    {
        return static::factory(
            array_intersect_key(
                $this->toArray(),
                collect($data)->toArray()

It seems like $data defined by parameter $data on line 815 can also be of type object<Noz\Contracts\CollectionInterface>; however, Noz\collect() does only seem to accept array|object<Iterator>|null, maybe add an additional type check?

            )
        );
    }

    /**
     * @inheritDoc
     */
    public function isEmpty(callable $callback = null)
    {
        if (!is_null($callback)) {
            return $this->all($callback);
        }
        return empty($this->getData());
    }

    /**
     * @inheritDoc
     */
    public function only($indices)
    {
        return $this->intersectKeys(static::factory($indices)->flip()->toArray());
    }

    /**
     * @inheritDoc
     */
    public function pipe(callable $callback)
    {
        return $callback($this);
    }

    /**
     * @inheritDoc
     */
    public function random($num)
    {
        return $this->shuffle()->slice(0, $num);
    }

    /**
     * @inheritDoc
     */
    public function indicesOf($value)
    {
        return $this->filter(function($val) use ($value) {
            return $val == $value;
        })->map(function($val, $key) {
            return $key;
        });
    }

    /**
     * @inheritDoc
     */
    public function shuffle()
    {
        return static::factory(shuffle($this->getData()));

$this->getData() cannot be passed to shuffle() as the parameter $array expects a reference.

    }

    /**
     * @inheritDoc
     */
    public function slice($offset, $length = null)
    {
        return static::factory(array_slice($this->getData(), $offset, $length, true));
    }

    /**
     * @inheritDoc
     */
    public function split($num)
    {
        $count = $this->count();
        $size = (int)($count / $num);
        $mod = $count % $num;
        return static::factory($this->fold(function($chunks, $val, $key, $iter) use ($num, $size, $mod) {

The parameter $key is not used and could be removed.

The parameter $iter is not used and could be removed.

            $chunk_count = count($chunks);
            if ($chunk_count <= $mod) {
                $size++;
            }
            if (is_null($chunks)) {
                // create initial chunks array...
                $chunks = [[]];
            }

            // grab the most recent chunk
            $chunk = array_pop($chunks);

            if (count($chunk) < $size) {
                // if chunk is less than the expected size, add value to it
                array_push($chunk, $val);
                array_push($chunks, $chunk);
            } else {
                // otherwise, add the chunk back and add the value to a new chunk
                array_push($chunks, $chunk);
                if ($chunk_count <= $num) {
                    $chunk = [$val];
                }
                array_push($chunks, $chunk);
            }

            return $chunks;
        }));
    }

    /**
     * @inheritDoc
     */
    public function union($data)
    {
        return static::factory(
            array_merge(
                $this->getData(),
                collect($data)->toArray()

It seems like $data defined by parameter $data on line 929 can also be of type object<Noz\Contracts\CollectionInterface>; however, Noz\collect() does only seem to accept array|object<Iterator>|null, maybe add an additional type check?

            )
        );
    }

    /**
     * @inheritDoc
     */
    public function zip(...$data)
    {
        /** @var CollectionInterface $args The function arguments TODO: Change this to SequenceInterface when you have that interface. */

This line exceeds maximum limit of 120 characters; contains 137 characters

        $args = new Sequence(func_get_args());
        $args->map(function($val) {
            if (is_arrayable($val)) {
                return to_array($val);
            } else {
                // @todo throw exception?
                return [];
            }
        });
        $args = $args->prepend($this->getData())
                     ->prepend(null);

        return static::factory(
//            array_map(

50% of this comment could be valid code. Did you maybe forget this after debugging?

//                null,
//                $this->getData(),
//                ...$data
//            )
            call_user_func_array(
                'array_map',
                $args->toArray()
            )
        );
    }

    /**
     * @inheritDoc
     */
    public function fold(callable $callback, $initial = null)
    {
        $iter = 0;
        $carry = $initial;
        foreach ($this as $key => $val) {
            $carry = $callback($carry, $val, $key, $iter++);
        }
        return $carry;
    }

    /**
     * @inheritDoc
     */
    public function foldl(callable $callback, $initial = null)
    {
        return $this->reverse()->fold($callback, $initial);
    }

    /**
     * @inheritDoc
     */
    public function all(callable $callback = null)
    {
        if (is_null($callback)) {
            $callback = function($val) {
                return (bool) $val;
            };
        }
        return $this->filter($callback)->isEmpty();
    }

    /**
     * @inheritDoc
     */
    public function none(callable $callback = null)
    {
        if (is_null($callback)) {
            $callback = function($val) {
                return (bool) $val;
            };
        }
        return $this->filter($callback)->isEmpty();
    }

    // BEGIN Numeric Collection Methods
    // These methods only really work on numeric data.

    /**
     * Increment an item.
     *
     * Increment the item specified by $key by one value. Intended for integers
     * but also works (using this term loosely) for letters. Any other data type
     * it may modify is unintended behavior at best.
     *
     * This method modifies its internal data array rather than returning a new
     * collection.
     *
     * @param mixed $index    The key of the item you want to increment.
     * @param int   $interval The interval that $key should be incremented by
     *
     * @return Collection
     */
    public function increment($index, $interval = 1)
    {
        $val = $this->retrieve($index);
        $val += $interval;
        return $this->set($index, $val);
    }

    /**
     * Decrement an item.
     *
     * Frcrement the item specified by $key by one value. Intended for integers.
     * Does not work for letters and if it does anything to anything else, it's
     * unintended at best.
     *
     * This method modifies its internal data array rather than returning a new
     * collection.
     *
     * @param mixed $index      The key of the item you want to decrement.
     * @param int   $interval The interval that $key should be decremented by
     *
     * @return Collection
     */
    public function decrement($index, $interval = 1)
    {
        $val = $this->retrieve($index);
        $val -= $interval;
        return $this->set($index, $val);
    }

    /**
     * Get the sum.
     *
     * @return int|float The sum of all values in collection
     */
    public function sum()
    {
        return array_sum($this->toArray());
    }

    /**
     * Get the average.
     *
     * @return float|int The average value from the collection
     */
    public function average()
    {
        return $this->sum() / $this->count();
    }

    /**
     * Get the mode.
     *
     * @return float|int The mode
     */
    public function mode()
    {
        $counts = $this->counts()->toArray();
        arsort($counts);
        $mode = key($counts);

        return (strpos($mode, '.')) ? floatval($mode) : intval($mode);
    }

    /**
     * Get the median value.
     *
     * @return float|int The median value
     */
    public function median()
    {
        $count = $this->count();
        $data  = $this->toArray();
        natcasesort($data);
        $middle = $count / 2;
        $values = array_values($data);
        if ($count % 2 == 0) {
            // even number, use middle
            $low  = $values[$middle - 1];
            $high = $values[$middle];

            return ($low + $high) / 2;
        }
        // odd number return median
        return $values[$middle];
    }

    /**
     * Get the maximum value.
     *
     * @return mixed The maximum
     */
    public function max()
    {
        return max($this->getData());
    }

    /**
     * Get the minimum value.
     *
     * @return mixed The minimum
     */
    public function min()
    {
        return min($this->getData());
    }

    /**
     * Get the number of times each item occurs in the collection.

     * This method will return a NumericCollection where keys are the
     * values and values are the number of times that value occurs in
     * the original collection.

     * @return Collection
     */
    public function counts()
    {
        return static::factory(array_count_values($this->toArray()));
    }

    /**
     * @param $serialized
     */
    public function unserialize($serialized)
    {
        $this->setData(unserialize($serialized));
    }

}