¿Hay alguna razón por la que no podamos iterar en "rango inverso" en ruby?

Intenté iterar hacia atrás con el uso de un Range y each:

(4..0).each do |i|
  puts i
end
==> 4..0

La iteración 0..4escribe los números. Por otro rango r = 4..0parece estar bien, r.first == 4, r.last == 0.

Me parece extraño que la construcción anterior no produzca el resultado esperado. ¿Cuál es la razón de eso? ¿Cuáles son las situaciones en las que este comportamiento es razonable?

Un rango es solo eso: algo definido por su inicio y final, no por su contenido. "Iterar" en un rango no tiene sentido en un caso general. Considere, por ejemplo, cómo "iteraría" sobre el rango producido por dos fechas. ¿Repetirías de día? ¿Por mes? ¿por año? ¿por semana? No está bien definido. En mi opinión, el hecho de que esté permitido para rangos de avance debe verse solo como un método de conveniencia.

Si desea iterar hacia atrás en un rango como ese, siempre puede usar downto:

$ r = 10..6
=> 10..6

$ (r.first).downto(r.last).each { |i| puts i }
10
9
8
7
6

Aquí hay algunos pensamientos más de otros sobre por qué es difícil permitir la iteración y tratar consistentemente con rangos inversos.

¿Qué tal (0..1).reverse_eachque itera el rango al revés?

Iterando sobre un rango en Ruby con eachllamadas al succmétodo en el primer objeto en el rango.

$ 4.succ
=> 5

Y 5 está fuera del rango.

Puede simular la iteración inversa con este truco:

(-4..0).each { |n| puts n.abs }

John señaló que esto no funcionará si se extiende por 0. Esto:

>> (-2..2).each { |n| puts -n }
2
1
0
-1
-2
=> -2..2

No puedo decir que realmente me guste ninguno de ellos porque oscurecen la intención.

Según el libro "Programming Ruby", el objeto Range almacena los dos puntos finales del rango y usa el .succmiembro para generar los valores intermedios. Dependiendo del tipo de tipo de datos que esté usando en su rango, siempre puede crear una subclase Integery volver a definir el .succmiembro para que actúe como un iterador inverso (probablemente también desee volver a definirlo .next).

También puede lograr los resultados que busca sin utilizar un rango. Prueba esto:

4.step(0, -1) do |i|
    puts i
end

Esto pasará de 4 a 0 en pasos de -1. Sin embargo, no sé si esto funcionará para algo excepto para los argumentos Integer.

Otra forma es (1..10).to_a.reverse

Incluso puedes usar un forbucle:

for n in 4.downto(0) do
  print n
end

que imprime:

4
3
2
1
0

si la lista no es tan grande. Creo que [*0..4].reverse.each { |i| puts i } es la forma más sencilla.

Como dijo bta, la razón es que Range#eachenvía succa su inicio, luego al resultado de esa succllamada, y así sucesivamente hasta que el resultado sea mayor que el valor final. No puedes pasar de 4 a 0 llamando succ, y de hecho ya comienzas más que el final.

Agrego otra posibilidad de cómo realizar la iteración sobre el rango inverso. No lo uso, pero es una posibilidad. Es un poco arriesgado parchear objetos con núcleo de rubí.

class Range

  def each(&block)
    direction = (first<=last ? 1 : -1)
    i = first
    not_reached_the_end = if first<=last
                            lambda {|i| i<=last}
                          else
                            lambda {|i| i>=last}
                          end
    while not_reached_the_end.call(i)
      yield i
      i += direction
    end
  end
end

Esto funcionó para mi caso de uso perezoso

(-999999..0).lazy.map{|x| -x}.first(3)
#=> [999999, 999998, 999997]

El OP escribió

Me parece extraño que la construcción anterior no produzca el resultado esperado. ¿Cuál es la razón de eso? ¿Cuáles son las situaciones en las que este comportamiento es razonable?

no '¿Se puede hacer?' pero para responder la pregunta que no se hizo antes de llegar a la pregunta que realmente se hizo:

$ irb
2.1.5 :001 > (0..4)
 => 0..4
2.1.5 :002 > (0..4).each { |i| puts i }
0
1
2
3
4
 => 0..4
2.1.5 :003 > (4..0).each { |i| puts i }
 => 4..0
2.1.5 :007 > (0..4).reverse_each { |i| puts i }
4
3
2
1
0
 => 0..4
2.1.5 :009 > 4.downto(0).each { |i| puts i }
4
3
2
1
0
 => 4

Dado que se afirma que reverse_each crea una matriz completa, es evidente que downto será más eficiente. El hecho de que un diseñador de idiomas pueda incluso considerar implementar cosas como esa se relaciona un poco con la respuesta a la pregunta real tal como se le preguntó.

Para responder a la pregunta como se hizo realmente ...

La razón es que Ruby es un lenguaje infinitamente sorprendente. Algunas sorpresas son agradables, pero hay muchos comportamientos que están rotos. Incluso si algunos de estos ejemplos siguientes se corrigen con versiones más recientes, hay muchos otros y permanecen como acusaciones en la mentalidad del diseño original:

nil.to_s
   .to_s
   .inspect

da como resultado "" pero

nil.to_s
#  .to_s   # Don't want this one for now
   .inspect

resultados en

 syntax error, unexpected '.', expecting end-of-input
 .inspect
 ^

Probablemente esperaría que << y push sea lo mismo para agregar a matrices, pero

a = []
a << *[:A, :B]    # is illegal but
a.push *[:A, :B]  # isn't.

Probablemente esperaría que 'grep' se comporte como su equivalente en la línea de comandos de Unix, pero no coincide === con = ~, a pesar de su nombre.

$ echo foo | grep .
foo
$ ruby -le 'p ["foo"].grep(".")'
[]

Varios métodos tienen alias inesperadamente entre sí, por lo que debe aprender varios nombres para lo mismo, por ejemplo, findy detect, incluso si le gusta la mayoría de los desarrolladores y solo usa uno u otro. Lo mismo ocurre con size, county length, excepto para las clases que definen cada una de manera diferente, o que no definen una o dos en absoluto.

A menos que alguien haya implementado algo más, como que el método principal tapse haya redefinido en varias bibliotecas de automatización para presionar algo en la pantalla. Buena suerte averiguando lo que está pasando, especialmente si algún módulo requerido por otro módulo ha engañado a otro módulo para hacer algo indocumentado.

El objeto de la variable de entorno, ENV no admite 'fusionar', por lo que debe escribir

 ENV.to_h.merge('a': '1')

Como beneficio adicional, incluso puede redefinir sus constantes o las de otra persona si cambia de opinión sobre lo que deberían ser.

En cuanto a mí, la forma más sencilla es:

[*0..9].reverse

Otra forma de iterar para la enumeración:

(1..3).reverse_each{|v| p v}