0001-Implement-Enumerator-Chain-and-Enumerator-chain-Feat.patch - Ruby master - Ruby Issue Tracking System

Feature #15144 » 0001-Implement-Enumerator-Chain-and-Enumerator-chain-Feat.patch

knu (Akinori MUSHA), 11/21/2018 06:12 AM

     ************************************************/
     #include "ruby/ruby.h"
     #include "internal.h"
     #include "id.h"
-...
     static VALUE generator_allocate(VALUE klass);
     static VALUE generator_init(VALUE obj, VALUE proc);
     static VALUE rb_cEnumChain;
     struct enum_chain {
         VALUE enums;
         long pos;
     };
     static VALUE rb_cArithSeq;
     /*
-...
         return rb_attr_get(self, id_result);
+    }
     /*
      * Document-class: Enumerator::Chain
+     *
      * Enumerator::Chain is a subclass of Enumerator, which represents a
      * chain of enumerables that works as a single enumerator.
      */
     static void
     enum_chain_mark(void *p)
+    {
         struct enum_chain *ptr = p;
         rb_gc_mark(ptr->enums);
+    }
     #define enum_chain_free RUBY_TYPED_DEFAULT_FREE
     static size_t
     enum_chain_memsize(const void *p)
+    {
         return sizeof(struct enum_chain);
+    }
     static const rb_data_type_t enum_chain_data_type = {
         "chain",
+        {
     	enum_chain_mark,
     	enum_chain_free,
     	enum_chain_memsize,
         },
 , 0, RUBY_TYPED_FREE_IMMEDIATELY
     };
     static struct enum_chain *
     enum_chain_ptr(VALUE obj)
+    {
         struct enum_chain *ptr;
         TypedData_Get_Struct(obj, struct enum_chain, &enum_chain_data_type, ptr);
         if (!ptr || ptr->enums == Qundef) {
     	rb_raise(rb_eArgError, "uninitialized chain");
+        }
         return ptr;
+    }
     /* :nodoc: */
     static VALUE
     enum_chain_allocate(VALUE klass)
+    {
         struct enum_chain *ptr;
         VALUE obj;
         obj = TypedData_Make_Struct(klass, struct enum_chain, &enum_chain_data_type, ptr);
         ptr->enums = Qundef;
         ptr->pos = -1;
         return obj;
+    }
     /*
      * call-seq:
      *   Enumerator::Chain.new(*enums) -> enum
      *   Enumerator.chain(*enums) -> enum
+     *
      * Generates an Enumerator::Chain object from the given
      * enumerable objects.
+     *
      *   e = Enumerator.chain(1..3, [4, 5])
      *   e.to_a #=> [1, 2, 3, 4, 5]
      */
     static VALUE
     enum_chain_initialize(VALUE obj, VALUE enums)
+    {
         struct enum_chain *ptr;
         rb_check_frozen(obj);
         TypedData_Get_Struct(obj, struct enum_chain, &enum_chain_data_type, ptr);
         if (!ptr) rb_raise(rb_eArgError, "unallocated chain");
         ptr->enums = rb_obj_freeze(enums);
         ptr->pos = -1;
         return obj;
+    }
     /* :nodoc: */
     static VALUE
     enum_chain_init_copy(VALUE obj, VALUE orig)
+    {
         struct enum_chain *ptr0, *ptr1;
         if (!OBJ_INIT_COPY(obj, orig)) return obj;
         ptr0 = enum_chain_ptr(orig);
         TypedData_Get_Struct(obj, struct enum_chain, &enum_chain_data_type, ptr1);
         if (!ptr1) rb_raise(rb_eArgError, "unallocated chain");
         ptr1->enums = ptr0->enums;
         ptr1->pos = ptr0->pos;
         return obj;
+    }
     static VALUE
     enum_chain_total_size(VALUE enums)
