shugo	2012-03-15 18:25:03 +0900 (Thu, 15 Mar 2012)

  New Revision: 35041

  http://svn.ruby-lang.org/cgi-bin/viewvc.cgi?view=rev&revision=35041

  Log:
    * enumerator.c (lazy_zip, lazy_cycle): Enumerator::Lazy#{zip,cycle}
      should be eager when a block is given, to be consistent with
      Enumerable#{zip,cycle}.

  Modified files:
    trunk/ChangeLog
    trunk/enumerator.c
    trunk/test/ruby/test_lazy_enumerator.rb

Index: ChangeLog
===================================================================
--- ChangeLog	(revision 35040)
+++ ChangeLog	(revision 35041)
@@ -1,3 +1,9 @@
+Thu Mar 15 18:19:53 2012  Shugo Maeda  <shugo@r...>
+
+	* enumerator.c (lazy_zip, lazy_cycle): Enumerator::Lazy#{zip,cycle}
+	  should be eager when a block is given, to be consistent with
+	  Enumerable#{zip,cycle}.
+
 Thu Mar 15 17:45:27 2012  Shugo Maeda  <shugo@r...>
 
 	* enumerator.c (InitVM_Enumerator): renamed Enumerable::Lazy to
Index: enumerator.c
===================================================================
--- enumerator.c	(revision 35040)
+++ enumerator.c	(revision 35041)
@@ -1374,24 +1374,6 @@
 }
 
 static VALUE
-lazy_zip_func_i(VALUE val, VALUE arg, int argc, VALUE *argv)
-{
-    VALUE yielder, ary, v, result;
-    long i;
-
-    yielder = argv[0];
-    ary = rb_ary_new2(RARRAY_LEN(arg) + 1);
-    rb_ary_push(ary, argv[1]);
-    for (i = 0; i < RARRAY_LEN(arg); i++) {
-	v = rb_funcall(RARRAY_PTR(arg)[i], id_next, 0);
-	rb_ary_push(ary, v);
-    }
-    result = rb_yield(ary);
-    rb_funcall(yielder, id_yield, 1, result);
-    return Qnil;
-}
-
-static VALUE
 lazy_zip_func(VALUE val, VALUE arg, int argc, VALUE *argv)
 {
     VALUE yielder, ary, v;
@@ -1414,14 +1396,15 @@
     VALUE ary;
     int i;
 
+    if (rb_block_given_p()) {
+	return rb_call_super(argc, argv);
+    }
     ary = rb_ary_new2(argc);
     for (i = 0; i < argc; i++) {
 	rb_ary_push(ary, rb_funcall(argv[i], id_lazy, 0));
     }
 
-    return rb_block_call(rb_cLazy, id_new, 1, &obj,
-			 rb_block_given_p() ? lazy_zip_func_i :  lazy_zip_func,
-			 ary);
+    return rb_block_call(rb_cLazy, id_new, 1, &obj, lazy_zip_func, ary);
 }
 
 static VALUE
@@ -1528,6 +1511,9 @@
     VALUE args;
     int len = rb_long2int((long)argc + 2);
 
+    if (rb_block_given_p()) {
+	return rb_call_super(argc, argv);
+    }
     args = rb_ary_tmp_new(len);
     rb_ary_push(args, obj);
     rb_ary_push(args, sym_cycle);
@@ -1535,8 +1521,7 @@
 	rb_ary_cat(args, argv, argc);
     }
     return rb_block_call(rb_cLazy, id_new, len, RARRAY_PTR(args),
-			 rb_block_given_p() ? lazy_map_func : lazy_cycle_func,
-			 args /* prevent from GC */);
+			 lazy_cycle_func, args /* prevent from GC */);
 }
 
 static VALUE
Index: test/ruby/test_lazy_enumerator.rb
===================================================================
--- test/ruby/test_lazy_enumerator.rb	(revision 35040)
+++ test/ruby/test_lazy_enumerator.rb	(revision 35041)
@@ -139,9 +139,12 @@
   end
 
   def test_zip_with_block
+    # zip should be eager when a block is given
     a = Step.new(1..3)
-    assert_equal(["a", 1], a.lazy.zip("a".."c") {|x, y| [y, x]}.first)
-    assert_equal(1, a.current)
+    ary = []
+    assert_equal(nil, a.lazy.zip("a".."c") {|x, y| ary << [x, y]})
+    assert_equal(a.zip("a".."c"), ary)
+    assert_equal(3, a.current)
   end
 
   def test_take
@@ -190,10 +193,17 @@
     assert_equal(3, a.current)
     assert_equal("1", a.lazy.cycle(2).map(&:to_s).first)
     assert_equal(1, a.current)
-    assert_equal("1", a.lazy.cycle(2, &:to_s).first)
-    assert_equal(1, a.current)
   end
 
+  def test_cycle_with_block
+    # cycle should be eager when a block is given
+    a = Step.new(1..3)
+    ary = []
+    assert_equal(nil, a.lazy.cycle(2) {|i| ary << i})
+    assert_equal(a.cycle(2).to_a, ary)
+    assert_equal(3, a.current)
+  end
+
   def test_force
     assert_equal([1, 2, 3], (1..Float::INFINITY).lazy.take(3).force)
   end

--
ML: ruby-changes@q...
Info: http://www.atdot.net/~ko1/quickml/