Question

In Ruby, what is the most expressive way to map an array in such a way that certain elements are modified and the others left untouched?

This is a straight-forward way to do it:

old_a = ['a', 'b', 'c']                         # ['a', 'b', 'c'] new_a = old_a.map { |x| (x=='b' ? x+'!' : x) }  # ['a', 'b!', 'c'] 

Omitting the ‘leave-alone’ case of course if not enough:

new_a = old_a.map { |x| x+'!' if x=='b' }       # [nil, 'b!', nil] 

What I would like is something like this:

new_a = old_a.map_modifying_only_elements_where (Proc.new {|x| x == 'b'})          do |y|           y + '!'         end # ['a', 'b!', 'c'] 

Is there some nice way to do this in Ruby (or maybe Rails has some kind of convenience method that I haven’t found yet)?

---

Thanks everybody for replying. While you collectively convinced me that it’s best to just use map with the ternary operator, some of you posted very interesting answers!

Answer 1

I agree that the map statement is good as it is. It’s clear and simple,, and would easy for anyone to maintain.

If you want something more complex, how about this?

module Enumerable   def enum_filter(&filter)     FilteredEnumerator.new(self, &filter)   end   alias :on :enum_filter   class FilteredEnumerator     include Enumerable     def initialize(enum, &filter)       @enum, @filter = enum, filter       if enum.respond_to?(:map!)         def self.map!           @enum.map! { |elt| @filter[elt] ? yield(elt) : elt }         end       end     end     def each       @enum.each { |elt| yield(elt) if @filter[elt] }     end     def each_with_index       @enum.each_with_index { |elt,index| yield(elt, index) if @filter[elt] }      end     def map       @enum.map { |elt| @filter[elt] ? yield(elt) : elt }     end     alias :and :enum_filter     def or       FilteredEnumerator.new(@enum) { |elt| @filter[elt] || yield(elt) }     end   end end  %w{ a b c }.on { |x| x == 'b' }.map { |x| x + '!' } #=> [ 'a', 'b!', 'c' ]  require 'set' Set.new(%w{ He likes dogs}).on { |x| x.length % 2 == 0 }.map! { |x| x.reverse } #=> #<Set: {'likes', 'eH', 'sgod'}>  ('a'..'z').on { |x| x[0] % 6 == 0 }.or { |x| 'aeiouy'[x] }.to_a.join #=> 'aefiloruxy'