Add support for strongly typed collections

[jcviljoen]

I have an idea to introduce type specific collections in Laravel. This is a simple idea that I feel can really have a lot of applications, but since I haven't contributed before I'd love to get some feedback first 🙏.

Essentially, I'm looking to introduce a new TypeCollection (name pending) which extends the base Collection class and checks to make sure all items are of the correct type. This is useful because (especially from a reviewer's perspective) you don't have to guess what might be inside the collection.

One very simple use case to demonstrate this is to consider a collection of enums:

public function checkEnums(Collection $enums): void {}

Does this contain only the enum values (strings / integers etc), or is an instantiated enum object?
When using the function you can likely pass in either one, but it could likely cause unexpected errors.

This would act similar to how we can extend Eloquent collections for models, except it would actually validate that the items adhere to a class type.

The class that I'm proposing would look something like this:

<?php

namespace Illuminate\Support;

use Illuminate\Support\Collection as BaseCollection;

class TypeCollection extends BaseCollection
{
    protected string $class;

    public function __construct(string $class, array $items = [])
    {
        $this->class = $class;

        $items = $this->sanitiseItems($items);

        parent::__construct($items);
    }

    protected function sanitiseItems(array $items): array
    {
        $objects = [];

        foreach ($items as $key => $value) {
            if ($value instanceof $this->class) {
                $objects[$key] = $value;

                continue;
            }

            throw new \Exception("$value is not an instance of $this->class");
        }

        return $objects;
    }
}

Once you then fit this to your custom class, it will allow us to build strongly typed collections that can be passed as function arguments. You always know what you are working with, and even simpler to review.

There are various enum packages that we use together with Laravel as well, and we can help support those packages with a dedicated enum collection as well:

<?php

namespace Illuminate\Support\Collections;

class EnumCollection extends TypedCollection
{
    protected function sanitiseItems(array $items, string $enumClass): array
    {
        $enums = [];

        foreach ($items as $key => $value) {
            $enums[$key] = $value instanceof $enumClass
                ? $value
                : new $enumClass($value);
        }

        return $enums;
    }
}

This could even potentially be used with Laravel's model attribute casting (but that's possible future implementations that extend beyond what I'm currently proposing).

I know this may seem rather simple, but I'd love to hear some of your opinions, improvements, or if this even makes sense at all to add.
I'd also love to help by adding the code myself 🙌 .

[henzeb]

There are a lot of packages doing that. Including mine. https://packagist.org/packages/henzeb/laravel-typed-collection

Oh, and someone is making steps with it. Currently it's possible to use 'ensure' , which throws an exception if types does not match.

[jcviljoen]

@henzeb this is fantastic, and is basically what I've had in mind 😂. Specifically the section Extending TypedCollection 🤩
Thank you for sharing!

I'm actually quite disappointed that I didn't find this before posting the idea, but hey, we live and we learn 🤷.

[henzeb]

indeed, I created my package after finding just one what that didn't entirely do what I wanted it to do and then after release I figured out there where plenty of others who already did. But that doesn't matter to me, this way I can implement a lot of extra features like casting (an array can be a JSON) custom generic types (why would a string not be something special like a Uuid or JSON) and some more things i've added recently.

cheers!