class Enumerator::Lazy

Родитель:: Enumerator

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

Enumerator::Lazy можно создать из любого Enumerable с помощью метода Enumerable#lazy.

lazy = (1..Float::INFINITY).lazy.select(&:odd?).drop(10).take_while { |i| i < 30 }
# => #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator::Lazy: 1..Infinity>:select>:drop(10)>:take_while>

Фактический перебор выполняется при вызове любого непереопределённого метода Enumerable, например Enumerable#first или Enumerable#to_a (последний метод имеет псевдоним force, который делает код более выразительным):

lazy.first(2)
#=> [21, 23]

lazy.force
#=> [21, 23, 25, 27, 29]

Обратите внимание: для большинства методов Enumerable, которые можно вызывать с блоком или без него, для Enumerator::Lazy блок всегда обязателен:

[1, 2, 3].map       #=> #<Enumerator: [1, 2, 3]:map>
[1, 2, 3].lazy.map  # ArgumentError: tried to call lazy map without a block

Этот класс позволяет идиоматично выполнять вычисления над длинными или бесконечными последовательностями, а также объединять вычисления в цепочки, не создавая промежуточных массивов.

Пример работы с последовательностью, вычисляемой с задержкой:

require 'open-uri'

# This will fetch all URLs before selecting
# necessary data
URLS.map { |u| JSON.parse(URI.open(u).read) }
  .select { |data| data.key?('stats') }
  .first(5)

# This will fetch URLs one-by-one, only till
# there is enough data to satisfy the condition
URLS.lazy.map { |u| JSON.parse(URI.open(u).read) }
  .select { |data| data.key?('stats') }
  .first(5)

Завершение цепочки вызовом «.eager» создаёт нелени́вый перечислитель, подходящий для возврата или передачи другому методу, ожидающему обычный перечислитель.

def active_items
  groups
    .lazy
    .flat_map(&:items)
    .reject(&:disabled)
    .eager
end

# This works lazily; if a checked item is found, it stops
# iteration and does not look into remaining groups.
first_checked = active_items.find(&:checked)

# This returns an array of items like a normal enumerator does.
all_checked = active_items.select(&:checked)

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

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

static VALUE
lazy_initialize(int argc, VALUE *argv, VALUE self)
{
    VALUE obj, size = Qnil;
    VALUE generator;

    rb_check_arity(argc, 1, 2);
    LAZY_NEED_BLOCK(new);
    obj = argv[0];
    if (argc > 1) {
        size = argv[1];
    }
    generator = generator_allocate(rb_cGenerator);
    rb_block_call(generator, id_initialize, 0, 0, lazy_init_block_i, obj);
    enumerator_init(self, generator, sym_each, 0, 0, 0, size, 0);
    rb_ivar_set(self, id_receiver, obj);

    return self;
}

Создаёт новый перечислитель Lazy. Когда перечислитель фактически выполняет перебор (например, при вызове force), выполняется перебор obj, и каждое значение передаётся указанному блоку. Блок может возвращать значения с помощью yielder. Например, чтобы создать перечислитель «фильтрация + отображение»:

def filter_map(sequence)
  Lazy.new(sequence) do |yielder, *values|
    result = yield *values
    yielder << result if result
  end
end

filter_map(1..Float::INFINITY) {|i| i*i if i.even?}.first(5)
#=> [4, 16, 36, 64, 100]

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

_enumerable_collect ()

Как Enumerable#map, но операция выполняется по цепочке лениво.

(1..Float::INFINITY).lazy.map {|i| i**2 }
#=> #<Enumerator::Lazy: #<Enumerator::Lazy: 1..Infinity>:map>
(1..Float::INFINITY).lazy.map {|i| i**2 }.first(3)
#=> [1, 4, 9]

Псевдоним для: collect

_enumerable_collect_concat ()

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

["foo", "bar"].lazy.flat_map {|i| i.each_char.lazy}.force
#=> ["f", "o", "o", "b", "a", "r"]

