6

Ruby has a handy function for enumerables called each_cons. Which "Iterates the given block for each array of consecutive elements." This is really nice. Except that this is definitely an each method, which returns nil upon completion and not an array of the values you've looped over like map would.

However, if I have a situation where I need to iterate over an enumerable type, take an element and its cons, then perform some operation on them and return them back into an array what can I do? Normally, I'd use map for this sort of behavior. But map_cons doesn't exist.

An example:

Given a list of integers, I need to see which ones of those integers repeat and return a list of just those integers

[1, 1, 4, 5, 6, 2, 2] ## I need some function that will get me [1, 2]

I can say:

[1, 1, 4, 5, 6, 2, 2].each_cons(2) {|e| e[0] if e[0] == e[1]}

But, since it eachs over the array, it will complete successfully and return nil at the end. I need it to behave like map and not like each.

Is this behavior something that ruby supports? Am I coming at it from the wrong direction entirely?

kingsfoil
  • 3,795
  • 7
  • 32
  • 56

3 Answers3

15

The documentation of each_cons ends with this innocent phrase: "If no block is given, returns an enumerator." Most methods of Enumerable do this. What can you do with an Enumerator? Nothing truly impressive . But Enumerators include Enumerable, which does provide a large amount of powerful methods, map being one of them. So, as Stefan Pochmann does:

[1, 1, 4, 5, 6, 2, 2].each_cons(2).map { |e| e[0] if e[0] == e[1] }

each_consis called without a block, so it returns an Enumerator. mapis simply one of its methods.

steenslag
  • 79,051
  • 16
  • 138
  • 171
  • 2
    Since we're dealing with pairs, consider using `map { |a, b| a if a == b }`. – Sagar Pandya Dec 02 '17 at 16:00
  • 2
    Perhaps not truly impressive, but enumerators without blocks can still be handy. For example, `enum = [:even, :odd].cycle #=> #; enum.next; #=> :even; enum.next #=> :odd; enum.next #=> :even`... – Cary Swoveland Dec 03 '17 at 00:36
5

Just add map?

[1, 1, 4, 5, 6, 2, 2].each_cons(2).map { |e| e[0] if e[0] == e[1] }
=> [1, nil, nil, nil, nil, 2]
moveson
  • 5,103
  • 1
  • 15
  • 32
Stefan Pochmann
  • 27,593
  • 8
  • 44
  • 107
2

Ruby 2.7 added the method filter_map which makes this even easier:

p [1, 1, 4, 5, 6, 2, 2].each_cons(2).filter_map{|a,b| a if a == b} # => [1, 2]
steenslag
  • 79,051
  • 16
  • 138
  • 171