Enumerator::Lazy

Class

Lazy

Class Methods

Lazy.new(obj, size=nil) { |yielder, *values| ... }

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

    rb_check_arity(argc, 1, 2);
    if (!rb_block_given_p()) {
        rb_raise(rb_eArgError, "tried to call lazy new without a block");
    }
    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);
    rb_ivar_set(self, id_receiver, obj);

    return self;
}

Creates a new Lazy enumerator. When the enumerator is actually enumerated (e.g. by calling force), obj will be enumerated and each value passed to the given block. The block can yield values back using yielder. For example, to create a method filter_map in both lazy and non-lazy fashions:

module Enumerable
  def filter_map(&block)
    map(&block).compact
  end
end

class Enumerator::Lazy
  def filter_map
    Lazy.new(self) do |yielder, *values|
      result = yield *values
      yielder << result if result
    end
  end
end

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

Instance Methods

chunk(*args)

enumerator.c View on GitHub

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

No documentation available

chunk_while(*args)

enumerator.c View on GitHub

An alias for chunk

collect

enumerator.c View on GitHub

An alias for map

lazy.collect_concat { |obj| block } → a_lazy_enumerator

enumerator.c View on GitHub

An alias for flat_map

drop(p1)

enumerator.c View on GitHub

          
            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);
}

No documentation available

drop_while

enumerator.c View on GitHub

          
            static VALUE
lazy_drop_while(VALUE obj)
{
    if (!rb_block_given_p()) {
        rb_raise(rb_eArgError, "tried to call lazy drop_while without a block");
    }

    return lazy_add_method(obj, 0, 0, Qfalse, Qnil, &lazy_drop_while_funcs);
}

No documentation available

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

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

enumerator.c View on GitHub

An alias for to_enum

filter

enumerator.c View on GitHub

An alias for select

find_all

enumerator.c View on GitHub

An alias for select

lazy.flat_map { |obj| block } → a_lazy_enumerator

enumerator.c View on GitHub

          
            static VALUE
lazy_flat_map(VALUE obj)
{
    if (!rb_block_given_p()) {
        rb_raise(rb_eArgError, "tried to call lazy flat_map without a block");
    }

    return lazy_set_method(rb_block_call(rb_cLazy, id_new, 1, &obj,
                                         lazy_flat_map_proc, 0),
                           Qnil, 0);
}

Returns a new lazy enumerator with the concatenated results of running block once for every element in lazy.

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

A value x returned by block is decomposed if either of the following conditions is true:

a) <i>x</i> responds to both each and force, which means that
   <i>x</i> is a lazy enumerator.
b) <i>x</i> is an array or responds to to_ary.

Otherwise, x is contained as-is in the return value.

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

lazy.force → array

enumerator.c View on GitHub

An alias for to_a

grep(p1)

enumerator.c View on GitHub

          
            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);
}

No documentation available

grep_v(p1)

enumerator.c View on GitHub

          
            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);
}

No documentation available

lazy

enumerator.c View on GitHub

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

No documentation available

map

enumerator.c View on GitHub

          
            static VALUE
lazy_map(VALUE obj)
{
    if (!rb_block_given_p()) {
        rb_raise(rb_eArgError, "tried to call lazy map without a block");
    }

    return lazy_add_method(obj, 0, 0, Qnil, Qnil, &lazy_map_funcs);
}

No documentation available

reject

enumerator.c View on GitHub

          
            static VALUE
lazy_reject(VALUE obj)
{
    if (!rb_block_given_p()) {
        rb_raise(rb_eArgError, "tried to call lazy reject without a block");
    }

    return lazy_add_method(obj, 0, 0, Qnil, Qnil, &lazy_reject_funcs);
}

No documentation available

select

enumerator.c View on GitHub

          
            static VALUE
lazy_select(VALUE obj)
{
    if (!rb_block_given_p()) {
        rb_raise(rb_eArgError, "tried to call lazy select without a block");
    }

    return lazy_add_method(obj, 0, 0, Qnil, Qnil, &lazy_select_funcs);
}

No documentation available

slice_after(*args)

enumerator.c View on GitHub

An alias for chunk

slice_before(*args)

enumerator.c View on GitHub

An alias for chunk

slice_when(*args)

enumerator.c View on GitHub

An alias for chunk

take(p1)

enumerator.c View on GitHub

          
            static VALUE
lazy_take(VALUE obj, VALUE n)
{
    long len = NUM2LONG(n);
    int argc = 0;
    VALUE argv[2];

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

    if (len == 0) {
       argv[0] = sym_cycle;
       argv[1] = INT2NUM(0);
       argc = 2;
    }

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

No documentation available

take_while

enumerator.c View on GitHub

          
            static VALUE
lazy_take_while(VALUE obj)
{
    if (!rb_block_given_p()) {
        rb_raise(rb_eArgError, "tried to call lazy take_while without a block");
    }

    return lazy_add_method(obj, 0, 0, Qnil, Qnil, &lazy_take_while_funcs);
}

No documentation available

lazy.to_a → array

enumerator.c View on GitHub

          
            static VALUE lazy_to_a(VALUE self)
{
}

Expands lazy enumerator to an array. See Enumerable#to_a.

lzy.to_enum(method = :each, *args) → lazy_enum

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

enumerator.c View on GitHub

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

    if (argc > 0) {
        --argc;
        meth = *argv++;
    }
    lazy = lazy_to_enum_i(self, meth, argc, argv, 0);
    if (rb_block_given_p()) {
        enumerator_ptr(lazy)->size = rb_block_proc();
    }
    return lazy;
}

Similar to Kernel#to_enum, except it returns a lazy enumerator. This makes it easy to define Enumerable methods that will naturally remain lazy if called from a lazy enumerator.

For example, continuing from the example in Kernel#to_enum:

# See Kernel#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]

uniq

enumerator.c View on GitHub

          
            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);
}

No documentation available

zip(*args)

enumerator.c View on GitHub

          
            static VALUE
lazy_zip(int argc, VALUE *argv, VALUE obj)
{
    VALUE ary, v;
    long i;
    rb_block_call_func *func = lazy_zip_arrays_func;

    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);
            func = lazy_zip_func;
            break;
        }
        rb_ary_push(ary, v);
    }

    return lazy_set_method(rb_block_call(rb_cLazy, id_new, 1, &obj,
                                         func, ary),
                           ary, lazy_receiver_size);
}

No documentation available

Enumerator::Lazy

Lazy.new(obj, size=nil) { |yielder, *values| ... }

chunk(*args)

chunk_while(*args)

collect

lazy.collect_concat { |obj| block } → a_lazy_enumerator

drop(p1)

drop_while

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

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

filter

find_all

lazy.flat_map { |obj| block } → a_lazy_enumerator

lazy.force → array

grep(p1)

grep_v(p1)

lazy

map

reject

select

slice_after(*args)

slice_before(*args)

slice_when(*args)

take(p1)

take_while

lazy.to_a → array

lzy.to_enum(method = :each, *args) → lazy_enum

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

uniq

zip(*args)

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

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