Значение x, возвращённое block, разлагается, если выполняется одно из следующих условий:

x поддерживает методы each и force, что означает, что x является ленивым перечислителем.
x является массивом или поддерживает метод to_ary.

В противном случае x включается в возвращаемое значение без изменений.

[{a:1}, {b:2}].lazy.flat_map {|i| i}.force
#=> [{:a=>1}, {:b=>2}]

Псевдоним для: collect_concat

_enumerable_drop

Псевдоним для: drop

_enumerable_drop_while

Псевдоним для: drop_while

_enumerable_filter ()

Как Enumerable#select, но операция выполняется по цепочке лениво.

Псевдоним для: filter

_enumerable_filter_map

Псевдоним для: filter_map

_enumerable_find_all ()

Как Enumerable#select, но операция выполняется по цепочке лениво.

Псевдоним для: find_all

_enumerable_flat_map

Псевдоним для: flat_map

_enumerable_grep

Псевдоним для: grep

_enumerable_grep_v

Псевдоним для: grep_v

_enumerable_map

Псевдоним для: map

_enumerable_reject

Псевдоним для: reject

_enumerable_select

Псевдоним для: select

_enumerable_take

Псевдоним для: take

_enumerable_take_while

Псевдоним для: take_while

_enumerable_uniq

Псевдоним для: uniq

_enumerable_zip

Псевдоним для: zip

chunk (*args) Показать исходный код

endif

static VALUE
lazy_super(int argc, VALUE *argv, VALUE lazy)
{
    return enumerable_lazy(rb_call_super(argc, argv));
}

Как Enumerable#chunk, но операция выполняется по цепочке лениво.

Также имеет псевдонимы: slice_before, slice_after, slice_when, chunk_while

chunk_while (*args)

Как Enumerable#chunk_while, но операция выполняется по цепочке лениво.

Псевдоним для: chunk

collect { |obj| block } → lazy_enumerator

Как Enumerable#map, но операция выполняется по цепочке лениво.

(1..Float::INFINITY).lazy.map {|i| i**2 }
#=> #<Enumerator::Lazy: #<Enumerator::Lazy: 1..Infinity>:map>
(1..Float::INFINITY).lazy.map {|i| i**2 }.first(3)
#=> [1, 4, 9]

Также имеет псевдонимы: _enumerable_collect

Псевдоним для: map

collect_concat { |obj| block } → a_lazy_enumerator

["foo", "bar"].lazy.flat_map {|i| i.each_char.lazy}.force
#=> ["f", "o", "o", "b", "a", "r"]

Значение x, возвращённое block, разлагается, если выполняется одно из следующих условий:

x поддерживает методы each и force, что означает, что x является ленивым перечислителем.
x является массивом или поддерживает метод to_ary.

В противном случае x включается в возвращаемое значение без изменений.

[{a:1}, {b:2}].lazy.flat_map {|i| i}.force
#=> [{:a=>1}, {:b=>2}]

Также имеет псевдонимы: _enumerable_collect_concat

Псевдоним для: flat_map

compact → lazy_enumerator Показать исходный код

static VALUE
lazy_compact(VALUE obj)
{
    return lazy_add_method(obj, 0, 0, Qnil, Qnil, &lazy_compact_funcs);
}

Как Enumerable#compact, но операция выполняется по цепочке лениво.

drop(n) → lazy_enumerator Показать исходный код

static VALUE
lazy_drop(VALUE obj, VALUE n)
{
    long len = NUM2LONG(n);
    VALUE argv[2];
    argv[0] = sym_each;
    argv[1] = n;

    if (len < 0) {
        rb_raise(rb_eArgError, "attempt to drop negative size");
    }

    return lazy_add_method(obj, 2, argv, n, rb_ary_new3(1, n), &lazy_drop_funcs);
}

Как Enumerable#drop, но операция выполняется по цепочке лениво.

Также имеет псевдонимы: _enumerable_drop

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