+    {
         VALUE total = INT2FIX(0);
         RARRAY_PTR_USE(enums, ptr, {
             long i;
             for (i = 0; i < RARRAY_LEN(enums); i++) {
                 VALUE size = enum_size(ptr[i]);
                 if (NIL_P(size) || (RB_TYPE_P(size, T_FLOAT) && isinf(NUM2DBL(size)))) {
                     return size;
+                }
                 if (!RB_INTEGER_TYPE_P(size)) {
                     return Qnil;
+                }
                 total = rb_funcall(total, '+', 1, size);
+            }
         });
         return total;
+    }
     /*
      * call-seq:
      *   obj.size -> integer
+     *
      * Returns the total size of the enumerator chain calculated by
      * summing up the size of each enumerable in the chain.  If any of the
      * enumerables reports its size as nil or Float::INFINITY, that value
      * is returned as the total size.
      */
     static VALUE
     enum_chain_size(VALUE obj)
+    {
         return enum_chain_total_size(enum_chain_ptr(obj)->enums);
+    }
     static VALUE
     enum_chain_enum_size(VALUE obj, VALUE args, VALUE eobj)
+    {
         return enum_chain_size(obj);
+    }
     static VALUE
     enum_chain_yield_block(VALUE arg, VALUE block, int argc, VALUE *argv)
+    {
         return rb_funcallv(block, rb_intern("call"), argc, argv);
+    }
     static VALUE
     enum_chain_enum_no_size(VALUE obj, VALUE args, VALUE eobj)
+    {
         return Qnil;
+    }
     /*
      * call-seq:
      *   obj.each(*args) { |...| ... } -> obj
      *   obj.each(*args) -> enumerator
+     *
      * Iterates over the first enumerable by calling the "each" method on
      * it with the given arguments until it is exhausted, then proceeds to
      * the next enumerable, until all of the enumerables are exhausted.
+     *
      * If no block is given, returns an enumerator.
      */
     static VALUE
     enum_chain_each(int argc, VALUE *argv, VALUE obj)
+    {
         VALUE enums, block;
         struct enum_chain *objptr;
         RETURN_SIZED_ENUMERATOR(obj, argc, argv, argc > 0 ? enum_chain_enum_no_size : enum_chain_enum_size);
         objptr = enum_chain_ptr(obj);
         enums = objptr->enums;
         block = rb_block_proc();
         RARRAY_PTR_USE(enums, ptr, {
             long i;
             for (i = 0; i < RARRAY_LEN(enums); i++) {
                 objptr->pos = i;
                 rb_block_call(ptr[i], id_each, argc, argv, enum_chain_yield_block, block);
+            }
         });
         return obj;
+    }
     /*
      * call-seq:
      *   obj.rewind -> obj
+     *
      * Rewinds the enumerator chain by calling the "rewind" method on each
      * enumerable in reverse order.  Each call is performed only if the
      * enumerable responds to the method.
      */
     static VALUE
     enum_chain_rewind(VALUE obj)
+    {
         struct enum_chain *objptr = enum_chain_ptr(obj);
         VALUE enums = objptr->enums;
         RARRAY_PTR_USE(enums, ptr, {
             long i;
             for (i = objptr->pos; 0 <= i && i < RARRAY_LEN(enums); objptr->pos = --i) {
                 rb_check_funcall(ptr[i], id_rewind, 0, 0);
+            }
         });
         return obj;
+    }
     static VALUE
     inspect_enum_chain(VALUE obj, VALUE dummy, int recur)
+    {
         VALUE klass = rb_obj_class(obj);
         struct enum_chain *ptr;
         TypedData_Get_Struct(obj, struct enum_chain, &enum_chain_data_type, ptr);
         if (!ptr || ptr->enums == Qundef) {
     	return rb_sprintf("#<%"PRIsVALUE": uninitialized>", rb_class_path(klass));
+        }
         if (recur) {
     	return rb_sprintf("#<%"PRIsVALUE": ...>", rb_class_path(klass));
+        }
         return rb_sprintf("#<%"PRIsVALUE": %+"PRIsVALUE">", rb_class_path(klass), ptr->enums);
+    }
     /*
      * call-seq:
      *   obj.inspect -> string
+     *
      * Returns a printable version of the enumerator chain.
      */
     static VALUE
     enum_chain_inspect(VALUE obj)
