Maybe it's better to make method using to accept array? Then IDE will understand it's method of the concrete class.

AsEncryptedCollectionMap::using([Color::class, 'make'])

Edit: Ah I see it's supported. But I'd prefer to enforce this way, because it's better for static analysis.

I somewhat concur with Anton. Mostly just to simply the code in the castUsing methods here:

public function __construct(array $arguments)
{
    $arguments = array_values($arguments);

    if (empty($arguments) || empty($arguments[0])) {
        throw new InvalidArgumentException('No class or callable has been set to map the Collection.');
    }

    if (isset($arguments[1]) && ! is_array($arguments[0])) {
        $arguments = [$arguments[0], $arguments[1]];
        unset($arguments[1]);
    }

    $this->callable = $arguments[0];
}

What is $arguments = [$arguments[0], $arguments[1]]; supposed to accomplish? It just gets the first two elements of $arguments and assigns it to itself (could use array_slice($arguments, 0, 2), but I still don't understand why its used).

And then unset($arguments[1]); removes the second element, so we could have just done $arguments = [$arguments[0]], but since we are then taking the first element out for the callable, we don't even have to put it back into the array, we could have just done $this->callable = $arguments[0]. Which is exactly what is done below the if statement, so why even have the if statement?

@AndrewMast I just brainfaterd, so I fixed it.

Anyway, what are your thoughts guys? Should be this remain as its own Castable, or extend the base AsCollection to accept an map argument?

public function casts()
{
    return [
        'colors_map_into' => AsCollection::into(Color::class),
        'colors_collection' => AsCollection::using(ColorsCollection::class, Color::class),
        'colors_map' => AsCollection::map([Color::class, 'make']),
    ]
}

The benefit of the latter is allowing the developer to use its own Collection class but additionally mapping each item to a class or callback, which would be great for both scenarios without sacrifices.

This would mean the AsCollection and AsEncryptedCollection would grow a little in size to amend receiving a map class or callback, and properly normalizing the arguments.

Reworked at #55383