<form method="POST">
    <h3>Editing: AbstractCollection.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

/**
 * This file is part of the ramsey/collection library
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * @copyright Copyright (c) Ben Ramsey &lt;ben@benramsey.com&gt;
 * @license http://opensource.org/licenses/MIT MIT
 */

declare(strict_types=1);

namespace Ramsey\Collection;

use Closure;
use Ramsey\Collection\Exception\CollectionMismatchException;
use Ramsey\Collection\Exception\InvalidArgumentException;
use Ramsey\Collection\Exception\InvalidSortOrderException;
use Ramsey\Collection\Exception\OutOfBoundsException;
use Ramsey\Collection\Tool\TypeTrait;
use Ramsey\Collection\Tool\ValueExtractorTrait;
use Ramsey\Collection\Tool\ValueToStringTrait;

use function array_filter;
use function array_map;
use function array_merge;
use function array_search;
use function array_udiff;
use function array_uintersect;
use function current;
use function end;
use function in_array;
use function is_int;
use function is_object;
use function reset;
use function spl_object_id;
use function sprintf;
use function unserialize;
use function usort;

/**
 * This class provides a basic implementation of `CollectionInterface`, to
 * minimize the effort required to implement this interface
 *
 * @template T
 * @extends AbstractArray&lt;T&gt;
 * @implements CollectionInterface&lt;T&gt;
 */
abstract class AbstractCollection extends AbstractArray implements CollectionInterface
{
    use TypeTrait;
    use ValueToStringTrait;
    use ValueExtractorTrait;

    /**
     * @inheritDoc
     */
    public function add($element): bool
    {
        $this[] = $element;

        return true;
    }

    /**
     * @inheritDoc
     */
    public function contains($element, bool $strict = true): bool
    {
        return in_array($element, $this-&gt;data, $strict);
    }

    /**
     * @inheritDoc
     */
    public function offsetSet($offset, $value): void
    {
        if ($this-&gt;checkType($this-&gt;getType(), $value) === false) {
            throw new InvalidArgumentException(
                'Value must be of type ' . $this-&gt;getType() . '; value is '
                . $this-&gt;toolValueToString($value),
            );
        }

        if ($offset === null) {
            $this-&gt;data[] = $value;
        } else {
            $this-&gt;data[$offset] = $value;
        }
    }

    /**
     * @inheritDoc
     */
    public function remove($element): bool
    {
        if (($position = array_search($element, $this-&gt;data, true)) !== false) {
            unset($this[$position]);

            return true;
        }

        return false;
    }

    /**
     * @inheritDoc
     */
    public function column(string $propertyOrMethod): array
    {
        $temp = [];

        foreach ($this-&gt;data as $item) {
            /** @var mixed $value */
            $value = $this-&gt;extractValue($item, $propertyOrMethod);

            /** @psalm-suppress MixedAssignment */
            $temp[] = $value;
        }

        return $temp;
    }

    /**
     * @inheritDoc
     */
    public function first()
    {
        if ($this-&gt;isEmpty()) {
            throw new OutOfBoundsException('Can\'t determine first item. Collection is empty');
        }

        reset($this-&gt;data);

        /** @var T $first */
        $first = current($this-&gt;data);

        return $first;
    }

    /**
     * @inheritDoc
     */
    public function last()
    {
        if ($this-&gt;isEmpty()) {
            throw new OutOfBoundsException('Can\'t determine last item. Collection is empty');
        }

        /** @var T $item */
        $item = end($this-&gt;data);
        reset($this-&gt;data);

        return $item;
    }

    public function sort(string $propertyOrMethod, string $order = self::SORT_ASC): CollectionInterface
    {
        if (!in_array($order, [self::SORT_ASC, self::SORT_DESC], true)) {
            throw new InvalidSortOrderException('Invalid sort order given: ' . $order);
        }

        $collection = clone $this;

        usort(
            $collection-&gt;data,
            /**
             * @param T $a
             * @param T $b
             */
            function ($a, $b) use ($propertyOrMethod, $order): int {
                /** @var mixed $aValue */
                $aValue = $this-&gt;extractValue($a, $propertyOrMethod);

                /** @var mixed $bValue */
                $bValue = $this-&gt;extractValue($b, $propertyOrMethod);

                return ($aValue &lt;=&gt; $bValue) * ($order === self::SORT_DESC ? -1 : 1);
            },
        );

        return $collection;
    }

