Y a-t-il une raison pour laquelle nous ne pouvons pas itérer sur «Reverse Range» en rubis?

J'ai essayé d'itérer en arrière en utilisant une plage et each:

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

L'itération par 0..4écrit les nombres. D'autre plage r = 4..0semble être ok, r.first == 4, r.last == 0.

Il me semble étrange que la construction ci-dessus ne donne pas le résultat attendu. Quelle en est la raison? Quelles sont les situations où ce comportement est raisonnable?

Une plage n'est que cela: quelque chose défini par son début et sa fin, pas par son contenu. «Itérer» sur une plage n'a pas vraiment de sens dans un cas général. Considérez, par exemple, comment vous «itéreriez» sur la plage produite par deux dates. Souhaitez-vous itérer par jour? par mois? par année? par semaine? Ce n'est pas bien défini. OMI, le fait qu'il soit autorisé pour les plages avant doit être considéré comme une méthode de commodité uniquement.

Si vous souhaitez effectuer une itération en arrière sur une plage comme celle-ci, vous pouvez toujours utiliser downto:

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

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

Voici quelques réflexions d'autres personnes sur les raisons pour lesquelles il est difficile à la fois d'autoriser l'itération et de gérer systématiquement les plages inversées.

Que diriez-vous de (0..1).reverse_eachlaquelle itère la plage à l'envers?

Itérer sur une plage en Ruby avec eachappelle la succméthode sur le premier objet de la plage.

$ 4.succ
=> 5

Et 5 est en dehors de la plage.

Vous pouvez simuler une itération inverse avec ce hack:

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

John a souligné que cela ne fonctionnera pas s'il s'étend sur 0. Cela:

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

Je ne peux pas dire que j'aime vraiment l'un d'entre eux parce qu'ils obscurcissent en quelque sorte l'intention.

Selon le livre "Programming Ruby", l'objet Range stocke les deux extrémités de la plage et utilise le .succmembre pour générer les valeurs intermédiaires. Selon le type de type de données que vous utilisez dans votre plage, vous pouvez toujours créer une sous-classe Integeret redéfinir le .succmembre afin qu'il agisse comme un itérateur inversé (vous voudrez probablement également redéfinir .next).

Vous pouvez également obtenir les résultats que vous recherchez sans utiliser de plage. Essaye ça:

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

Cela passera de 4 à 0 par incréments de -1. Cependant, je ne sais pas si cela fonctionnera pour autre chose que les arguments Integer.

Une autre façon est (1..10).to_a.reverse

Vous pouvez même utiliser une forboucle:

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

qui imprime:

4
3
2
1
0

si la liste n'est pas si grande. je pense que [*0..4].reverse.each { |i| puts i } c'est le moyen le plus simple.

Comme bta l'a dit, la raison est que cela Range#eachenvoie succà son début, puis au résultat de cet succappel, et ainsi de suite jusqu'à ce que le résultat soit supérieur à la valeur finale. Vous ne pouvez pas passer de 4 à 0 en appelant succ, et en fait vous commencez déjà plus grand que la fin.

J'ajoute une autre possibilité de réaliser une itération sur une plage inversée. Je ne l'utilise pas, mais c'est une possibilité. Il est un peu risqué de monkey patch ruby ​​core objects.

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

Cela a fonctionné pour mon cas d'utilisation paresseux

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

L'OP a écrit

Il me semble étrange que la construction ci-dessus ne donne pas le résultat attendu. Quelle en est la raison? Quelles sont les situations où ce comportement est raisonnable?

pas «Peut-il être fait? mais pour répondre à la question qui n'a pas été posée avant d'arriver à la question qui a été réellement posée:

$ 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

Puisque reverse_each est censé créer un tableau entier, downto sera clairement plus efficace. Le fait qu'un concepteur de langage puisse même envisager de mettre en œuvre des choses comme celles-là est un peu lié à la réponse à la question réelle posée.

Pour répondre à la question telle qu'elle est réellement posée ...

La raison en est que Ruby est un langage infiniment surprenant. Certaines surprises sont agréables, mais il y a beaucoup de comportements qui sont carrément cassés. Même si certains de ces exemples suivants sont corrigés par des versions plus récentes, il y en a beaucoup d'autres, et ils restent comme des accusations sur l'état d'esprit de la conception originale:

nil.to_s
   .to_s
   .inspect

donne "" mais

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

résulte en

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

Vous vous attendriez probablement à ce que << et push soient les mêmes pour l'ajout aux tableaux, mais

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

Vous vous attendriez probablement à ce que «grep» se comporte comme son équivalent en ligne de commande Unix, mais il correspond === non = ~, malgré son nom.

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

Diverses méthodes sont inopinément des alias l'une pour l'autre, vous devez donc apprendre plusieurs noms pour la même chose - par exemple findet detect- même si vous aimez la plupart des développeurs et n'utilisez jamais que l'un ou l'autre. Il en va de même pour size, countet length, à l' exception des classes qui définissent différemment chacun, ou ne définissent pas un ou deux du tout.

À moins que quelqu'un n'ait implémenté autre chose - comme la méthode principale tapa été redéfinie dans diverses bibliothèques d'automatisation pour appuyer sur quelque chose à l'écran. Bonne chance pour découvrir ce qui se passe, surtout si un module requis par un autre module a monkey encore un autre module pour faire quelque chose de non documenté.

L'objet de variable d'environnement, ENV ne prend pas en charge 'merge', vous devez donc écrire

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

En prime, vous pouvez même redéfinir vos constantes ou celles de quelqu'un d'autre si vous changez d'avis sur ce qu'elles devraient être.

Quant à moi, le moyen le plus simple est:

[*0..9].reverse

Une autre façon d'itérer pour l'énumération:

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