Existe uma razão pela qual não podemos iterar no “intervalo reverso” no ruby?

Tentei iterar para trás usando um intervalo e each:

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

A iteração 0..4escreve os números. Por outro Faixa r = 4..0parece ser ok, r.first == 4, r.last == 0.

Parece-me estranho que a construção acima não produza o resultado esperado. Qual é a razão disso? Quais são as situações em que esse comportamento é razoável?

Um intervalo é apenas isso: algo definido por seu início e fim, não por seu conteúdo. "Iterar" em um intervalo realmente não faz sentido em um caso geral. Considere, por exemplo, como você iria "iterar" no intervalo produzido por duas datas. Você iteraria por dia? por mês? por ano? por semana? Não está bem definido. IMO, o fato de que é permitido para intervalos futuros deve ser visto apenas como um método de conveniência.

Se quiser iterar para trás em um intervalo como esse, você sempre pode usar downto:

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

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

Aqui estão mais alguns pensamentos de outros sobre por que é difícil permitir a iteração e lidar consistentemente com intervalos reversos.

Que tal (0..1).reverse_eachqual itera o intervalo para trás?

Iterando em um intervalo em Ruby com eachchamadas o succmétodo no primeiro objeto no intervalo.

$ 4.succ
=> 5

E 5 está fora do intervalo.

Você pode simular a iteração reversa com este hack:

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

John apontou que isso não funcionará se abranger 0. Isso:

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

Não posso dizer que gosto mesmo de qualquer um deles porque meio que obscurecem a intenção.

De acordo com o livro "Programming Ruby", o objeto Range armazena os dois pontos finais do intervalo e usa o .succmembro para gerar os valores intermediários. Dependendo do tipo de tipo de dados que você está usando em seu intervalo, você sempre pode criar uma subclasse de Integere redefinir o .succmembro para que ele atue como um iterador reverso (você provavelmente também desejaria redefinir .next).

Você também pode obter os resultados que procura sem usar um intervalo. Experimente isto:

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

Isso irá variar de 4 a 0 em etapas de -1. No entanto, não sei se isso funcionará para qualquer coisa, exceto argumentos inteiros.

Outra maneira é (1..10).to_a.reverse

Você pode até usar um forloop:

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

que imprime:

4
3
2
1
0

se a lista não for tão grande. eu acho que [*0..4].reverse.each { |i| puts i } é a maneira mais simples.

Como bta disse, o motivo é que Range#eachenvia succpara o seu início, depois para o resultado daquela succchamada, e assim por diante até que o resultado seja maior que o valor final. Você não pode passar de 4 a 0 chamando succe, na verdade, você já começa maior que o final.

Eu adiciono uma outra possibilidade de como realizar a iteração no intervalo reverso. Eu não uso, mas é uma possibilidade. É um pouco arriscado remendar objetos de núcleo de rubi.

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

Isso funcionou para meu caso de uso preguiçoso

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

O OP escreveu

Parece-me estranho que a construção acima não produza o resultado esperado. Qual é a razão disso? Quais são as situações em que esse comportamento é razoável?

não 'Isso pode ser feito?' mas para responder à pergunta que não foi feita antes de chegar à pergunta que realmente foi feita:

$ 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

Uma vez que é afirmado que reverse_each constrói um array inteiro, downto será claramente mais eficiente. O fato de que um designer de linguagem pode até mesmo considerar a implementação de coisas como essa meio que se vincula à resposta à pergunta real quando feita.

Para responder à pergunta como realmente feita ...

A razão é porque Ruby é uma linguagem infinitamente surpreendente. Algumas surpresas são agradáveis, mas há muitos comportamentos que estão completamente quebrados. Mesmo que alguns dos exemplos a seguir sejam corrigidos por versões mais recentes, há muitos outros e eles permanecem como acusações sobre a mentalidade do design original:

nil.to_s
   .to_s
   .inspect

resulta em "" mas

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

resulta em

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

Você provavelmente esperaria que << e push fossem iguais para anexar a matrizes, mas

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

Você provavelmente esperaria que 'grep' se comportasse como seu equivalente de linha de comando do Unix, mas faz === não correspondendo a = ~, apesar de seu nome.

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

Vários métodos são inesperadamente apelidos uns para os outros, então você precisa aprender vários nomes para a mesma coisa - por exemplo, finde detect- mesmo se você gosta da maioria dos desenvolvedores e usa apenas um ou outro. Praticamente o mesmo vale para size, counte length, exceto para classes que definem cada um de forma diferente, ou não definem um ou dois.

A menos que alguém tenha implementado algo diferente - como o método principal tapfoi redefinido em várias bibliotecas de automação para pressionar algo na tela. Boa sorte para descobrir o que está acontecendo, especialmente se algum módulo exigido por algum outro módulo manipulou outro módulo para fazer algo não documentado.

O objeto de variável de ambiente, ENV não suporta 'mesclar', então você tem que escrever

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

Como um bônus, você pode até mesmo redefinir suas constantes ou as de outra pessoa se mudar de ideia sobre como elas deveriam ser.

Para mim, a maneira mais simples é:

[*0..9].reverse

Outra maneira de iterar para enumeração:

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