When you call Array#each, what you actually get back is an Enumerator object. This object is simply something which implements the Enumerable mix in and defines an Object#each instance method which (by convention should) yield objects to another code block. With these requirements in place, the Enumerator provides a set of very powerful methods. I will be covering three of them: select, map, and reduce.

For demonstration purposes, I will be using an array (which implements an “each” method, returning an Enumerator object). In this example, we have an array of colors:

rainbow = ['red', 'orange', 'yellow', 'green', 'blue', 'purple']
# ['red', 'orange', 'yellow', 'green', 'blue', 'purple']

In terms of the Array class, Array#each simply yields each item from the array starting at the first element and ending on the last element.

Select

Select is a method built on top of each which enables quick and easy list filtering. Some examples may help illustrate this:

# any color with 5 or more letters
rainbow.select {|color| color.size >= 5}
# ['orange', 'yellow', 'green', 'purple']

# any color containing g
rainbow.select {|color| color.include?('g')}
# ['orange', 'green']

# regular expression matching any letter repeated more than once
rainbow.select {|color| color =~ /(\w)\1+/}
# ['yellow', 'green']

Select uses Array#each to enumerate the array, running the test that you specify in the code block against each element. If it returns true, then select copies that into another array which is returned. Just like how most methods have dangerous banged (Class#method!) versions which modify the object it’s called on, so does each:

# destructive select method
rainbow.select! {|color| color.include?('g')}
# ['orange', 'green']

# original rainbow array has been modified!
rainbow
# ['orange', 'green']

Map

Map may be familiar to people coming from a functional programming background. To fully understand it, you need to know that in Ruby methods are first-class citizens (atoms). Just like how you can pass an integer as a method argument, Ruby places no restriction on passing functions in as well; there are no complaints so long as the resulting code makes sense. In functional languages (and Ruby), map is a method which takes a method and an enumerable as arguments and applies the method to each item of the enumerable.

While other languages (Python, Scheme) have syntax which follow the style discussed above, Ruby’s code blocks allow map to be viewed as another method built on top of each. Some examples:

rainbow = ['red', 'orange', 'yellow', 'green', 'blue', 'purple']
# ['red', 'orange', 'yellow', 'green', 'blue', 'purple']

# all the words capitalized
rainbow.map {|color| color.upcase}
# ['RED', 'ORANGE', 'YELLOW', 'GREEN', 'BLUE', 'PURPLE']

# all the words reversed
rainbow.map {|color| color.reverse}
# ['der', 'egnaro', 'wolley', 'neerg', 'eulb', 'elprup']

# length of all the words
rainbow.map {|color| color.size}
# [3, 6, 6, 5, 4, 6]

In each case, map takes a code block and applies it to each individual element of the array, returning a new array with the method specified in the code block applied to each element.

Inject/Reduce

Array#inject and Array#reduce are the same function with two different names. In a way, reduce is the kingpin of all the other Enumerator methods seen above. Rather than forcing you to return a filtered enumeration (select) or a transformed enumeration (map), reduce allows you to directly craft the object being returned (commonly called an accumulator because it accumulates the results as you enumerate the collection). Some examples:

# number of colors
rainbow.reduce(0) {|acc, n| acc += 1}
# 6

# number of characters in all colors of rainbow
rainbow.reduce(0) {|acc, n| acc += n.length}
# 30

# defining map with reduce/inject
rainbow.reduce([]) {|acc, n| acc.push(n.upcase)}
# ['RED', 'ORANGE', 'YELLOW', 'GREEN', 'BLUE', 'PURPLE']

Note how in the third example, reduce has done the same thing as map. We could, in fact, never use map and always just use reduce. However, the two different methods provides clarity and self documenting code. Map is typically used when you apply a function across an array, whereas inject is used if you have a specific need for the accumulator. If you consider which one will be more appropriate for what you are trying to do, your code will be clearer and easier to understand for others.

I hope this helps explain some of the essential methods used when programming with enumerators in Ruby!