класс Enumerator

Родитель:: Объект
Включённые модули:: Enumerable

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

Объект Enumerator можно создать с помощью следующих методов.

Kernel#to_enum
Kernel#enum_for
::new

Большинство методов имеют две формы: форму с блоком, где содержимое оценивается для каждого элемента в перечислении, и форму без блока, которая возвращает новый Enumerator, оборачивающий итерацию.

enumerator = %w(one two three).each
puts enumerator.class # => Enumerator

enumerator.each_with_object("foo") do |item, obj|
  puts "#{obj}: #{item}"
end

# foo: one
# foo: two
# foo: three

enum_with_obj = enumerator.each_with_object("foo")
puts enum_with_obj.class # => Enumerator

enum_with_obj.each do |item, obj|
  puts "#{obj}: #{item}"
end

# foo: one
# foo: two
# foo: three

Это позволяет объединять Enumeratorы в цепочки. Например, вы можете преобразовать элементы списка в строки, содержащие индекс и элемент как строку, с помощью:

puts %w[foo bar baz].map.with_index { |w, i| "#{i}:#{w}" }
# => ["0:foo", "1:bar", "2:baz"]

Объект Enumerator также может использоваться как внешний итератор. Например, #next возвращает следующее значение итератора или вызывает исключение StopIteration, если Enumerator достиг конца.

e = [1,2,3].each   # returns an enumerator object.
puts e.next   # => 1
puts e.next   # => 2
puts e.next   # => 3
puts e.next   # raises StopIteration

Вы можете использовать это для реализации внутреннего итератора следующим образом:

def ext_each(e)
  while true
    begin
      vs = e.next_values
    rescue StopIteration
      return $!.result
    end
    y = yield(*vs)
    e.feed y
  end
end

o = Object.new

def o.each
  puts yield
  puts yield(1)
  puts yield(1, 2)
  3
end

# use o.each as an internal iterator directly.
puts o.each {|*x| puts x; [:b, *x] }
# => [], [:b], [1], [:b, 1], [1, 2], [:b, 1, 2], 3

# convert o.each to an external iterator for
# implementing an internal iterator.
puts ext_each(o.to_enum) {|*x| puts x; [:b, *x] }
# => [], [:b], [1], [:b, 1], [1, 2], [:b, 1, 2], 3

Публичные методы класса

new(size = nil) { |yielder| ... } Показать исходный код

new(obj, method = :each, *args)

static VALUE
enumerator_initialize(int argc, VALUE *argv, VALUE obj)
{
    VALUE recv, meth = sym_each;
    VALUE size = Qnil;

    if (rb_block_given_p()) {
        rb_check_arity(argc, 0, 1);
        recv = generator_init(generator_allocate(rb_cGenerator), rb_block_proc());
        if (argc) {
            if (NIL_P(argv[0]) || rb_respond_to(argv[0], id_call) ||
                (RB_TYPE_P(argv[0], T_FLOAT) && RFLOAT_VALUE(argv[0]) == INFINITY)) {
                size = argv[0];
            }
            else {
                size = rb_to_int(argv[0]);
            }
            argc = 0;
        }
    }
    else {
        rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
        rb_warn("Enumerator.new without a block is deprecated; use Object#to_enum");
        recv = *argv++;
        if (--argc) {
            meth = *argv++;
            --argc;
        }
    }

    return enumerator_init(obj, recv, meth, argc, argv, 0, size);
}

Создаёт новый объект Enumerator, который может использоваться как Enumerable.

В первой форме итерация определяется заданным блоком, в котором объект «yielder», переданный в качестве параметра блока, может использоваться для передачи значения вызовом метода yield (алиас +<<+):

fib = Enumerator.new do |y|
  a = b = 1
  loop do
    y << a
    a, b = b, a + b
  end
end

p fib.take(10) # => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

