Collection::keyBy(), with multiple values/levels

[jay-knight]

I have a need to be able to take a collection and "key" it by multiple values. Consider:

$collection = collect([
    [
        "first_key" => "value1",
        "second_Key" => "value2",
        "something" => "4"
    ],
    [
        "first_key" => "value1",
        "second_key" => "value3",
        "something" => "20"
    ]
])

In this collection, I know that the combination of first and second will always be unique. So I'd like to arrange this like:

collect([
    "value1" => [
        "value2" => [
            "first_key" => "value1",
            "second_second" => "value2",
            "something" => "4"
        ],
        "value3" => [
            "first_key" => "value1",
            "second_second" => "value3",
            "something" => "20"
        ],
    ]
])

$collection->groupBy(["first_key", "second_key"]]) gets me really close, but there is a third level of collections, each with one array:

> $collection->groupBy(["first_key", "second_key"])->toArray()

= [
    "value1" => [
      "value2" => [
        [
          "first_key" => "value1",
          "second_key" => "value2",
          "something" => "4",
        ],
      ],
      "value3" => [
        [
          "first_key" => "value1",
          "second_key" => "value3",
          "something" => "20",
        ],
      ],
    ],
  ]

It would be really nice if $collection->keyBy(["first_key", "second_key"]]) would behave similarly, but keep the value of the second level one of the original arrays instead of an array containing that original array.

So:

1. Would it be possible for Collection::keyBy() to take an array of keys and behave like that?
2. Is there a neat way of achieving what I'm looking for with the current methods available?

I did try to

$collection
    ->keyBy(fn($v) => "{$v["first_key"]}.{$v["second_key"]}")
    ->undot()

And that comes really close, but if either of the key values contain a dot (which they can), it messes that up and adds a third level.

[jay-knight]

I'll answer my own question with something that works, but I don't really like (with some help from Claude):

collect($collection
    ->reduce(function ($carry, $item) {
        data_set($carry, [$item['first_key'], $item['second_key']], $item, false);
        return $carry;
    }, []));

This "reduces" the collection into an array that looks the way I want, then wraps the whole thing into a collect() to turn it back into a collection.

[iruoy]

You can combine groupBy() for the first level with keyBy() for the second:

$result = $collection
    ->groupBy('first_key')
    ->map(fn ($group) => $group->keyBy('second_key'));

$result->toArray() gives the structure you showed: each second-level key points directly to the original item, without an extra array containing that item.

Dots in the values of either key are preserved literally, since this doesn't build a dotted path or call undot().

One difference from your reduce() solution: keyBy() keeps the last item if a key combination occurs more than once, whereas your data_set(..., false) keeps the first. With the unique combinations you described, that makes no difference.

Also, the first sample item has second_Key rather than second_key; those field names need to match.