static VALUE
lazy_drop_while(VALUE obj)
{
    LAZY_NEED_BLOCK(drop_while);
    return lazy_add_method(obj, 0, 0, Qfalse, Qnil, &lazy_drop_while_funcs);
}

Как Enumerable#drop_while, но операция выполняется по цепочке лениво.

Также имеет псевдонимы: _enumerable_drop_while

eager → enum Показать исходный код

static VALUE
lazy_eager(VALUE self)
{
    return enumerator_init(enumerator_allocate(rb_cEnumerator),
                           self, sym_each, 0, 0, lazy_eager_size, Qnil, 0);
}

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

enum_for(method = :each, *args) → lazy_enum

enum_for(method = :each, *args) {|*args| block } → lazy_enum

Аналогичен Object#to_enum, но возвращает ленивый перечислитель. Это упрощает определение методов Enumerable, которые естественным образом остаются ленивыми при вызове из ленивого перечислителя.

Например, продолжая пример из Object#to_enum:

# See Object#to_enum for the definition of repeat
r = 1..Float::INFINITY
r.repeat(2).first(5) # => [1, 1, 2, 2, 3]
r.repeat(2).class # => Enumerator
r.repeat(2).map{|n| n ** 2}.first(5) # => endless loop!
# works naturally on lazy enumerator:
r.lazy.repeat(2).class # => Enumerator::Lazy
r.lazy.repeat(2).map{|n| n ** 2}.first(5) # => [1, 1, 4, 4, 9]

Псевдоним для: to_enum

filter { |obj| block } → lazy_enumerator

Как Enumerable#select, но операция выполняется по цепочке лениво.

Также имеет псевдонимы: _enumerable_filter

Псевдоним для: select

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

static VALUE
lazy_filter_map(VALUE obj)
{
    LAZY_NEED_BLOCK(filter_map);
    return lazy_add_method(obj, 0, 0, Qnil, Qnil, &lazy_filter_map_funcs);
}

Как Enumerable#filter_map, но операция выполняется по цепочке лениво.

(1..).lazy.filter_map { |i| i * 2 if i.even? }.first(5)
#=> [4, 8, 12, 16, 20]

Также имеет псевдонимы: _enumerable_filter_map

find_all { |obj| block } → lazy_enumerator

Как Enumerable#select, но операция выполняется по цепочке лениво.

Также имеет псевдонимы: _enumerable_find_all

Псевдоним для: select

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

static VALUE
lazy_flat_map(VALUE obj)
{
    LAZY_NEED_BLOCK(flat_map);
    return lazy_add_method(obj, 0, 0, Qnil, Qnil, &lazy_flat_map_funcs);
}

["foo", "bar"].lazy.flat_map {|i| i.each_char.lazy}.force
#=> ["f", "o", "o", "b", "a", "r"]

Значение x, возвращённое block, разлагается, если выполняется одно из следующих условий:

x поддерживает методы each и force, что означает, что x является ленивым перечислителем.
x является массивом или поддерживает метод to_ary.

В противном случае x включается в возвращаемое значение без изменений.

[{a:1}, {b:2}].lazy.flat_map {|i| i}.force
#=> [{:a=>1}, {:b=>2}]

Также имеет псевдонимы: collect_concat, _enumerable_flat_map

force → array

Преобразует lazy перечислитель в массив. См. Enumerable#to_a.

Псевдоним для: to_a

grep(pattern) → lazy_enumerator Показать исходный код

grep(pattern) { |obj| block } → lazy_enumerator

static VALUE
lazy_grep(VALUE obj, VALUE pattern)
{
    const lazyenum_funcs *const funcs = rb_block_given_p() ?
        &lazy_grep_iter_funcs : &lazy_grep_funcs;
    return lazy_add_method(obj, 0, 0, pattern, rb_ary_new3(1, pattern), funcs);
}

Как Enumerable#grep, но операция выполняется по цепочке лениво.

