Enumerable is a module providing a rich set of methods for traversing, searching, and manipulating collections — map, select, , , , and many more. Arrays, hashes, ranges, and any class that defines get all these methods. It's central to Ruby's elegant, functional data processing.
reducefindgroup_byeach[1, 2, 3, 4, 5]
.select { |n| n.even? } # filter → [2, 4]
.map { |n| n * 10 } # transform → [20, 40]
[1, 2, 3, 4].reduce(0) { |sum, n| sum + n } # 10 — fold/accumulate (also .sum)
[1, 2, 3, 4].find { |n| n > 2 } # 3 — first match
[1, 2, 3, 4].all? { |n| n > 0 } # true
[1, 2, 3, 4].any? { |n| n > 3 } # true
[1, 2, 3, 4].count { |n| n.even? } # 2
[3, 1, 2].sort; [3, 1, 2].min; [3, 1, 2].max
[1, 2, 3].each_with_index { |val, i| ... }
words.group_by { |w| w.length } # group into a hash by a key
[1, 2, 3, 4].partition { |n| n.even? } # [[2,4], [1,3]] — split by condition
[1, 2, 3].each_slice(2).to_a # [[1,2],[3]] — chunks
Enumerable provides dozens of expressive methods for filtering, transforming, aggregating, searching, grouping, and chunking — covering nearly any collection operation, chainable for clean data pipelines.
{ a: 1, b: 2 }.select { |k, v| v > 1 } # hashes are Enumerable → { b: 2 }
(1..100).map { |n| n * 2 } # ranges are Enumerable
class TodoList
include Enumerable # mix in Enumerable...
def initialize = @items = []
def each(&block) # ...just define `each`...
@items.each(&block)
end
# ...and you get map, select, reduce, find, sort, etc. FOR FREE!
end
list = TodoList.new
list.select { |item| item.done? } # works! — Enumerable provides it via your `each`
The elegant part: include Enumerable and define just each, and your class gains all of Enumerable's methods (map, select, reduce, etc.) automatically.
The Enumerable module is central to Ruby's elegant, expressive style of data processing, and understanding it is essential for productive, idiomatic Ruby.
It provides a rich, comprehensive set of methods (map, select, reduce, find, group_by, partition, all?, any?, and dozens more) for working with collections — and these methods, which you use constantly on arrays, hashes, and ranges, are what make Ruby's data manipulation so concise and readable (chaining expressive operations instead of writing verbose loops).
Mastering Enumerable's methods is key to writing fluent, functional-style Ruby — it's how you filter, transform, aggregate, search, and group data elegantly.
Beyond using these methods on built-in collections, an important and distinctly Ruby feature is that you can make your own classes Enumerable: by include Enumerable and defining just the each method, your class automatically gains all of Enumerable's methods (map, select, reduce, etc.) — a powerful demonstration of Ruby's mixin design and a practical tool for building custom collection-like classes that behave like arrays.
Understanding Enumerable — its wealth of methods (the foundation of Ruby's expressive data processing), that arrays/hashes/ranges all include it, and how to make custom classes Enumerable by defining each — is important, frequently-applied knowledge that's central to writing idiomatic Ruby.
Since data processing with Enumerable methods is ubiquitous in Ruby (and Rails), and since the include Enumerable + each pattern is an elegant example of Ruby's mixin power, mastering Enumerable is foundational for effective, idiomatic Ruby development and a common topic reflecting fluency with the language's expressive collection handling.