Collections and Enums: Is there a more convenient way to get options?

[simonhamp]

I often find myself doing something like this to give me a well-formatted array of BackedEnum key-values (principally it could work with UnitEnum too) and I'm not sure if there's a better way:

// BackedEnum
collect(SomeEnum::cases())->mapWithKeys(fn(SomeEnum $item) => [$item->value => $item->label()]);

// UnitEnum
collect(SomeEnum::cases())->mapWithKeys(fn(SomeEnum $item) => [$item->name => $item->label()]);

But it's getting kind of annoying to put that everywhere. So I move it to the enum:

enum SomeEnum: string
{
    public static function options(): Arrayable
    {
        return collect(self::cases())->mapWithKeys(fn(self $item) => [$item->value => $item->label()]);
    }

    public function label()
    {
        // My prettier name logic
    }
}

// Some moments later...

SomeEnum::options();

This is fine when I want all/some subset of the available enum options and I'm calling the enum directly, but it doesn't help when I'm dealing with an AsEnumCollection cast from that enum.

In those cases, I end up with a Collection and now I still have to write:

$model->enum_cast_attribute->mapWithKeys(fn(SomeEnum $item) => [$item->value => $item->label()]);

So, I could let the SomeEnum:options() method accept a collection:

    public static function options(?Collection $subset = null): Arrayable
    {
        $options = $subset ?? collect(self::cases());

        return $options->mapWithKeys(fn(self $item) => [$item->value => $item->label()]);
    }

Which keeps all of this logic together, but then I still gotta do:

SomeEnum::options($model->enum_cast_attribute);

Which feels kinda weird - I have a collection of the enum, which I pass into the enum, to run some code on.

I really just want a Collection method that does some of this for me:

public static function options(): Arrayable
{
    return collect(self::cases())->options();
}

$model->enum_cast_attribute->options();

I am tempted to put something together for this, but wanted to make sure I'm not missing something before I start on it.

Does anyone else have this problem? How do you solve it?

[henzeb]

There are a few packages for this. Look at Enumhancer for example.

[simonhamp]

I can't see anything in Enumhancer that specifically addresses what I'm talking about here. I'm not getting at some general-purpose thing for enums... it's more about Collections.

Like, if there was a widely available method (let's call itoptions) that could do this mapWithKeys(fn() => [$key => $value]) piece which I find myself writing a lot, that would be great

[chris-ware]

As for most things, there is a spatie package that I think suits your needs here: https://github.com/spatie/laravel-options

[simonhamp]

Yep! That's the kind of thing I'm looking for. Thanks!

I'll experiment a little and see how it goes.

[simonhamp]

So I think if there was an options method on the Collection class, you could pair it with an Optionable interface which would force you to write an asOption method that would ultimately return the single-value array used in mapWithKeys e.g.

enum SomeEnum: string implements Optionable
{
    public function asOption(): Option
    {
        return [$this->value => $this->label()];

        // Or maybe using a class for strictness/clarity
        return new Option(
            key: $this->value,
            value: $this->label()
        );
    }
}

// Then...
collect(SomeEnum::cases)->options();

[wizzymore]

public static function asArray(): array
{
    $names = array_column(BackedEnum::cases(), 'name');
    $values = array_column(BackedEnum::cases(), 'value');
    if (count($values) > 0) {
        return array_combine($names, $values);
    }
    
    return $names;
}

public static function asCollection(): \Illuminate\Support\Collection
{
    return collect(self::asArray());
}

Extract this in a trait and you are good to go.