Также имеет псевдонимы: _enumerable_grep

grep_v(pattern) → lazy_enumerator Показать исходный код

grep_v(pattern) { |obj| block } → lazy_enumerator

static VALUE
lazy_grep_v(VALUE obj, VALUE pattern)
{
    const lazyenum_funcs *const funcs = rb_block_given_p() ?
        &lazy_grep_v_iter_funcs : &lazy_grep_v_funcs;
    return lazy_add_method(obj, 0, 0, pattern, rb_ary_new3(1, pattern), funcs);
}

Как Enumerable#grep_v, но операция выполняется по цепочке лениво.

Также имеет псевдонимы: _enumerable_grep_v

lazy → lazy_enumerator Показать исходный код

static VALUE
lazy_lazy(VALUE obj)
{
    return obj;
}

Возвращает self.

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

static VALUE
lazy_map(VALUE obj)
{
    LAZY_NEED_BLOCK(map);
    return lazy_add_method(obj, 0, 0, Qnil, Qnil, &lazy_map_funcs);
}

Как Enumerable#map, но операция выполняется по цепочке лениво.

(1..Float::INFINITY).lazy.map {|i| i**2 }
#=> #<Enumerator::Lazy: #<Enumerator::Lazy: 1..Infinity>:map>
(1..Float::INFINITY).lazy.map {|i| i**2 }.first(3)
#=> [1, 4, 9]

Также имеет псевдонимы: collect, _enumerable_map

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

static VALUE
lazy_reject(VALUE obj)
{
    LAZY_NEED_BLOCK(reject);
    return lazy_add_method(obj, 0, 0, Qnil, Qnil, &lazy_reject_funcs);
}

Как Enumerable#reject, но операция выполняется по цепочке лениво.

Также имеет псевдонимы: _enumerable_reject

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

static VALUE
lazy_select(VALUE obj)
{
    LAZY_NEED_BLOCK(select);
    return lazy_add_method(obj, 0, 0, Qnil, Qnil, &lazy_select_funcs);
}

Как Enumerable#select, но операция выполняется по цепочке лениво.

Также имеет псевдонимы: find_all, filter, _enumerable_select

slice_after (*args)

Как Enumerable#slice_after, но операция выполняется по цепочке лениво.

Псевдоним для: chunk

slice_before (*args)

Как Enumerable#slice_before, но операция выполняется по цепочке лениво.

Псевдоним для: chunk

slice_when (*args)

Как Enumerable#slice_when, но операция выполняется по цепочке лениво.

Псевдоним для: chunk

take(n) → lazy_enumerator Показать исходный код

static VALUE
lazy_take(VALUE obj, VALUE n)
{
    long len = NUM2LONG(n);

    if (len < 0) {
        rb_raise(rb_eArgError, "attempt to take negative size");
    }

    n = LONG2NUM(len);          /* no more conversion */

    return lazy_add_method(obj, 0, 0, n, rb_ary_new3(1, n), &lazy_take_funcs);
}

Как Enumerable#take, но операция выполняется по цепочке лениво.

Также имеет псевдонимы: _enumerable_take

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

static VALUE
lazy_take_while(VALUE obj)
{
    LAZY_NEED_BLOCK(take_while);
    return lazy_add_method(obj, 0, 0, Qnil, Qnil, &lazy_take_while_funcs);
}

Как Enumerable#take_while, но операция выполняется по цепочке лениво.

Также имеет псевдонимы: _enumerable_take_while

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

static VALUE
lazy_to_a(VALUE self)
{
}

Преобразует lazy перечислитель в массив. См. Enumerable#to_a.

Также имеет псевдонимы: force

to_enum(method = :each, *args) → lazy_enum Показать исходный код

to_enum(method = :each, *args) {|*args| block } → lazy_enum