+    {
         return rb_exec_recursive(inspect_enum_chain, obj, 0);
+    }
     /*
      * call-seq:
      *   e.chain(*enums) -> enumerator
+     *
      * Returns an Enumerator::Chain object generated from this enumerator
      * and given enumerables.
+     *
      *   e = (1..3).each.chain([4, 5])
      *   e.to_a #=> [1, 2, 3, 4, 5]
      */
     static VALUE
     enumerator_s_chain(int argc, VALUE enums)
+    {
         return enum_chain_initialize(enum_chain_allocate(rb_cEnumChain), enums);
+    }
     /*
      * call-seq:
      *   e.chain(*enums) -> enumerator
+     *
      * Returns an Enumerator::Chain object generated from this enumerator
      * and given enumerables.
+     *
      *   e = (1..3).each.chain([4, 5])
      *   e.to_a #=> [1, 2, 3, 4, 5]
      */
     static VALUE
     enumerator_chain(int argc, VALUE *argv, VALUE obj)
+    {
         VALUE enums = rb_ary_new_from_values(1, &obj);
         rb_ary_cat(enums, argv, argc);
         return enum_chain_initialize(enum_chain_allocate(rb_cEnumChain), enums);
+    }
     /*
      * call-seq:
      *   e + enum        -> enumerator
+     *
      * Returns an Enumerator::Chain object generated from this enumerator
      * and a given enumerable.
+     *
      *   e = (1..3).each + [4, 5]
      *   e.to_a #=> [1, 2, 3, 4, 5]
      */
     static VALUE
     enumerator_plus(VALUE obj, VALUE eobj)
+    {
         VALUE enums = rb_ary_new_from_args(2, obj, eobj);
         return enum_chain_initialize(enum_chain_allocate(rb_cEnumChain), enums);
+    }
     /*
      * Document-class: Enumerator::ArithmeticSequence
+     *
-...
         rb_define_method(rb_cEnumerator, "rewind", enumerator_rewind, 0);
         rb_define_method(rb_cEnumerator, "inspect", enumerator_inspect, 0);
         rb_define_method(rb_cEnumerator, "size", enumerator_size, 0);
         rb_define_method(rb_cEnumerator, "chain", enumerator_chain, -1);
         rb_define_method(rb_cEnumerator, "+", enumerator_plus, 1);
         /* Lazy */
         rb_cLazy = rb_define_class_under(rb_cEnumerator, "Lazy", rb_cEnumerator);
