It is nice to do (for the forwards):

(1..10).each{|i| puts “i=#{i}” }

but I don’t like to do (for the backwards):

(1..10).to_a.reverse.each{|i| puts “i=#{i}” }

Well, I don’t actually mind doing that too much, but when I am teaching going backwards, I want to show my students a nice symmetry (i.e. with minimal difference, e.g. only adding a reverse, or a step -1, but without modifying anything else). You can do (for symmetry):

(a=*1..10).each{|i| puts “i=#{i}” }
and
(a=*1..10).reverse.each{|i| puts “i=#{i}” }
which I don’t like much, but you can’t do

(*1..10).each{|i| puts “i=#{i}” }
(*1..10).reverse.each{|i| puts “i=#{i}” }
#
(1..10).step(1){|i| puts “i=#{i}” }
(1..10).step(-1){|i| puts “i=#{i}” }
#
(1..10).each{|i| puts “i=#{i}” }
(10..1).each{|i| puts “i=#{i}” } # I don’t want this though. It’s dangerous

You could ultimately do

class Range
def each_reverse(&block)
self.to_a.reverse.each(&block)
end
end

but I want to teach pure Ruby rather than object oriented approaches (just yet). I would like to iterate backwards:

– without creating an array (consider 0..1000000000)
– working for any Range (e.g. Strings, not just Integers)
– without using any extra object oriented power (i.e. no class modification)

I believe this is impossible without defining a pred method, which means modifying the Range class to use it. If you can do this please let me know, otherwise confirmation of impossibility would be appreciated though it would be disappointing. Perhaps Ruby 1.9 addresses this.

The “right” way is

class Range

def each_reverse(&block)
i = self.last
while self === i
block.call(i)
i = i.pred
end
self
end

def every(&block)
if self.first < self.last
range = self
direction = :succ
else
range = self.last .. self.first
direction = :pred
end
i = self.first
while range === i
block.call(i)
i = i.send(direction)
end
self
end

end

class Integer

def pred
self – 1
end

end

class String

def pred
return ” if self == ”
self[0..-2] + (self[-1]-1).chr
end

end

ranges = [
1..10,
'a'..'j',
10..1,
'j'..'a'
]

ranges.each do |range|
puts “#{range.inspect}.each …”
range.each{|i| puts i}
puts “#{range.inspect}.each_reverse …”
range.each_reverse{|i| puts i}
puts “#{range.inspect}.every …”
range.every{|i| puts i}
end

(Thanks for your time in reading this.)

Cheers!

class Range
def iter(&block)
if first <= last
each(&block)
else
first.downto(last, &block)
end
end
end

(1..5).iter do |i|
puts(i)
end

(5..1).iter do |i|
puts(i)
end

Thanks! The min/max makes my life easier :) but as for the iterating, I still need to use a general solution, because I don’t know if x is less than or more than y.