Необязательный параметр можно использовать для указания способа вычисления размера ленивым образом (см. #size). Он может быть значением или вызываемым объектом.

Во второй, устаревшей, форме сгенерированный Enumerator итерирует по заданному объекту с использованием заданного метода с переданными аргументами.

Использование этой формы не рекомендуется. Используйте вместо этого Kernel#enum_for или Kernel#to_enum.

e = Enumerator.new(ObjectSpace, :each_object)
    #-> ObjectSpace.enum_for(:each_object)

e.select { |obj| obj.is_a?(Class) }  #=> array of all classes

Публичные методы экземпляра

each { |elm| block } → obj Показать исходный код

each → enum

each(*appending_args) { |elm| block } → obj

each(*appending_args) → an_enumerator

static VALUE
enumerator_each(int argc, VALUE *argv, VALUE obj)
{
    if (argc > 0) {
        struct enumerator *e = enumerator_ptr(obj = rb_obj_dup(obj));
        VALUE args = e->args;
        if (args) {
#if SIZEOF_INT < SIZEOF_LONG
            /* check int range overflow */
            rb_long2int(RARRAY_LEN(args) + argc);
#endif
            args = rb_ary_dup(args);
            rb_ary_cat(args, argv, argc);
        }
        else {
            args = rb_ary_new4(argc, argv);
        }
        e->args = args;
    }
    if (!rb_block_given_p()) return obj;
    return enumerator_block_call(obj, 0, obj);
}

Итерирует по блоку в соответствии с тем, как был сконструирован этот Enumerator. Если блок и аргументы не заданы, возвращает self.

Примеры

"Hello, world!".scan(/\w+/)                     #=> ["Hello", "world"]
"Hello, world!".to_enum(:scan, /\w+/).to_a      #=> ["Hello", "world"]
"Hello, world!".to_enum(:scan).each(/\w+/).to_a #=> ["Hello", "world"]

obj = Object.new

def obj.each_arg(a, b=:b, *rest)
  yield a
  yield b
  yield rest
  :method_returned
end

enum = obj.to_enum :each_arg, :a, :x

enum.each.to_a                  #=> [:a, :x, []]
enum.each.equal?(enum)          #=> true
enum.each { |elm| elm }         #=> :method_returned

enum.each(:y, :z).to_a          #=> [:a, :x, [:y, :z]]
enum.each(:y, :z).equal?(enum)  #=> false
enum.each(:y, :z) { |elm| elm } #=> :method_returned

each_with_index {|(*args), idx| ... } Показать исходный код

each_with_index

static VALUE
enumerator_each_with_index(VALUE obj)
{
    return enumerator_with_index(0, NULL, obj);
}

То же самое, что и #with_index, т.е. нет начального смещения.

Если блок не задан, возвращается новый Enumerator, который включает индекс.

each_with_object(obj) {|(*args), obj| ... } Показать исходный код

each_with_object(obj)

static VALUE
enumerator_with_object(VALUE obj, VALUE memo)
{
    RETURN_SIZED_ENUMERATOR(obj, 1, &memo, enumerator_enum_size);
    enumerator_block_call(obj, enumerator_with_object_i, memo);

    return memo;
}

Итерирует заданный блок для каждого элемента с произвольным объектом, obj, и возвращает obj

Если блок не задан, возвращается новый Enumerator.

Пример

to_three = Enumerator.new do |y|
  3.times do |x|
    y << x
  end
end

to_three_with_string = to_three.with_object("foo")
to_three_with_string.each do |x,string|
  puts "#{string}: #{x}"
end

# => foo:0
# => foo:1
# => foo:2

feed obj → nil Показать исходный код

static VALUE
enumerator_feed(VALUE obj, VALUE v)
{
    struct enumerator *e = enumerator_ptr(obj);

    if (e->feedvalue != Qundef) {
        rb_raise(rb_eTypeError, "feed value already set");
    }
    e->feedvalue = v;

    return Qnil;
}

Устанавливает значение, которое будет возвращено следующим вызовом yield внутри e.

Если значение не установлено, yield возвращает nil.

Это значение очищается после передачи.

# Array#map passes the array's elements to "yield" and collects the
# results of "yield" as an array.
# Following example shows that "next" returns the passed elements and
# values passed to "feed" are collected as an array which can be
# obtained by StopIteration#result.
e = [1,2,3].map
p e.next           #=> 1
e.feed "a"
p e.next           #=> 2
e.feed "b"
p e.next           #=> 3
e.feed "c"
begin
  e.next
rescue StopIteration
  p $!.result      #=> ["a", "b", "c"]
end

o = Object.new
def o.each
  x = yield         # (2) blocks
  p x               # (5) => "foo"
  x = yield         # (6) blocks
  p x               # (8) => nil
  x = yield         # (9) blocks
  p x               # not reached w/o another e.next
end

e = o.to_enum
e.next              # (1)
e.feed "foo"        # (3)
e.next              # (4)
e.next              # (7)
                    # (10)

inspect → string Показать исходный код

static VALUE
enumerator_inspect(VALUE obj)
{
    return rb_exec_recursive(inspect_enumerator, obj, 0);
}

Создаёт удобочитаемый вариант e.

next → object Показать исходный код

static VALUE
enumerator_next(VALUE obj)
{
    VALUE vs = enumerator_next_values(obj);
    return ary2sv(vs, 0);
}

Возвращает следующий объект в перечислении и перемещает внутреннюю позицию вперёд. Когда позиция достигает конца, генерируется исключение StopIteration.

Пример

a = [1,2,3]
e = a.to_enum
p e.next   #=> 1
p e.next   #=> 2
p e.next   #=> 3
p e.next   #raises StopIteration

Обратите внимание, что перечисление последовательности с помощью next не влияет на другие методы перечисления, не использующие внешнюю итерацию, если методы основной итерации сами не вызывают побочные эффекты, например IO#each_line.

next_values → array Показать исходный код

static VALUE
enumerator_next_values(VALUE obj)
{
    struct enumerator *e = enumerator_ptr(obj);
    VALUE vs;

    if (e->lookahead != Qundef) {
        vs = e->lookahead;
        e->lookahead = Qundef;
        return vs;
    }

    return get_next_values(obj, e);
}

Возвращает следующий объект в виде массива в перечислении и перемещает внутреннюю позицию вперёд. При достижении конца последовательности генерируется исключение StopIteration.

Этот метод может использоваться для различения yield и yield nil.

Пример

o = Object.new
def o.each
  yield
  yield 1
  yield 1, 2
  yield nil
  yield [1, 2]
end
e = o.to_enum
p e.next_values
p e.next_values
p e.next_values
p e.next_values
p e.next_values
e = o.to_enum
p e.next
p e.next
p e.next
p e.next
p e.next

## yield args       next_values      next
#  yield            []               nil
#  yield 1          [1]              1
#  yield 1, 2       [1, 2]           [1, 2]
#  yield nil        [nil]            nil
#  yield [1, 2]     [[1, 2]]         [1, 2]

Обратите внимание, что next_values не влияет на другие методы перечисления, не использующие внешнюю итерацию, если у основного метода итерации нет побочных эффектов, например, IO#each_line.

peek → object Показать исходный код

static VALUE
enumerator_peek(VALUE obj)
{
    VALUE vs = enumerator_peek_values(obj);
    return ary2sv(vs, 1);
}

Возвращает следующий объект в перечислении, но не перемещает внутреннюю позицию вперёд. Если позиция уже в конце, генерируется исключение StopIteration.

Пример

a = [1,2,3]
e = a.to_enum
p e.next   #=> 1
p e.peek   #=> 2
p e.peek   #=> 2
p e.peek   #=> 2
p e.next   #=> 2
p e.next   #=> 3
p e.peek   #raises StopIteration

peek_values → array Показать исходный код

static VALUE
enumerator_peek_values_m(VALUE obj)
{
    return rb_ary_dup(enumerator_peek_values(obj));
}

Возвращает следующий объект как массив, аналогично #next_values, но не перемещает внутреннюю позицию вперёд. Если позиция уже в конце, генерируется исключение StopIteration.

Пример

o = Object.new
def o.each
  yield
  yield 1
  yield 1, 2
end
e = o.to_enum
p e.peek_values    #=> []
e.next
p e.peek_values    #=> [1]
p e.peek_values    #=> [1]
e.next
p e.peek_values    #=> [1, 2]
e.next
p e.peek_values    # raises StopIteration

rewind → e Показать исходный код

static VALUE
enumerator_rewind(VALUE obj)
{
    struct enumerator *e = enumerator_ptr(obj);

    rb_check_funcall(e->obj, id_rewind, 0, 0);

    e->fib = 0;
    e->dst = Qnil;
    e->lookahead = Qundef;
    e->feedvalue = Qundef;
    e->stop_exc = Qfalse;
    return obj;
}

Возвращает перечисление к началу.

Если заключённый объект отвечает на метод «rewind», он вызывается.

size → int, Float::INFINITY or nil Показать исходный код

static VALUE
enumerator_size(VALUE obj)
{
    struct enumerator *e = enumerator_ptr(obj);
    int argc = 0;
    const VALUE *argv = NULL;
    VALUE size;

    if (e->procs) {
        struct generator *g = generator_ptr(e->obj);
        VALUE receiver = rb_check_funcall(g->obj, id_size, 0, 0);
        long i = 0;

        for (i = 0; i < RARRAY_LEN(e->procs); i++) {
            VALUE proc = RARRAY_AREF(e->procs, i);
            struct proc_entry *entry = proc_entry_ptr(proc);
            lazyenum_size_func *size = entry->fn->size;
            if (!size) {
                return Qnil;
            }
            receiver = (*size)(proc, receiver);
        }
        return receiver;
    }

    if (e->size_fn) {
        return (*e->size_fn)(e->obj, e->args, obj);
    }
    if (e->args) {
        argc = (int)RARRAY_LEN(e->args);
        argv = RARRAY_CONST_PTR(e->args);
    }
    size = rb_check_funcall(e->size, id_call, argc, argv);
    if (size != Qundef) return size;
    return e->size;
}

Возвращает размер перечисления или nil, если его нельзя вычислить ленивым образом.

(1..100).to_a.permutation(4).size # => 94109400
loop.size # => Float::INFINITY
(1..100).drop_while.size # => nil

with_index(offset = 0) {|(*args), idx| ... } Показать исходный код

with_index(offset = 0)

static VALUE
enumerator_with_index(int argc, VALUE *argv, VALUE obj)
{
    VALUE memo;

    rb_scan_args(argc, argv, "01", &memo);
    RETURN_SIZED_ENUMERATOR(obj, argc, argv, enumerator_enum_size);
    if (NIL_P(memo))
        memo = INT2FIX(0);
    else
        memo = rb_to_int(memo);
    return enumerator_block_call(obj, enumerator_with_index_i, (VALUE)MEMO_NEW(memo, 0, 0));
}

Итерирует заданный блок для каждого элемента с индексом, который начинается с offset. Если блок не задан, возвращается новый Enumerator, включающий индекс, начиная с offset

offset: Начальный индекс для использования

with_object(obj) {|(*args), obj| ... } Показать исходный код

with_object(obj)

static VALUE
enumerator_with_object(VALUE obj, VALUE memo)
{
    RETURN_SIZED_ENUMERATOR(obj, 1, &memo, enumerator_enum_size);
    enumerator_block_call(obj, enumerator_with_object_i, memo);

    return memo;
}

Итерирует заданный блок для каждого элемента с произвольным объектом, obj, и возвращает obj

Если блок не задан, возвращается новый Enumerator.

Пример

to_three = Enumerator.new do |y|
  3.times do |x|
    y << x
  end
end

to_three_with_string = to_three.with_object("foo")
to_three_with_string.each do |x,string|
  puts "#{string}: #{x}"
end

# => foo:0
# => foo:1
# => foo:2

Ruby Core © 1993–2017 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.