    public function filter(callable $callback): CollectionInterface
    {
        $collection = clone $this;
        $collection-&gt;data = array_merge([], array_filter($collection-&gt;data, $callback));

        return $collection;
    }

    /**
     * {@inheritdoc}
     */
    public function where(string $propertyOrMethod, $value): CollectionInterface
    {
        return $this-&gt;filter(function ($item) use ($propertyOrMethod, $value) {
            /** @var mixed $accessorValue */
            $accessorValue = $this-&gt;extractValue($item, $propertyOrMethod);

            return $accessorValue === $value;
        });
    }

    public function map(callable $callback): CollectionInterface
    {
        return new Collection('mixed', array_map($callback, $this-&gt;data));
    }

    public function diff(CollectionInterface $other): CollectionInterface
    {
        $this-&gt;compareCollectionTypes($other);

        $diffAtoB = array_udiff($this-&gt;data, $other-&gt;toArray(), $this-&gt;getComparator());
        $diffBtoA = array_udiff($other-&gt;toArray(), $this-&gt;data, $this-&gt;getComparator());

        /** @var array&lt;array-key, T&gt; $diff */
        $diff = array_merge($diffAtoB, $diffBtoA);

        $collection = clone $this;
        $collection-&gt;data = $diff;

        return $collection;
    }

    public function intersect(CollectionInterface $other): CollectionInterface
    {
        $this-&gt;compareCollectionTypes($other);

        /** @var array&lt;array-key, T&gt; $intersect */
        $intersect = array_uintersect($this-&gt;data, $other-&gt;toArray(), $this-&gt;getComparator());

        $collection = clone $this;
        $collection-&gt;data = $intersect;

        return $collection;
    }

    public function merge(CollectionInterface ...$collections): CollectionInterface
    {
        $mergedCollection = clone $this;

        foreach ($collections as $index =&gt; $collection) {
            if (!$collection instanceof static) {
                throw new CollectionMismatchException(
                    sprintf('Collection with index %d must be of type %s', $index, static::class),
                );
            }

            // When using generics (Collection.php, Set.php, etc),
            // we also need to make sure that the internal types match each other
            if ($this-&gt;getUniformType($collection) !== $this-&gt;getUniformType($this)) {
                throw new CollectionMismatchException(
                    sprintf(
                        'Collection items in collection with index %d must be of type %s',
                        $index,
                        $this-&gt;getType(),
                    ),
                );
            }

            foreach ($collection as $key =&gt; $value) {
                if (is_int($key)) {
                    $mergedCollection[] = $value;
                } else {
                    $mergedCollection[$key] = $value;
                }
            }
        }

        return $mergedCollection;
    }

    /**
     * @inheritDoc
     */
    public function unserialize($serialized): void
    {
        /** @var array&lt;array-key, T&gt; $data */
        $data = unserialize($serialized, ['allowed_classes' =&gt; [$this-&gt;getType()]]);

        $this-&gt;data = $data;
    }

    /**
     * @param CollectionInterface&lt;T&gt; $other
     */
    private function compareCollectionTypes(CollectionInterface $other): void
    {
        if (!$other instanceof static) {
            throw new CollectionMismatchException('Collection must be of type ' . static::class);
        }

        // When using generics (Collection.php, Set.php, etc),
        // we also need to make sure that the internal types match each other
        if ($this-&gt;getUniformType($other) !== $this-&gt;getUniformType($this)) {
            throw new CollectionMismatchException('Collection items must be of type ' . $this-&gt;getType());
        }
    }

    private function getComparator(): Closure
    {
        return /**
             * @param T $a
             * @param T $b
             */
            function ($a, $b): int {
                // If the two values are object, we convert them to unique scalars.
                // If the collection contains mixed values (unlikely) where some are objects
                // and some are not, we leave them as they are.
                // The comparator should still work and the result of $a &lt; $b should
                // be consistent but unpredictable since not documented.
                if (is_object($a) &amp;&amp; is_object($b)) {
                    $a = spl_object_id($a);
                    $b = spl_object_id($b);
                }

                return $a === $b ? 0 : ($a &lt; $b ? 1 : -1);
            };
    }

    /**
     * @param CollectionInterface&lt;mixed&gt; $collection
     */
    private function getUniformType(CollectionInterface $collection): string
    {
        switch ($collection-&gt;getType()) {
            case 'integer':
                return 'int';
            case 'boolean':
                return 'bool';
            case 'double':
                return 'float';
            default:
                return $collection-&gt;getType();
        }
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>