static VALUE
lazy_to_enum(int argc, VALUE *argv, VALUE self)
{
    VALUE lazy, meth = sym_each, super_meth;

    if (argc > 0) {
        --argc;
        meth = *argv++;
    }
    if (RTEST((super_meth = rb_hash_aref(lazy_use_super_method, meth)))) {
        meth = super_meth;
    }
    lazy = lazy_to_enum_i(self, meth, argc, argv, 0, rb_keyword_given_p());
    if (rb_block_given_p()) {
        RB_OBJ_WRITE(lazy, &enumerator_ptr(lazy)->size, rb_block_proc());
    }
    return lazy;
}

Например, продолжая пример из Object#to_enum:

# See Object#to_enum for the definition of repeat
r = 1..Float::INFINITY
r.repeat(2).first(5) # => [1, 1, 2, 2, 3]
r.repeat(2).class # => Enumerator
r.repeat(2).map{|n| n ** 2}.first(5) # => endless loop!
# works naturally on lazy enumerator:
r.lazy.repeat(2).class # => Enumerator::Lazy
r.lazy.repeat(2).map{|n| n ** 2}.first(5) # => [1, 1, 4, 4, 9]

Также имеет псевдонимы: enum_for

uniq → lazy_enumerator Показать исходный код

uniq { |item| block } → lazy_enumerator

static VALUE
lazy_uniq(VALUE obj)
{
    const lazyenum_funcs *const funcs =
        rb_block_given_p() ? &lazy_uniq_iter_funcs : &lazy_uniq_funcs;
    return lazy_add_method(obj, 0, 0, Qnil, Qnil, funcs);
}

Как Enumerable#uniq, но операция выполняется по цепочке лениво.

Также имеет псевдонимы: _enumerable_uniq

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

with_index(offset = 0)

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

    rb_scan_args(argc, argv, "01", &memo);
    if (NIL_P(memo))
        memo = LONG2NUM(0);

    return lazy_add_method(obj, 0, 0, memo, rb_ary_new_from_values(1, &memo), &lazy_with_index_funcs);
}

Если передан блок, возвращает ленивый перечислитель, который перебирает элементы, передавая каждый из них блоку вместе с индексом, начинающимся с offset, и возвращает ленивый перечислитель, выдающий те же значения (без индекса).

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

offset: начальный индекс

См. Enumerator#with_index.

zip(arg, ...) → lazy_enumerator Показать исходный код

zip(arg, ...) { |arr| block } → nil

static VALUE
lazy_zip(int argc, VALUE *argv, VALUE obj)
{
    VALUE ary, v;
    long i;
    const lazyenum_funcs *funcs = &lazy_zip_funcs[1];

    if (rb_block_given_p()) {
        return rb_call_super(argc, argv);
    }

    ary = rb_ary_new2(argc);
    for (i = 0; i < argc; i++) {
        v = rb_check_array_type(argv[i]);
        if (NIL_P(v)) {
            for (; i < argc; i++) {
                if (!rb_respond_to(argv[i], id_each)) {
                    rb_raise(rb_eTypeError, "wrong argument type %"PRIsVALUE" (must respond to :each)",
                             rb_obj_class(argv[i]));
                }
            }
            ary = rb_ary_new4(argc, argv);
            funcs = &lazy_zip_funcs[0];
            break;
        }
        rb_ary_push(ary, v);
    }

    return lazy_add_method(obj, 0, 0, ary, ary, funcs);
}

Как Enumerable#zip, но операция выполняется по цепочке лениво. Однако, если методу zip передан блок, значения перечисляются сразу.

Также имеет псевдонимы: _enumerable_zip

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

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

with_index(offset = 0)

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

    rb_check_arity(argc, 0, 1);
    RETURN_SIZED_ENUMERATOR(obj, argc, argv, enumerator_enum_size);
    memo = (!argc || NIL_P(memo = argv[0])) ? INT2FIX(0) : rb_to_int(memo);
    return enumerator_block_call(obj, enumerator_with_index_i, (VALUE)MEMO_NEW(memo, 0, 0));
}

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

offset: начальный индекс

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