Ruby - Grouping and Projection - ruby

Question

Coming from c#, I'm used to being able to do the following using LINQ
var people = new List<Person>
{
new Person(Race.Black, "Mitch",30),
new Person(Race.White, "Mike",30),
new Person(Race.Mexican, "Mel",30),
};
var groups = people.GroupBy (p => p.Race)
.Select(g => new {race = g.Key, person = g});
Moving into Ruby, I would like to do grouping and projection into a hash, but is there an out of the box method for this or do I need to roll my own? Here's my implementation but it'd be great if this was offered in the language, or a 3rd party library that offered an implementation
def group(arr,group_sym)
groups = {}
arr.each do |i|
race = i[group_sym]
groups[race] = [] unless groups.has_key?(race)
i.delete(group_sym)
groups[race].push(i)
end
groups
end
Edit: So what I'm expecting from this is the following:
input:
people = [{name: 'mike', race: 'white', age: 30},
{name: 'mel', race: 'white', age: 31},
{name: 'mitch', race: 'black', age: 30},
{name: 'megan', race: 'asian', age: 30},
{name: 'maebe', race: 'black', age: 30},]
function call:
groupedPeople = groupBy(people,'race')
returns:
[{'white' => [{name: 'mike', age: 30},
{name: 'mel', race: 'white'}],
{'black' => [{...black people}],
{'asian' => [{...asian people}]
}]
For this specific example, I'd want to get a hash where my people array is grouped by race

Answer 1

Because of the fact that C#'s query expressions are meant to look like SQL queries, the method names are a bit unusual compared to other languages: Select is usually called map, Aggregate is usually called fold or reduce, Where is usually called select or filter, etc.
If you simply translate the method names, you can almost literally translate your code to Ruby:
Person = Struct.new(:race, :name, :age)
people = [
Person.new(:black, 'Mitch', 30),
Person.new(:white, 'Mike', 30),
Person.new(:mexican, 'Mel', 30)
]
groups = people.group_by(&:race).map {|race, people| { race: race, person: people } }
I used a Hash as the closest replacement for IGrouping.