module Enumerable
  def method_missing(sym, *args)
    if (sym.to_s =~ /^(.+)_with$/) && (msg = args.shift)
      send($1.to_sym) do |x|
        x.send(msg, *args)
      end
    end
  end
end

[1, 2, 3].map_with :to_s

module Enumerable

   def select_with_index
      index = -1
      (block_given? && self.class == Range || self.class == Array)  ?  select { |x| index += 1; yield(x, index) }  :  self
   end

   def select_with_index_blk(&block)
      index = -1
      (block && self.class == Range || self.class == Array)  ?  select { |x| index += 1; block.call(x, index) }  :  self
   end

end


p ('a'..'n').select_with_index { |x, i| x if i % 2 == 0 }
p ('a'..'n').select_with_index_blk { |x, i| x if i % 2 == 0 }


require 'benchmark' 

num = 1000000

Benchmark.bm(8) do |t| 

  t.report('yield:') do 
    (0..num).select_with_index { |x, i| x } 
    #(0..num).select_with_index { |x, i| x if i % 2 == 0 } 
 end 

 t.report('block:') do
    (0..num).select_with_index_blk { |x, i| x } 
    #(0..num).select_with_index_blk { |x, i| x if i % 2 == 0 } 
 end 

end 

#class Array 
module Enumerable
  def comprehend(&block) 
    block ? map(&block).compact : self 
  end 
end 


old_data = *(1..5)          # alternatives to the splat operator: (1..5).to_a or (1..5).collect
new_data = *(3..9)


# some reinventing going on here ...
added = new_data.comprehend { |x| x if not old_data.include?(x) } 
removed = old_data.comprehend { |x| x if not new_data.include?(x) } 
same = new_data.comprehend { |x| x if old_data.include?(x) } 
modified = new_data.comprehend { |x| x**2 if not x % 2 == 0 }

p added                                            #=> [6, 7, 8, 9]
p added = new_data - old_data                      #=> [6, 7, 8, 9]

p removed                                         #=> [1, 2]
p removed = old_data - new_data                   #=> [1, 2]

p same                                              #=> [3, 4, 5]
p same = old_data & new_data                        #=> [3, 4, 5]
 
p modified                                        #=> [9, 25, 49, 81]


new_data = [[5, 9], [22, 3], [99, 564]]
bool_vals = new_data.comprehend { |x, y| x <= y }
p bool_vals                                      #=> [true, false, true]

module Enumerable
  def foldr(o, m = nil)
    reverse.inject(m) {|m, i| m ? i.send(o, m) : i}
  end

  def foldl(o, m = nil)
    inject(m) {|m, i| m ? m.send(o, i) : i}
  end
end

[1, 2, 3, 4, 5].foldl(:+) #=> 15
[1, 2, 3, 4, 5].foldl(:*) #=> 120

[1, 2, 3, 4, 5].foldr(:-, 0) #=> 3
[1, 2, 3, 4, 5].foldl(:-, 0) #=> -15