-...
         rb_define_method(rb_cYielder, "yield", yielder_yield, -2);
         rb_define_method(rb_cYielder, "<<", yielder_yield_push, 1);
         /* Chain */
         rb_cEnumChain = rb_define_class_under(rb_cEnumerator, "Chain", rb_cEnumerator);
         rb_define_alloc_func(rb_cEnumChain, enum_chain_allocate);
         rb_define_method(rb_cEnumChain, "initialize", enum_chain_initialize, -2);
         rb_define_method(rb_cEnumChain, "initialize_copy", enum_chain_init_copy, 1);
         rb_define_method(rb_cEnumChain, "each", enum_chain_each, -1);
         rb_define_method(rb_cEnumChain, "size", enum_chain_size, 0);
         rb_define_method(rb_cEnumChain, "rewind", enum_chain_rewind, 0);
         rb_define_method(rb_cEnumChain, "inspect", enum_chain_inspect, 0);
         rb_define_singleton_method(rb_cEnumerator, "chain", enumerator_s_chain, -2);
         /* ArithmeticSequence */
         rb_cArithSeq = rb_define_class_under(rb_cEnumerator, "ArithmeticSequence", rb_cEnumerator);
         rb_undef_alloc_func(rb_cArithSeq);

         assert_equal([0, 1], u.force)
         assert_equal([0, 1], u.force)
       end
       def test_chain_and_plus
         a = (1..5).each
         e1 = a.chain()
         assert_kind_of(Enumerator::Chain, e1)
         assert_equal(5, e1.size)
         ary = []
         e1.each { |x| ary << x }
         assert_equal([1, 2, 3, 4, 5], ary)
         e2 = a + [6, 7, 8]
         assert_kind_of(Enumerator::Chain, e2)
         assert_equal(8, e2.size)
         ary = []
         e2.each { |x| ary << x }
         assert_equal([1, 2, 3, 4, 5, 6, 7, 8], ary)
         e3 = a.chain([6, 7], 8.step)
         assert_kind_of(Enumerator::Chain, e3)
         assert_equal(Float::INFINITY, e3.size)
         ary = []
         e3.take(10).each { |x| ary << x }
         assert_equal([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], ary)
         # `a + b + c` should not return `Enumerator.chain(a, b, c)`
         # because it is expected that `(a + b).each` be called.
         e4 = e2.dup
         class << e4
           attr_reader :each_is_called
           def each
             super
             @each_is_called = true
           end
         end
         e5 = e4 + 9.step
         assert_kind_of(Enumerator::Chain, e5)
         assert_equal(Float::INFINITY, e5.size)
         ary = []
         e5.take(10).each { |x| ary << x }
         assert_equal([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], ary)
         assert_equal(true, e4.each_is_called)
       end
       def test_chained_enums
         a = (1..5).each
         e0 = Enumerator::Chain.new()
         assert_kind_of(Enumerator::Chain, e0)
         assert_equal(0, e0.size)
         ary = []
         e0.each { |x| ary << x }
         assert_equal([], ary)
         e1 = Enumerator::Chain.new(a)
         assert_kind_of(Enumerator::Chain, e1)
         assert_equal(5, e1.size)
         ary = []
         e1.each { |x| ary << x }
         assert_equal([1, 2, 3, 4, 5], ary)
         e2 = Enumerator.chain(a, [6, 7, 8])
         assert_kind_of(Enumerator::Chain, e2)
         assert_equal(8, e2.size)
         ary = []
         e2.each { |x| ary << x }
         assert_equal([1, 2, 3, 4, 5, 6, 7, 8], ary)
         e3 = Enumerator.chain(a, [6, 7], 8.step)
         assert_kind_of(Enumerator::Chain, e3)
         assert_equal(Float::INFINITY, e3.size)
         ary = []
         e3.take(10).each { |x| ary << x }
         assert_equal([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], ary)
         e4 = Enumerator.chain(a, Enumerator.new { |y| y << 6 << 7 << 8 })
         assert_kind_of(Enumerator::Chain, e4)
         assert_equal(nil, e4.size)
         ary = []
         e4.each { |x| ary << x }
         assert_equal([1, 2, 3, 4, 5, 6, 7, 8], ary)
         e5 = Enumerator.chain(e1, e2)
         assert_kind_of(Enumerator::Chain, e5)
         assert_equal(13, e5.size)
         ary = []
         e5.each { |x| ary << x }
         assert_equal([1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 6, 7, 8], ary)
         rewound = []
         e1.define_singleton_method(:rewind) { rewound << object_id }
         e2.define_singleton_method(:rewind) { rewound << object_id }
         e5.rewind
         assert_equal(rewound, [e2.object_id, e1.object_id])
         rewound = []
         a = [1]
         e6 = Enumerator.chain(a)
         a.define_singleton_method(:rewind) { rewound << object_id }
         e6.rewind
         assert_equal(rewound, [])
         assert_equal(
           '#<Enumerator::Chain: [' +
             '#<Enumerator::Chain: [' +
               '#<Enumerator: 1..5:each>' +
             ']>, ' +
             '#<Enumerator::Chain: [' +
               '#<Enumerator: 1..5:each>, ' +
               '[6, 7, 8]' +
             ']>' +
           ']>',
           e5.inspect
+        )
       end
     end
+    -

Project

General

Profile

Ruby » Ruby master

Feature #15144 » 0001-Implement-Enumerator-Chain-and-Enumerator-chain-Feat.patch