Как использовать счетчик

Основное различие между Enumerator и большинством^† других структур данных в основной библиотеке Ruby (Array, Hash) и стандартной библиотеке (Set, SortedSet) заключается в том, что Enumerator может быть бесконечным. У вас не может быть Array всех четных чисел, или потока нулей, или всех простых чисел, но вы определенно можете иметь такое Enumerator:

evens = Enumerator.new do |y|
  i = -2
  y << i += 2 while true
end

evens.take(10)
# => [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

zeroes = [0].cycle

zeroes.take(10)
# => [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

Итак, что вы можете сделать с таким Enumerator? Ну, три вещи, в основном.

1. Enumerator смешивается с Enumerable. Таким образом, вы можете использовать все методы Enumerable, такие как map, inject, all?, any?, none?, select, reject и так далее. Просто имейте в виду, что Enumerator может быть бесконечным, тогда как map возвращает Array, поэтому попытка map бесконечного Enumerator может создать бесконечно большое Array и занять бесконечное количество времени.

2. Существуют методы упаковки, которые каким-то образом «обогащают» Enumerator и возвращают новый Enumerator. Например, Enumerator#with_index добавляет в блок «счетчик циклов», а Enumerator#with_object добавляет мемо-объект.

3. Вы можете использовать Enumerator так же, как вы использовали бы его в других языках для внешней итерации, используя метод Enumerator#next, который даст вам либо следующее значение (и переместит Enumerator вперед), либо raise исключение StopIteration, если Enumerator конечно и у вас есть дошел до конца.

^† Например, бесконечный диапазон: (1..1.0/0)

Хороший вопрос.

Что, если мы хотим сделать несколько вещей с созданным перечислителем? Мы не хотим обрабатывать его сейчас, потому что это означает, что нам может понадобиться создать еще один позже?

my_enum = %w[now is the time for all good elves to get to work].map # => #<Enumerator: ["now", "is", "the", "time", "for", "all", "good", "elves", "to", "get", "to", "work"]:map>

my_enum.each(&:upcase) # => ["NOW", "IS", "THE", "TIME", "FOR", "ALL", "GOOD", "ELVES", "TO", "GET", "TO", "WORK"]
my_enum.each(&:capitalize) # => ["Now", "Is", "The", "Time", "For", "All", "Good", "Elves", "To", "Get", "To", "Work"]

Функция возврата enumerable, когда блок не задан, в основном используется при объединении функций из перечислимого класса вместе. Как это:

abc = %w[a b c]
p abc.map.with_index{|item, index| [item, index]} #=> [["a", 0], ["b", 1], ["c", 2]]

редактировать:

Я думаю, что мое собственное понимание этого поведения слишком ограничено, чтобы дать правильное понимание внутренней работы Ruby. Я думаю, самое важное, что следует отметить, это то, что аргументы передаются так же, как и для процедур. Таким образом, если массив передан, он будет автоматически "размазан" (какое-нибудь лучшее слово для этого?). Я думаю, что лучший способ понять это — просто использовать несколько простых функций, возвращающих перечисляемые числа, и начать экспериментировать.

abc = %w[a b c d]
p abc.each_slice(2)                #<Enumerator: ["a", "b", "c", "d"]:each_slice(2)>
p abc.each_slice(2).to_a           #=> [["a", "b"], ["c", "d"]]
p abc.each_slice(2).map{|x| x}     #=> [["a", "b"], ["c", "d"]]
p abc.each_slice(2).map{|x,y| x+y} #=> ["ab", "cd"]
p abc.each_slice(2).map{|x,| x}    #=> ["a", "c"] # rest of arguments discarded because of comma.
p abc.each_slice(2).map.with_index{|array, index| [array, index]} #=> [[["a", "b"], 0], [["c", "d"], 1]]
p abc.each_slice(2).map.with_index{|(x,y), index| [x,y, index]}   #=> [["a", "b", 0], ["c", "d", 1]]

В дополнение к ответу hirolau есть еще один метод lazy, который вы можете комбинировать для изменения перечислителя.

a_very_long_array.map.lazy

Если бы map всегда принимал блок, то должен был бы быть другой метод, такой как map_lazy, и аналогично для других итераторов, делающих то же самое.

Я предполагаю, что иногда вы хотите передать Enumerator другому методу, несмотря на то, откуда взялся этот Enumerator: map, slice, что угодно:

def report enum
  if Enumerator === enum
    enum.each { |e| puts "Element: #{e}" }
  else
    raise "report method requires enumerator as parameter"
  end
end

> report %w[one two three].map
# Element: one
# Element: two
# Element: three

> report (1..10).each_slice(2)    
# Element: [1, 2]
# Element: [3, 4]
# Element: [5, 6]
# Element: [7, 8]
# Element: [9, 10]

Enumerator Класс, допускающий как внутреннюю, так и внешнюю итерацию.

=> array = [1,2,3,4,5]
=> array.map
=> #<Enumerator: [2, 4, 6, 8, 10]:map>
=> array.map.next
=> 2
=> array.map.next_values
=> [0] 2