advanced patterns with Enumerable#group_by in Ruby 3.1.0 when handling nil values
After trying multiple solutions online, I still can't figure this out. I'm working with an scenario with the `Enumerable#group_by` method in Ruby 3.1.0 when my array includes `nil` values. I expect the `nil` values to be grouped together in a separate array, but instead, the behavior is inconsistent depending on how I implement my grouping logic. Here's a simplified version of what I'm working with: ```ruby data = [1, 2, nil, 3, nil, 4] grouped = data.group_by { |num| num.nil? ? 'nil_group' : num.even? } puts grouped.inspect ``` I expected to see an output like this: ``` { "nil_group" => [nil, nil], false => [1, 3], true => [2, 4] } ``` However, I got: ``` { "nil_group" => [nil, nil], true => [2, 4], false => [1, 3] } ``` The order of the keys in the resulting hash seems to be inconsistent. I’ve also tried using `group_by` with a different approach: ```ruby grouped = data.group_by { |num| num.nil? ? :nil : (num.even? ? :even : :odd) } puts grouped.inspect ``` This produced the same scenario. I'm concerned that the ordering of keys might affect further processing in my application. Is there a way to ensure that the keys maintain a consistent order when using `group_by`, especially when dealing with `nil` values? I also checked the documentation for `Enumerable` and it doesn’t mention anything about key order. Any insights would be greatly appreciated! This is part of a larger API I'm building.