rhodes 3.1.1 → 3.2.0.beta.1

data/platform/shared/ruby/array.c

@@ -25,7 +25,7 @@ VALUE rb_cArray;
 static ID id_cmp;
 
 #define ARY_DEFAULT_SIZE 16
-#define ARY_MAX_SIZE (LONG_MAX / sizeof(VALUE))
+#define ARY_MAX_SIZE (LONG_MAX / (int)sizeof(VALUE))
 
 void
 rb_mem_clear(register VALUE *mem, register long size)
@@ -45,10 +45,10 @@ memfill(register VALUE *mem, register long size, register VALUE val)
 
 # define ARY_SHARED_P(ary) \
     (assert(!FL_TEST(ary, ELTS_SHARED) || !FL_TEST(ary, RARRAY_EMBED_FLAG)), \
-     FL_TEST(ary,ELTS_SHARED))
+     FL_TEST(ary,ELTS_SHARED)!=0)
 # define ARY_EMBED_P(ary) \
     (assert(!FL_TEST(ary, ELTS_SHARED) || !FL_TEST(ary, RARRAY_EMBED_FLAG)), \
-     FL_TEST(ary, RARRAY_EMBED_FLAG))
+     FL_TEST(ary, RARRAY_EMBED_FLAG)!=0)
 
 #define ARY_HEAP_PTR(a) (assert(!ARY_EMBED_P(a)), RARRAY(a)->as.heap.ptr)
 #define ARY_HEAP_LEN(a) (assert(!ARY_EMBED_P(a)), RARRAY(a)->as.heap.len)
@@ -95,7 +95,7 @@ memfill(register VALUE *mem, register long size, register VALUE val)
         ARY_SET_HEAP_LEN(ary, n); \
     } \
     assert(RARRAY_LEN(ary) == n); \
-} while (0) 
+} while (0)
 #define ARY_INCREASE_PTR(ary, n) do  { \
     assert(!ARY_EMBED_P(ary)); \
     assert(!OBJ_FROZEN(ary)); \
@@ -144,39 +144,55 @@ static void
 ary_resize_capa(VALUE ary, long capacity)
 {
     assert(RARRAY_LEN(ary) <= capacity);
-    assert(!OBJ_FROZEN(ary)); 
-    assert(!ARY_SHARED_P(ary)); 
+    assert(!OBJ_FROZEN(ary));
+    assert(!ARY_SHARED_P(ary));
     if (capacity > RARRAY_EMBED_LEN_MAX) {
         if (ARY_EMBED_P(ary)) {
-            long len = ARY_EMBED_LEN(ary); 
+            long len = ARY_EMBED_LEN(ary);
             VALUE *ptr = ALLOC_N(VALUE, (capacity));
-            MEMCPY(ptr, ARY_EMBED_PTR(ary), VALUE, len); 
-            FL_UNSET_EMBED(ary); 
-            ARY_SET_PTR(ary, ptr); 
-            ARY_SET_HEAP_LEN(ary, len); 
+            MEMCPY(ptr, ARY_EMBED_PTR(ary), VALUE, len);
+            FL_UNSET_EMBED(ary);
+            ARY_SET_PTR(ary, ptr);
+            ARY_SET_HEAP_LEN(ary, len);
         }
-        else { 
+        else {
             REALLOC_N(RARRAY(ary)->as.heap.ptr, VALUE, (capacity));
         }
-        ARY_SET_CAPA(ary, (capacity)); 
+        ARY_SET_CAPA(ary, (capacity));
     }
     else {
         if (!ARY_EMBED_P(ary)) {
-            long len = RARRAY_LEN(ary); 
-            VALUE *ptr = RARRAY_PTR(ary); 
-            MEMCPY(RARRAY(ary)->as.ary, ptr, VALUE, len); 
-            FL_SET_EMBED(ary); 
-            ARY_SET_LEN(ary, len); 
-            xfree(ptr); 
+            long len = RARRAY_LEN(ary);
+            VALUE *ptr = RARRAY_PTR(ary);
+            if (len > capacity) len = capacity;
+            MEMCPY(RARRAY(ary)->as.ary, ptr, VALUE, len);
+            FL_SET_EMBED(ary);
+            ARY_SET_LEN(ary, len);
+            xfree(ptr);
         }
     }
 }
 
+static void
+ary_double_capa(VALUE ary, long min)
+{
+    long new_capa = ARY_CAPA(ary) / 2;
+
+    if (new_capa < ARY_DEFAULT_SIZE) {
+	new_capa = ARY_DEFAULT_SIZE;
+    }
+    if (new_capa >= ARY_MAX_SIZE - min) {
+	new_capa = (ARY_MAX_SIZE - min) / 2;
+    }
+    new_capa += min;
+    ary_resize_capa(ary, new_capa);
+}
+
 static void
 rb_ary_decrement_share(VALUE shared)
 {
     if (shared) {
-	int num = ARY_SHARED_NUM(shared) - 1;
+	long num = ARY_SHARED_NUM(shared) - 1;
 	if (num == 0) {
 	    rb_ary_free(shared);
 	    rb_gc_force_recycle(shared);
@@ -196,15 +212,17 @@ rb_ary_unshare(VALUE ary)
 }
 
 static inline void
-rb_ary_unshare_safe(VALUE ary) {
+rb_ary_unshare_safe(VALUE ary)
+{
     if (ARY_SHARED_P(ary) && !ARY_EMBED_P(ary)) {
 	rb_ary_unshare(ary);
     }
 }
 
 static VALUE
-rb_ary_increment_share(VALUE shared) {
-    int num = ARY_SHARED_NUM(shared);
+rb_ary_increment_share(VALUE shared)
+{
+    long num = ARY_SHARED_NUM(shared);
     if (num >= 0) {
 	ARY_SET_SHARED_NUM(shared, num + 1);
     }
@@ -260,7 +278,7 @@ rb_ary_freeze(VALUE ary)
 
 /*
  *  call-seq:
- *     array.frozen?  -> true or false
+ *     ary.frozen?  -> true or false
  *
  *  Return <code>true</code> if this array is frozen (or temporarily frozen
  *  while being sorted).
@@ -285,21 +303,21 @@ ary_alloc(VALUE klass)
 }
 
 static VALUE
-ary_new(VALUE klass, long len)
+ary_new(VALUE klass, long capa)
 {
     VALUE ary;
 
-    if (len < 0) {
+    if (capa < 0) {
 	rb_raise(rb_eArgError, "negative array size (or size too big)");
     }
-    if (len > ARY_MAX_SIZE) {
+    if (capa > ARY_MAX_SIZE) {
 	rb_raise(rb_eArgError, "array size too big");
     }
     ary = ary_alloc(klass);
-    if (len > RARRAY_EMBED_LEN_MAX) {
+    if (capa > RARRAY_EMBED_LEN_MAX) {
         FL_UNSET_EMBED(ary);
-        ARY_SET_PTR(ary, ALLOC_N(VALUE, len));
-        ARY_SET_CAPA(ary, len);
+        ARY_SET_PTR(ary, ALLOC_N(VALUE, capa));
+        ARY_SET_CAPA(ary, capa);
         ARY_SET_HEAP_LEN(ary, 0);
     }
 
@@ -307,9 +325,9 @@ ary_new(VALUE klass, long len)
 }
 
 VALUE
-rb_ary_new2(long len)
+rb_ary_new2(long capa)
 {
-    return ary_new(rb_cArray, len);
+    return ary_new(rb_cArray, capa);
 }
 
 
@@ -355,19 +373,38 @@ rb_ary_new4(long n, const VALUE *elts)
 }
 
 VALUE
-rb_ary_tmp_new(long len)
+rb_ary_tmp_new(long capa)
 {
-    return ary_new(0, len);
+    return ary_new(0, capa);
 }
 
 void
 rb_ary_free(VALUE ary)
 {
     if (ARY_OWNS_HEAP_P(ary)) {
-	xfree(RARRAY_PTR(ary));
+	xfree(ARY_HEAP_PTR(ary));
     }
 }
 
+size_t
+rb_ary_memsize(VALUE ary)
+{
+    if (ARY_OWNS_HEAP_P(ary)) {
+	return RARRAY(ary)->as.heap.aux.capa * sizeof(VALUE);
+    }
+    else {
+	return 0;
+    }
+}
+
+static inline void
+ary_discard(VALUE ary)
+{
+    rb_ary_free(ary);
+    RBASIC(ary)->flags |= RARRAY_EMBED_FLAG;
+    RBASIC(ary)->flags &= ~RARRAY_EMBED_LEN_MASK;
+}
+
 static VALUE
 ary_make_shared(VALUE ary)
 {
@@ -375,6 +412,15 @@ ary_make_shared(VALUE ary)
     if (ARY_SHARED_P(ary)) {
 	return ARY_SHARED(ary);
     }
+    else if (ARY_SHARED_ROOT_P(ary)) {
+	return ary;
+    }
+    else if (OBJ_FROZEN(ary)) {
+	ary_resize_capa(ary, ARY_HEAP_LEN(ary));
+	FL_SET_SHARED_ROOT(ary);
+	ARY_SET_SHARED_NUM(ary, 1);
+	return ary;
+    }
     else {
 	NEWOBJ(shared, struct RArray);
 	OBJSETUP(shared, 0, T_ARRAY);
@@ -428,14 +474,14 @@ rb_check_array_type(VALUE ary)
  *  call-seq:
  *     Array.try_convert(obj) -> array or nil
  *
- *  Try to convert <i>obj</i> into an array, using to_ary method.
- *  Returns converted array or nil if <i>obj</i> cannot be converted
- *  for any reason.  This method is to check if an argument is an
- *  array.  
+ *  Try to convert <i>obj</i> into an array, using +to_ary+ method.
+ *  Returns converted array or +nil+ if <i>obj</i> cannot be converted
+ *  for any reason. This method can be used to check if an argument is an
+ *  array.
+ *
+ *     Array.try_convert([1])   #=> [1]
+ *     Array.try_convert("1")   #=> nil
  *
- *     Array.try_convert([1])   # => [1]
- *     Array.try_convert("1")   # => nil
- *     
  *     if tmp = Array.try_convert(arg)
  *       # the argument is an array
  *     elsif tmp = String.try_convert(arg)
@@ -469,22 +515,22 @@ rb_ary_s_try_convert(VALUE dummy, VALUE ary)
  *     Array.new
  *     Array.new(2)
  *     Array.new(5, "A")
- * 
+ *
  *     # only one copy of the object is created
  *     a = Array.new(2, Hash.new)
  *     a[0]['cat'] = 'feline'
  *     a
  *     a[1]['cat'] = 'Felix'
  *     a
- * 
+ *
  *     # here multiple copies are created
  *     a = Array.new(2) { Hash.new }
  *     a[0]['cat'] = 'feline'
  *     a
- * 
+ *
  *     squares = Array.new(5) {|i| i*i}
  *     squares
- * 
+ *
  *     copy = Array.new(squares)
  */
 
@@ -495,7 +541,7 @@ rb_ary_initialize(int argc, VALUE *argv, VALUE ary)
     VALUE size, val;
 
     rb_ary_modify(ary);
-    if (argc ==  0) {
+    if (argc == 0) {
 	if (ARY_OWNS_HEAP_P(ary) && RARRAY_PTR(ary)) {
 	    xfree(RARRAY_PTR(ary));
 	}
@@ -544,8 +590,8 @@ rb_ary_initialize(int argc, VALUE *argv, VALUE ary)
 }
 
 
-/* 
-* Returns a new array populated with the given objects. 
+/*
+* Returns a new array populated with the given objects.
 *
 *   Array.[]( 1, 'a', /^A/ )
 *   Array[ 1, 'a', /^A/ ]
@@ -570,8 +616,8 @@ rb_ary_store(VALUE ary, long idx, VALUE val)
     if (idx < 0) {
 	idx += RARRAY_LEN(ary);
 	if (idx < 0) {
-	    rb_raise(rb_eIndexError, "index %ld out of array",
-		     idx - RARRAY_LEN(ary));
+	    rb_raise(rb_eIndexError, "index %ld too small for array; minimum: %ld",
+		     idx - RARRAY_LEN(ary), -RARRAY_LEN(ary));
 	}
     }
     else if (idx >= ARY_MAX_SIZE) {
@@ -580,16 +626,7 @@ rb_ary_store(VALUE ary, long idx, VALUE val)
 
     rb_ary_modify(ary);
     if (idx >= ARY_CAPA(ary)) {
-	long new_capa = ARY_CAPA(ary) / 2;
-
-	if (new_capa < ARY_DEFAULT_SIZE) {
-	    new_capa = ARY_DEFAULT_SIZE;
-	}
-	if (new_capa >= ARY_MAX_SIZE - idx) {
-	    new_capa = (ARY_MAX_SIZE - idx) / 2;
-	}
-	new_capa += idx;
-	ary_resize_capa(ary, new_capa);
+	ary_double_capa(ary, idx);
     }
     if (idx > RARRAY_LEN(ary)) {
 	rb_mem_clear(RARRAY_PTR(ary) + RARRAY_LEN(ary),
@@ -663,10 +700,12 @@ ary_take_first_or_last(int argc, VALUE *argv, VALUE ary, enum ary_take_pos_flags
     return ary_make_partial(ary, rb_cArray, offset, n);
 }
 
+static VALUE rb_ary_push_1(VALUE ary, VALUE item);
+
 /*
  *  call-seq:
- *     array << obj            -> array
- *  
+ *     ary << obj            -> ary
+ *
  *  Append---Pushes the given object on to the end of this array. This
  *  expression returns the array itself, so several appends
  *  may be chained together.
@@ -679,29 +718,42 @@ ary_take_first_or_last(int argc, VALUE *argv, VALUE ary, enum ary_take_pos_flags
 VALUE
 rb_ary_push(VALUE ary, VALUE item)
 {
-    rb_ary_store(ary, RARRAY_LEN(ary), item);
+    rb_ary_modify(ary);
+    return rb_ary_push_1(ary, item);
+}
+
+static VALUE
+rb_ary_push_1(VALUE ary, VALUE item)
+{
+    long idx = RARRAY_LEN(ary);
+
+    if (idx >= ARY_CAPA(ary)) {
+	ary_double_capa(ary, idx);
+    }
+    RARRAY_PTR(ary)[idx] = item;
+    ARY_SET_LEN(ary, idx + 1);
     return ary;
 }
 
-/* 
+/*
  *  call-seq:
- *     array.push(obj, ... )   -> array
- *  
+ *     ary.push(obj, ... )   -> ary
+ *
  *  Append---Pushes the given object(s) on to the end of this array. This
  *  expression returns the array itself, so several appends
  *  may be chained together.
  *
  *     a = [ "a", "b", "c" ]
- *     a.push("d", "e", "f")  
+ *     a.push("d", "e", "f")
  *             #=> ["a", "b", "c", "d", "e", "f"]
  */
 
 static VALUE
 rb_ary_push_m(int argc, VALUE *argv, VALUE ary)
 {
-    rb_ary_modify_check(ary);
+    rb_ary_modify(ary);
     while (argc--) {
-	rb_ary_push(ary, *argv++);
+	rb_ary_push_1(ary, *argv++);
     }
     return ary;
 }
@@ -725,15 +777,15 @@ rb_ary_pop(VALUE ary)
 
 /*
  *  call-seq:
- *     array.pop    -> obj or nil
- *     array.pop(n) -> array
- *  
- *  Removes the last element from <i>self</i> and returns it, or
+ *     ary.pop    -> obj or nil
+ *     ary.pop(n) -> new_ary
+ *
+ *  Removes the last element from +self+ and returns it, or
  *  <code>nil</code> if the array is empty.
  *
  *  If a number _n_ is given, returns an array of the last n elements
  *  (or less) just like <code>array.slice!(-n, n)</code> does.
- *     
+ *
  *     a = [ "a", "b", "c", "d" ]
  *     a.pop     #=> "d"
  *     a.pop(2)  #=> ["b", "c"]
@@ -774,6 +826,9 @@ rb_ary_shift(VALUE ary)
 	RARRAY_PTR(ary)[0] = Qnil;
 	ary_make_shared(ary);
     }
+    else if (ARY_SHARED_NUM(ARY_SHARED(ary)) == 1) {
+	RARRAY_PTR(ary)[0] = Qnil;
+    }
     ARY_INCREASE_PTR(ary, 1);		/* shift ptr */
     ARY_INCREASE_LEN(ary, -1);
 
@@ -782,16 +837,16 @@ rb_ary_shift(VALUE ary)
 
 /*
  *  call-seq:
- *     array.shift    -> obj or nil
- *     array.shift(n) -> array
- *  
- *  Returns the first element of <i>self</i> and removes it (shifting all
+ *     ary.shift    -> obj or nil
+ *     ary.shift(n) -> new_ary
+ *
+ *  Returns the first element of +self+ and removes it (shifting all
  *  other elements down by one). Returns <code>nil</code> if the array
  *  is empty.
  *
  *  If a number _n_ is given, returns an array of the first n elements
  *  (or less) just like <code>array.slice!(0, n)</code> does.
- *     
+ *
  *     args = [ "-m", "-q", "filename" ]
  *     args.shift     #=> "-m"
  *     args           #=> ["-q", "filename"]
@@ -815,6 +870,9 @@ rb_ary_shift_m(int argc, VALUE *argv, VALUE ary)
     result = ary_take_first_or_last(argc, argv, ary, ARY_TAKE_FIRST);
     n = RARRAY_LEN(result);
     if (ARY_SHARED_P(ary)) {
+	if (ARY_SHARED_NUM(ARY_SHARED(ary)) == 1) {
+	    rb_mem_clear(RARRAY_PTR(ary), n);
+	}
         ARY_INCREASE_PTR(ary, n);
     }
     else {
@@ -827,11 +885,11 @@ rb_ary_shift_m(int argc, VALUE *argv, VALUE ary)
 
 /*
  *  call-seq:
- *     array.unshift(obj, ...)  -> array
- *  
- *  Prepends objects to the front of <i>array</i>.
- *  other elements up one.
- *     
+ *     ary.unshift(obj, ...)  -> ary
+ *
+ *  Prepends objects to the front of +self+,
+ *  moving other elements upwards.
+ *
  *     a = [ "b", "c", "d" ]
  *     a.unshift("a")   #=> ["a", "b", "c", "d"]
  *     a.unshift(1, 2)  #=> [ 1, 2, "a", "b", "c", "d"]
@@ -842,17 +900,17 @@ rb_ary_unshift_m(int argc, VALUE *argv, VALUE ary)
 {
     long len;
 
-    if (argc == 0) return ary;
     rb_ary_modify(ary);
+    if (argc == 0) return ary;
     if (ARY_CAPA(ary) <= (len = RARRAY_LEN(ary)) + argc) {
-	ary_resize_capa(ary, len + argc + ARY_DEFAULT_SIZE);
+	ary_double_capa(ary, len + argc);
     }
 
     /* sliding items */
     MEMMOVE(RARRAY_PTR(ary) + argc, RARRAY_PTR(ary), VALUE, len);
     MEMCPY(RARRAY_PTR(ary), argv, VALUE, argc);
     ARY_INCREASE_LEN(ary, argc);
-    
+
     return ary;
 }
 
@@ -899,21 +957,21 @@ rb_ary_subseq(VALUE ary, long beg, long len)
     return ary_make_partial(ary, klass, beg, len);
 }
 
-/* 
+/*
  *  call-seq:
- *     array[index]                -> obj      or nil
- *     array[start, length]        -> an_array or nil
- *     array[range]                -> an_array or nil
- *     array.slice(index)          -> obj      or nil
- *     array.slice(start, length)  -> an_array or nil
- *     array.slice(range)          -> an_array or nil
+ *     ary[index]                -> obj     or nil
+ *     ary[start, length]        -> new_ary or nil
+ *     ary[range]                -> new_ary or nil
+ *     ary.slice(index)          -> obj     or nil
+ *     ary.slice(start, length)  -> new_ary or nil
+ *     ary.slice(range)          -> new_ary or nil
  *
  *  Element Reference---Returns the element at _index_,
  *  or returns a subarray starting at _start_ and
  *  continuing for _length_ elements, or returns a subarray
  *  specified by _range_.
  *  Negative indices count backward from the end of the
- *  array (-1 is the last element). Returns nil if the index
+ *  array (-1 is the last element). Returns +nil+ if the index
  *  (or starting index) are out of range.
  *
  *     a = [ "a", "b", "c", "d", "e" ]
@@ -965,12 +1023,12 @@ rb_ary_aref(int argc, VALUE *argv, VALUE ary)
     return rb_ary_entry(ary, NUM2LONG(arg));
 }
 
-/* 
+/*
  *  call-seq:
- *     array.at(index)   ->   obj  or nil
+ *     ary.at(index)   ->   obj  or nil
  *
  *  Returns the element at _index_. A
- *  negative index counts from the end of _self_.  Returns +nil+
+ *  negative index counts from the end of +self+.  Returns +nil+
  *  if the index is out of range. See also <code>Array#[]</code>.
  *
  *     a = [ "a", "b", "c", "d", "e" ]
@@ -986,13 +1044,13 @@ rb_ary_at(VALUE ary, VALUE pos)
 
 /*
  *  call-seq:
- *     array.first     ->   obj or nil
- *     array.first(n)  ->   an_array
- *  
+ *     ary.first     ->   obj or nil
+ *     ary.first(n)  ->   new_ary
+ *
  *  Returns the first element, or the first +n+ elements, of the array.
  *  If the array is empty, the first form returns <code>nil</code>, and the
  *  second form returns an empty array.
- *     
+ *
  *     a = [ "q", "r", "s", "t" ]
  *     a.first     #=> "q"
  *     a.first(2)  #=> ["q", "r"]
@@ -1012,12 +1070,12 @@ rb_ary_first(int argc, VALUE *argv, VALUE ary)
 
 /*
  *  call-seq:
- *     array.last     ->  obj or nil
- *     array.last(n)  ->  an_array
- *  
- *  Returns the last element(s) of <i>self</i>. If the array is empty,
+ *     ary.last     ->  obj or nil
+ *     ary.last(n)  ->  new_ary
+ *
+ *  Returns the last element(s) of +self+. If the array is empty,
  *  the first form returns <code>nil</code>.
- *     
+ *
  *     a = [ "w", "x", "y", "z" ]
  *     a.last     #=> "z"
  *     a.last(2)  #=> ["y", "z"]
@@ -1037,17 +1095,17 @@ rb_ary_last(int argc, VALUE *argv, VALUE ary)
 
 /*
  *  call-seq:
- *     array.fetch(index)                    -> obj
- *     array.fetch(index, default )          -> obj
- *     array.fetch(index) {|index| block }   -> obj
- *  
+ *     ary.fetch(index)                    -> obj
+ *     ary.fetch(index, default )          -> obj
+ *     ary.fetch(index) {|index| block }   -> obj
+ *
  *  Tries to return the element at position <i>index</i>. If the index
  *  lies outside the array, the first form throws an
  *  <code>IndexError</code> exception, the second form returns
  *  <i>default</i>, and the third form returns the value of invoking
  *  the block, passing in the index. Negative values of <i>index</i>
  *  count from the end of the array.
- *     
+ *
  *     a = [ 11, 22, 33, 44 ]
  *     a.fetch(1)               #=> 22
  *     a.fetch(-1)              #=> 44
@@ -1075,7 +1133,8 @@ rb_ary_fetch(int argc, VALUE *argv, VALUE ary)
     if (idx < 0 || RARRAY_LEN(ary) <= idx) {
 	if (block_given) return rb_yield(pos);
 	if (argc == 1) {
-	    rb_raise(rb_eIndexError, "index %ld out of array", idx);
+	    rb_raise(rb_eIndexError, "index %ld outside of array bounds: %ld...%ld",
+			idx - (idx < 0 ? RARRAY_LEN(ary) : 0), -RARRAY_LEN(ary), RARRAY_LEN(ary));
 	}
 	return ifnone;
     }
@@ -1084,14 +1143,18 @@ rb_ary_fetch(int argc, VALUE *argv, VALUE ary)
 
 /*
  *  call-seq:
- *     array.index(obj)           ->  int or nil
- *     array.index {|item| block} ->  int or nil
- *  
- *  Returns the index of the first object in <i>self</i> such that is
+ *     ary.index(obj)           ->  int or nil
+ *     ary.index {|item| block} ->  int or nil
+ *     ary.index                ->  an_enumerator
+ *
+ *  Returns the index of the first object in +self+ such that is
  *  <code>==</code> to <i>obj</i>. If a block is given instead of an
  *  argument, returns first object for which <em>block</em> is true.
  *  Returns <code>nil</code> if no match is found.
- *     
+ *  See also <code>Array#rindex</code>.
+ *
+ *  If neither block nor argument is given, an enumerator is returned instead.
+ *
  *     a = [ "a", "b", "c" ]
  *     a.index("b")        #=> 1
  *     a.index("z")        #=> nil
@@ -1106,7 +1169,7 @@ rb_ary_index(int argc, VALUE *argv, VALUE ary)
     VALUE val;
     long i;
 
-    if (argc  == 0) {
+    if (argc == 0) {
 	RETURN_ENUMERATOR(ary, 0, 0);
 	for (i=0; i<RARRAY_LEN(ary); i++) {
 	    if (RTEST(rb_yield(RARRAY_PTR(ary)[i]))) {
@@ -1115,7 +1178,9 @@ rb_ary_index(int argc, VALUE *argv, VALUE ary)
 	}
 	return Qnil;
     }
-    rb_scan_args(argc, argv, "01", &val);
+    rb_scan_args(argc, argv, "1", &val);
+    if (rb_block_given_p())
+	rb_warn("given block not used");
     for (i=0; i<RARRAY_LEN(ary); i++) {
 	if (rb_equal(RARRAY_PTR(ary)[i], val))
 	    return LONG2NUM(i);
@@ -1125,13 +1190,19 @@ rb_ary_index(int argc, VALUE *argv, VALUE ary)
 
 /*
  *  call-seq:
- *     array.rindex(obj)    ->  int or nil
- *  
- *  Returns the index of the last object in <i>array</i>
+ *     ary.rindex(obj)           ->  int or nil
+ *     ary.rindex {|item| block} ->  int or nil
+ *     ary.rindex                ->  an_enumerator
+ *
+ *  Returns the index of the last object in +self+
  *  <code>==</code> to <i>obj</i>. If a block is given instead of an
  *  argument, returns first object for which <em>block</em> is
- *  true. Returns <code>nil</code> if no match is found.
- *     
+ *  true, starting from the last object.
+ *  Returns <code>nil</code> if no match is found.
+ *  See also <code>Array#index</code>.
+ *
+ *  If neither block nor argument is given, an enumerator is returned instead.
+ *
  *     a = [ "a", "b", "b", "b", "c" ]
  *     a.rindex("b")        #=> 3
  *     a.rindex("z")        #=> nil
@@ -1155,7 +1226,9 @@ rb_ary_rindex(int argc, VALUE *argv, VALUE ary)
 	}
 	return Qnil;
     }
-    rb_scan_args(argc, argv, "01", &val);
+    rb_scan_args(argc, argv, "1", &val);
+    if (rb_block_given_p())
+	rb_warn("given block not used");
     while (i--) {
 	if (rb_equal(RARRAY_PTR(ary)[i], val))
 	    return LONG2NUM(i);
@@ -1169,12 +1242,9 @@ rb_ary_rindex(int argc, VALUE *argv, VALUE ary)
 VALUE
 rb_ary_to_ary(VALUE obj)
 {
-    if (TYPE(obj) == T_ARRAY) {
-	return obj;
-    }
-    if (rb_respond_to(obj, rb_intern("to_ary"))) {
-	return to_ary(obj);
-    }
+    VALUE tmp = rb_check_array_type(obj);
+
+    if (!NIL_P(tmp)) return tmp;
     return rb_ary_new3(1, obj);
 }
 
@@ -1187,8 +1257,8 @@ rb_ary_splice(VALUE ary, long beg, long len, VALUE rpl)
     if (beg < 0) {
 	beg += RARRAY_LEN(ary);
 	if (beg < 0) {
-	    beg -= RARRAY_LEN(ary);
-	    rb_raise(rb_eIndexError, "index %ld out of array", beg);
+	    rb_raise(rb_eIndexError, "index %ld too small for array; minimum: %ld",
+		     beg - RARRAY_LEN(ary), -RARRAY_LEN(ary));
 	}
     }
     if (RARRAY_LEN(ary) < len || RARRAY_LEN(ary) < beg + len) {
@@ -1209,7 +1279,7 @@ rb_ary_splice(VALUE ary, long beg, long len, VALUE rpl)
 	}
 	len = beg + rlen;
 	if (len >= ARY_CAPA(ary)) {
-	    ary_resize_capa(ary, len);
+	    ary_double_capa(ary, len);
 	}
 	rb_mem_clear(RARRAY_PTR(ary) + RARRAY_LEN(ary), beg - RARRAY_LEN(ary));
 	if (rlen > 0) {
@@ -1222,7 +1292,7 @@ rb_ary_splice(VALUE ary, long beg, long len, VALUE rpl)
 
 	alen = RARRAY_LEN(ary) + rlen - len;
 	if (alen >= ARY_CAPA(ary)) {
-	    ary_resize_capa(ary, alen);
+	    ary_double_capa(ary, alen);
 	}
 
 	if (len != rlen) {
@@ -1236,11 +1306,11 @@ rb_ary_splice(VALUE ary, long beg, long len, VALUE rpl)
     }
 }
 
-/* 
+/*
  *  call-seq:
- *     array[index]         = obj                     ->  obj
- *     array[start, length] = obj or an_array or nil  ->  obj or an_array or nil
- *     array[range]         = obj or an_array or nil  ->  obj or an_array or nil
+ *     ary[index]         = obj                      ->  obj
+ *     ary[start, length] = obj or other_ary or nil  ->  obj or other_ary or nil
+ *     ary[range]         = obj or other_ary or nil  ->  obj or other_ary or nil
  *
  *  Element Assignment---Sets the element at _index_,
  *  or replaces a subarray starting at _start_ and
@@ -1252,7 +1322,7 @@ rb_ary_splice(VALUE ary, long beg, long len, VALUE rpl)
  *  zero. An +IndexError+ is raised if a negative index points
  *  past the beginning of the array. See also
  *  <code>Array#push</code>, and <code>Array#unshift</code>.
- * 
+ *
  *     a = Array.new
  *     a[4] = "4";                 #=> [nil, nil, nil, nil, "4"]
  *     a[0, 3] = [ 'a', 'b', 'c' ] #=> ["a", "b", "c", nil, "4"]
@@ -1270,6 +1340,7 @@ rb_ary_aset(int argc, VALUE *argv, VALUE ary)
     long offset, beg, len;
 
     if (argc == 3) {
+	rb_ary_modify_check(ary);
 	beg = NUM2LONG(argv[0]);
 	len = NUM2LONG(argv[1]);
 	rb_ary_splice(ary, beg, len, argv[2]);
@@ -1278,6 +1349,7 @@ rb_ary_aset(int argc, VALUE *argv, VALUE ary)
     if (argc != 2) {
 	rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc);
     }
+    rb_ary_modify_check(ary);
     if (FIXNUM_P(argv[0])) {
 	offset = FIX2LONG(argv[0]);
 	goto fixnum;
@@ -1296,11 +1368,11 @@ fixnum:
 
 /*
  *  call-seq:
- *     array.insert(index, obj...)  -> array
- *  
+ *     ary.insert(index, obj...)  -> ary
+ *
  *  Inserts the given values before the element with the given index
  *  (which may be negative).
- *     
+ *
  *     a = %w{ a b c d }
  *     a.insert(2, 99)         #=> ["a", "b", 99, "c", "d"]
  *     a.insert(-2, 1, 2, 3)   #=> ["a", "b", 99, "c", 1, 2, 3, "d"]
@@ -1311,10 +1383,11 @@ rb_ary_insert(int argc, VALUE *argv, VALUE ary)
 {
     long pos;
 
-    if (argc == 1) return ary;
     if (argc < 1) {
 	rb_raise(rb_eArgError, "wrong number of arguments (at least 1)");
     }
+    rb_ary_modify_check(ary);
+    if (argc == 1) return ary;
     pos = NUM2LONG(argv[0]);
     if (pos == -1) {
 	pos = RARRAY_LEN(ary);
@@ -1328,16 +1401,19 @@ rb_ary_insert(int argc, VALUE *argv, VALUE ary)
 
 /*
  *  call-seq:
- *     array.each {|item| block }   ->   array
- *  
- *  Calls <i>block</i> once for each element in <i>self</i>, passing that
+ *     ary.each {|item| block }   -> ary
+ *     ary.each                   -> an_enumerator
+ *
+ *  Calls <i>block</i> once for each element in +self+, passing that
  *  element as a parameter.
- *     
+ *
+ *  If no block is given, an enumerator is returned instead.
+ *
  *     a = [ "a", "b", "c" ]
  *     a.each {|x| print x, " -- " }
- *     
+ *
  *  produces:
- *     
+ *
  *     a -- b -- c --
  */
 
@@ -1355,16 +1431,20 @@ rb_ary_each(VALUE ary)
 
 /*
  *  call-seq:
- *     array.each_index {|index| block }  ->  array
- *  
+ *     ary.each_index {|index| block }  -> ary
+ *     ary.each_index                   -> an_enumerator
+ *
  *  Same as <code>Array#each</code>, but passes the index of the element
  *  instead of the element itself.
- *     
+ *
+ *  If no block is given, an enumerator is returned instead.
+ *
+ *
  *     a = [ "a", "b", "c" ]
  *     a.each_index {|x| print x, " -- " }
- *     
+ *
  *  produces:
- *     
+ *
  *     0 -- 1 -- 2 --
  */
 
@@ -1382,16 +1462,17 @@ rb_ary_each_index(VALUE ary)
 
 /*
  *  call-seq:
- *     array.reverse_each {|item| block } 
- *  
- *  Same as <code>Array#each</code>, but traverses <i>self</i> in reverse
+ *     ary.reverse_each {|item| block }   -> ary
+ *     ary.reverse_each                   -> an_enumerator
+ *
+ *  Same as <code>Array#each</code>, but traverses +self+ in reverse
  *  order.
- *     
+ *
  *     a = [ "a", "b", "c" ]
  *     a.reverse_each {|x| print x, " " }
- *     
+ *
  *  produces:
- *     
+ *
  *     c b a
  */
 
@@ -1413,10 +1494,10 @@ rb_ary_reverse_each(VALUE ary)
 
 /*
  *  call-seq:
- *     array.length -> int
- *  
- *  Returns the number of elements in <i>self</i>. May be zero.
- *     
+ *     ary.length -> int
+ *
+ *  Returns the number of elements in +self+. May be zero.
+ *
  *     [ 1, 2, 3, 4, 5 ].length   #=> 5
  */
 
@@ -1429,10 +1510,10 @@ rb_ary_length(VALUE ary)
 
 /*
  *  call-seq:
- *     array.empty?   -> true or false
- *  
- *  Returns <code>true</code> if <i>self</i> array contains no elements.
- *     
+ *     ary.empty?   -> true or false
+ *
+ *  Returns <code>true</code> if +self+ contains no elements.
+ *
  *     [].empty?   #=> true
  */
 
@@ -1444,91 +1525,163 @@ rb_ary_empty_p(VALUE ary)
     return Qfalse;
 }
 
-VALUE
-rb_ary_dup(VALUE ary)
+static VALUE
+rb_ary_dup_setup(VALUE ary)
 {
     VALUE dup = rb_ary_new2(RARRAY_LEN(ary));
     int is_embed = ARY_EMBED_P(dup);
     DUPSETUP(dup, ary);
     if (is_embed) FL_SET_EMBED(dup);
-    MEMCPY(RARRAY_PTR(dup), RARRAY_PTR(ary), VALUE, RARRAY_LEN(ary));
     ARY_SET_LEN(dup, RARRAY_LEN(ary));
+    return dup;
+}
 
+VALUE
+rb_ary_dup(VALUE ary)
+{
+    VALUE dup = rb_ary_dup_setup(ary);
+    MEMCPY(RARRAY_PTR(dup), RARRAY_PTR(ary), VALUE, RARRAY_LEN(ary));
     return dup;
 }
 
+VALUE
+rb_ary_resurrect(VALUE ary)
+{
+    return rb_ary_new4(RARRAY_LEN(ary), RARRAY_PTR(ary));
+}
+
 extern VALUE rb_output_fs;
 
+static void ary_join_1(VALUE obj, VALUE ary, VALUE sep, long i, VALUE result);
+
 static VALUE
-recursive_join(VALUE ary, VALUE argp, int recur)
+recursive_join(VALUE obj, VALUE argp, int recur)
 {
     VALUE *arg = (VALUE *)argp;
+    VALUE ary = arg[0];
+    VALUE sep = arg[1];
+    VALUE result = arg[2];
+
     if (recur) {
-	return rb_usascii_str_new2("[...]");
+	rb_raise(rb_eArgError, "recursive array join");
+    }
+    else {
+	ary_join_1(obj, ary, sep, 0, result);
     }
-    return rb_ary_join(arg[0], arg[1]);
+    return Qnil;
 }
 
-VALUE
-rb_ary_join(VALUE ary, VALUE sep)
+static void
+ary_join_0(VALUE ary, VALUE sep, long max, VALUE result)
 {
-    long len = 1, i;
-    int taint = Qfalse;
-    int untrust = Qfalse;
-    VALUE result, tmp;
-
-    if (RARRAY_LEN(ary) == 0) return rb_str_new(0, 0);
-    if (OBJ_TAINTED(ary) || OBJ_TAINTED(sep)) taint = Qtrue;
-    if (OBJ_UNTRUSTED(ary) || OBJ_UNTRUSTED(sep)) untrust = Qtrue;
+    long i;
+    VALUE val;
 
-    for (i=0; i<RARRAY_LEN(ary); i++) {
-	tmp = rb_check_string_type(RARRAY_PTR(ary)[i]);
-	len += NIL_P(tmp) ? 10 : RSTRING_LEN(tmp);
-    }
-    if (!NIL_P(sep)) {
-	StringValue(sep);
-	len += RSTRING_LEN(sep) * (RARRAY_LEN(ary) - 1);
+    for (i=0; i<max; i++) {
+	val = RARRAY_PTR(ary)[i];
+	if (i > 0 && !NIL_P(sep))
+	    rb_str_buf_append(result, sep);
+	rb_str_buf_append(result, val);
+	if (OBJ_TAINTED(val)) OBJ_TAINT(result);
+	if (OBJ_UNTRUSTED(val)) OBJ_TAINT(result);
     }
-    result = rb_str_buf_new(len);
-    for (i=0; i<RARRAY_LEN(ary); i++) {
-	tmp = RARRAY_PTR(ary)[i];
-	switch (TYPE(tmp)) {
+}
+
+static void
+ary_join_1(VALUE obj, VALUE ary, VALUE sep, long i, VALUE result)
+{
+    VALUE val, tmp;
+
+    for (; i<RARRAY_LEN(ary); i++) {
+	if (i > 0 && !NIL_P(sep))
+	    rb_str_buf_append(result, sep);
+
+	val = RARRAY_PTR(ary)[i];
+	switch (TYPE(val)) {
 	  case T_STRING:
+	  str_join:
+	    rb_str_buf_append(result, val);
 	    break;
 	  case T_ARRAY:
-	    if (tmp == ary) {
-		tmp = rb_usascii_str_new2("[...]");
+	    obj = val;
+	  ary_join:
+	    if (val == ary) {
+		rb_raise(rb_eArgError, "recursive array join");
 	    }
 	    else {
-		VALUE args[2];
+		VALUE args[3];
 
-		args[0] = tmp;
+		args[0] = val;
 		args[1] = sep;
-		tmp = rb_exec_recursive(recursive_join, ary, (VALUE)args);
+		args[2] = result;
+		rb_exec_recursive(recursive_join, obj, (VALUE)args);
 	    }
 	    break;
 	  default:
-	    tmp = rb_obj_as_string(tmp);
+	    tmp = rb_check_string_type(val);
+	    if (!NIL_P(tmp)) {
+		val = tmp;
+		goto str_join;
+	    }
+	    tmp = rb_check_convert_type(val, T_ARRAY, "Array", "to_ary");
+	    if (!NIL_P(tmp)) {
+		obj = val;
+		val = tmp;
+		goto ary_join;
+	    }
+	    val = rb_obj_as_string(val);
+	    goto str_join;
 	}
-	if (i > 0 && !NIL_P(sep))
-	    rb_str_buf_append(result, sep);
-	rb_str_buf_append(result, tmp);
-	if (OBJ_TAINTED(tmp)) taint = Qtrue;
-	if (OBJ_UNTRUSTED(tmp)) untrust = Qtrue;
+    }
+}
+
+VALUE
+rb_ary_join(VALUE ary, VALUE sep)
+{
+    long len = 1, i;
+    int taint = FALSE;
+    int untrust = FALSE;
+    VALUE val, tmp, result;
+
+    if (RARRAY_LEN(ary) == 0) return rb_usascii_str_new(0, 0);
+    if (OBJ_TAINTED(ary) || OBJ_TAINTED(sep)) taint = TRUE;
+    if (OBJ_UNTRUSTED(ary) || OBJ_UNTRUSTED(sep)) untrust = TRUE;
+
+    if (!NIL_P(sep)) {
+	StringValue(sep);
+	len += RSTRING_LEN(sep) * (RARRAY_LEN(ary) - 1);
+    }
+    for (i=0; i<RARRAY_LEN(ary); i++) {
+	val = RARRAY_PTR(ary)[i];
+	tmp = rb_check_string_type(val);
+
+	if (NIL_P(tmp) || tmp != val) {
+	    result = rb_str_buf_new(len + (RARRAY_LEN(ary)-i)*10);
+	    if (taint) OBJ_TAINT(result);
+	    if (untrust) OBJ_UNTRUST(result);
+	    ary_join_0(ary, sep, i, result);
+	    ary_join_1(ary, ary, sep, i, result);
+	    return result;
+	}
+
+	len += RSTRING_LEN(tmp);
     }
 
+    result = rb_str_buf_new(len);
     if (taint) OBJ_TAINT(result);
     if (untrust) OBJ_UNTRUST(result);
+    ary_join_0(ary, sep, RARRAY_LEN(ary), result);
+
     return result;
 }
 
 /*
  *  call-seq:
- *     array.join(sep=$,)    -> str
- *  
+ *     ary.join(sep=$,)    -> str
+ *
  *  Returns a string created by converting each element of the array to
  *  a string, separated by <i>sep</i>.
- *     
+ *
  *     [ "a", "b", "c" ].join        #=> "abc"
  *     [ "a", "b", "c" ].join("-")   #=> "a-b-c"
  */
@@ -1540,7 +1693,7 @@ rb_ary_join_m(int argc, VALUE *argv, VALUE ary)
 
     rb_scan_args(argc, argv, "01", &sep);
     if (NIL_P(sep)) sep = rb_output_fs;
-    
+
     return rb_ary_join(ary, sep);
 }
 
@@ -1556,8 +1709,8 @@ inspect_ary(VALUE ary, VALUE dummy, int recur)
     str = rb_str_buf_new2("[");
     for (i=0; i<RARRAY_LEN(ary); i++) {
 	s = rb_inspect(RARRAY_PTR(ary)[i]);
-	if (OBJ_TAINTED(s)) tainted = Qtrue;
-	if (OBJ_UNTRUSTED(s)) untrust = Qtrue;
+	if (OBJ_TAINTED(s)) tainted = TRUE;
+	if (OBJ_UNTRUSTED(s)) untrust = TRUE;
 	if (i > 0) rb_str_buf_cat2(str, ", ");
 	rb_str_buf_append(str, s);
     }
@@ -1569,10 +1722,10 @@ inspect_ary(VALUE ary, VALUE dummy, int recur)
 
 /*
  *  call-seq:
- *     array.to_s -> string
- *     array.inspect  -> string
+ *     ary.to_s -> string
+ *     ary.inspect  -> string
  *
- *  Create a printable version of <i>array</i>.
+ *  Creates a string representation of +self+.
  */
 
 static VALUE
@@ -1590,9 +1743,9 @@ rb_ary_to_s(VALUE ary)
 
 /*
  *  call-seq:
- *     array.to_a     -> array
- *  
- *  Returns _self_. If called on a subclass of Array, converts
+ *     ary.to_a     -> ary
+ *
+ *  Returns +self+. If called on a subclass of Array, converts
  *  the receiver to an Array object.
  */
 
@@ -1609,9 +1762,9 @@ rb_ary_to_a(VALUE ary)
 
 /*
  *  call-seq:
- *     array.to_ary -> array
- *  
- *  Returns _self_.
+ *     ary.to_ary -> ary
+ *
+ *  Returns +self+.
  */
 
 static VALUE
@@ -1620,32 +1773,37 @@ rb_ary_to_ary_m(VALUE ary)
     return ary;
 }
 
+static void
+ary_reverse(p1, p2)
+    VALUE *p1, *p2;
+{
+    while (p1 < p2) {
+	VALUE tmp = *p1;
+	*p1++ = *p2;
+	*p2-- = tmp;
+    }
+}
+
 VALUE
 rb_ary_reverse(VALUE ary)
 {
     VALUE *p1, *p2;
-    VALUE tmp;
 
     rb_ary_modify(ary);
     if (RARRAY_LEN(ary) > 1) {
 	p1 = RARRAY_PTR(ary);
 	p2 = p1 + RARRAY_LEN(ary) - 1;	/* points last item */
-
-	while (p1 < p2) {
-	    tmp = *p1;
-	    *p1++ = *p2;
-	    *p2-- = tmp;
-	}
+	ary_reverse(p1, p2);
     }
     return ary;
 }
 
 /*
  *  call-seq:
- *     array.reverse!   -> array 
- *  
- *  Reverses _self_ in place.
- *     
+ *     ary.reverse!   -> ary
+ *
+ *  Reverses +self+ in place.
+ *
  *     a = [ "a", "b", "c" ]
  *     a.reverse!       #=> ["c", "b", "a"]
  *     a                #=> ["c", "b", "a"]
@@ -1659,10 +1817,10 @@ rb_ary_reverse_bang(VALUE ary)
 
 /*
  *  call-seq:
- *     array.reverse -> an_array
- *  
- *  Returns a new array containing <i>self</i>'s elements in reverse order.
- *     
+ *     ary.reverse -> new_ary
+ *
+ *  Returns a new array containing +self+'s elements in reverse order.
+ *
  *     [ "a", "b", "c" ].reverse   #=> ["c", "b", "a"]
  *     [ 1 ].reverse               #=> [1]
  */
@@ -1670,7 +1828,111 @@ rb_ary_reverse_bang(VALUE ary)
 static VALUE
 rb_ary_reverse_m(VALUE ary)
 {
-    return rb_ary_reverse(rb_ary_dup(ary));
+    VALUE dup = rb_ary_dup_setup(ary);
+    long len = RARRAY_LEN(ary);
+
+    if (len > 0) {
+	VALUE *p1 = RARRAY_PTR(ary);
+	VALUE *p2 = RARRAY_PTR(dup) + len - 1;
+	do *p2-- = *p1++; while (--len > 0);
+    }
+    return dup;
+}
+
+static inline long
+rotate_count(long cnt, long len)
+{
+    return (cnt < 0) ? (len - (~cnt % len) - 1) : (cnt % len);
+}
+
+VALUE
+rb_ary_rotate(VALUE ary, long cnt)
+{
+    rb_ary_modify(ary);
+
+    if (cnt != 0) {
+	VALUE *ptr = RARRAY_PTR(ary);
+	long len = RARRAY_LEN(ary);
+
+	if (len > 0 && (cnt = rotate_count(cnt, len)) > 0) {
+	    --len;
+	    if (cnt < len) ary_reverse(ptr + cnt, ptr + len);
+	    if (--cnt > 0) ary_reverse(ptr, ptr + cnt);
+	    if (len > 0) ary_reverse(ptr, ptr + len);
+	    return ary;
+	}
+    }
+
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     ary.rotate!(cnt=1) -> ary
+ *
+ *  Rotates +self+ in place so that the element at +cnt+ comes first,
+ *  and returns +self+.  If +cnt+ is negative then it rotates in
+ *  counter direction.
+ *
+ *     a = [ "a", "b", "c", "d" ]
+ *     a.rotate!        #=> ["b", "c", "d", "a"]
+ *     a                #=> ["b", "c", "d", "a"]
+ *     a.rotate!(2)     #=> ["d", "a", "b", "c"]
+ *     a.rotate!(-3)    #=> ["a", "b", "c", "d"]
+ */
+
+static VALUE
+rb_ary_rotate_bang(int argc, VALUE *argv, VALUE ary)
+{
+    long n = 1;
+
+    switch (argc) {
+      case 1: n = NUM2LONG(argv[0]);
+      case 0: break;
+      default: rb_scan_args(argc, argv, "01", NULL);
+    }
+    rb_ary_rotate(ary, n);
+    return ary;
+}
+
+/*
+ *  call-seq:
+ *     ary.rotate([n = 1]) -> new_ary
+ *
+ *  Returns new array by rotating +self+, whose first element is the
+ *  element at +cnt+ in +self+.  If +cnt+ is negative then it rotates
+ *  in counter direction.
+ *
+ *     a = [ "a", "b", "c", "d" ]
+ *     a.rotate         #=> ["b", "c", "d", "a"]
+ *     a                #=> ["a", "b", "c", "d"]
+ *     a.rotate(2)      #=> ["c", "d", "a", "b"]
+ *     a.rotate(-3)     #=> ["b", "c", "d", "a"]
+ */
+
+static VALUE
+rb_ary_rotate_m(int argc, VALUE *argv, VALUE ary)
+{
+    VALUE rotated, *ptr, *ptr2;
+    long len, cnt = 1;
+
+    switch (argc) {
+      case 1: cnt = NUM2LONG(argv[0]);
+      case 0: break;
+      default: rb_scan_args(argc, argv, "01", NULL);
+    }
+
+    len = RARRAY_LEN(ary);
+    rotated = rb_ary_dup_setup(ary);
+    if (len > 0) {
+	cnt = rotate_count(cnt, len);
+	ptr = RARRAY_PTR(ary);
+	ptr2 = RARRAY_PTR(rotated);
+	len -= cnt;
+	MEMCPY(ptr2, ptr + cnt, VALUE, len);
+	MEMCPY(ptr2 + len, ptr, VALUE, cnt);
+    }
+    return rotated;
 }
 
 struct ary_sort_data {
@@ -1744,15 +2006,15 @@ sort_2(const void *ap, const void *bp, void *dummy)
 
 /*
  *  call-seq:
- *     array.sort!                   -> array
- *     array.sort! {| a,b | block }  -> array 
- *  
- *  Sorts _self_. Comparisons for
+ *     ary.sort!                   -> ary
+ *     ary.sort! {| a,b | block }  -> ary
+ *
+ *  Sorts +self+. Comparisons for
  *  the sort will be done using the <code><=></code> operator or using
  *  an optional code block. The block implements a comparison between
  *  <i>a</i> and <i>b</i>, returning -1, 0, or +1. See also
  *  <code>Enumerable#sort_by</code>.
- *     
+ *
  *     a = [ "d", "a", "e", "c", "b" ]
  *     a.sort                    #=> ["a", "b", "c", "d", "e"]
  *     a.sort {|x,y| y <=> x }   #=> ["e", "d", "c", "b", "a"]
@@ -1805,7 +2067,7 @@ rb_ary_sort_bang(VALUE ary)
                 ARY_SET_PTR(ary, RARRAY_PTR(tmp));
                 ARY_SET_HEAP_LEN(ary, RARRAY_LEN(tmp));
                 ARY_SET_CAPA(ary, ARY_CAPA(tmp));
-            } 
+            }
             /* tmp was lost ownership for the ptr */
             FL_UNSET(tmp, FL_FREEZE);
             FL_SET_EMBED(tmp);
@@ -1820,15 +2082,15 @@ rb_ary_sort_bang(VALUE ary)
 
 /*
  *  call-seq:
- *     array.sort                   -> an_array 
- *     array.sort {| a,b | block }  -> an_array 
- *  
- *  Returns a new array created by sorting <i>self</i>. Comparisons for
+ *     ary.sort                   -> new_ary
+ *     ary.sort {| a,b | block }  -> new_ary
+ *
+ *  Returns a new array created by sorting +self+. Comparisons for
  *  the sort will be done using the <code><=></code> operator or using
  *  an optional code block. The block implements a comparison between
  *  <i>a</i> and <i>b</i>, returning -1, 0, or +1. See also
  *  <code>Enumerable#sort_by</code>.
- *     
+ *
  *     a = [ "d", "a", "e", "c", "b" ]
  *     a.sort                    #=> ["a", "b", "c", "d", "e"]
  *     a.sort {|x,y| y <=> x }   #=> ["e", "d", "c", "b", "a"]
@@ -1843,15 +2105,50 @@ rb_ary_sort(VALUE ary)
 }
 
 
+static VALUE
+sort_by_i(VALUE i)
+{
+    return rb_yield(i);
+}
+
 /*
  *  call-seq:
- *     array.collect {|item| block }  -> an_array
- *     array.map     {|item| block }  -> an_array
- *  
- *  Invokes <i>block</i> once for each element of <i>self</i>. Creates a 
+ *     ary.sort_by! {| obj | block }    -> ary
+ *     ary.sort_by!                     -> an_enumerator
+ *
+ *  Sorts +self+ in place using a set of keys generated by mapping the
+ *  values in +self+ through the given block.
+ *
+ *  If no block is given, an enumerator is returned instead.
+ *
+ */
+
+static VALUE
+rb_ary_sort_by_bang(VALUE ary)
+{
+    VALUE sorted;
+
+    RETURN_ENUMERATOR(ary, 0, 0);
+    rb_ary_modify(ary);
+    sorted = rb_block_call(ary, rb_intern("sort_by"), 0, 0, sort_by_i, 0);
+    rb_ary_replace(ary, sorted);
+    return ary;
+}
+
+
+/*
+ *  call-seq:
+ *     ary.collect {|item| block }  -> new_ary
+ *     ary.map     {|item| block }  -> new_ary
+ *     ary.collect                  -> an_enumerator
+ *     ary.map                      -> an_enumerator
+ *
+ *  Invokes <i>block</i> once for each element of +self+. Creates a
  *  new array containing the values returned by the block.
  *  See also <code>Enumerable#collect</code>.
- *     
+ *
+ *  If no block is given, an enumerator is returned instead.
+ *
  *     a = [ "a", "b", "c", "d" ]
  *     a.collect {|x| x + "!" }   #=> ["a!", "b!", "c!", "d!"]
  *     a                          #=> ["a", "b", "c", "d"]
@@ -1872,15 +2169,19 @@ rb_ary_collect(VALUE ary)
 }
 
 
-/* 
+/*
  *  call-seq:
- *     array.collect! {|item| block }   ->   array
- *     array.map!     {|item| block }   ->   array
+ *     ary.collect! {|item| block }   -> ary
+ *     ary.map!     {|item| block }   -> ary
+ *     ary.collect                    -> an_enumerator
+ *     ary.map                        -> an_enumerator
  *
- *  Invokes the block once for each element of _self_, replacing the
+ *  Invokes the block once for each element of +self+, replacing the
  *  element with the value returned by _block_.
  *  See also <code>Enumerable#collect</code>.
- *   
+ *
+ *  If no block is given, an enumerator is returned instead.
+ *
  *     a = [ "a", "b", "c", "d" ]
  *     a.collect! {|x| x + "!" }
  *     a             #=>  [ "a!", "b!", "c!", "d!" ]
@@ -1927,15 +2228,15 @@ rb_get_values_at(VALUE obj, long olen, int argc, VALUE *argv, VALUE (*func) (VAL
     return result;
 }
 
-/* 
+/*
  *  call-seq:
- *     array.values_at(selector,... )  -> an_array
+ *     ary.values_at(selector,... )  -> new_ary
  *
  *  Returns an array containing the elements in
- *  _self_ corresponding to the given selector(s). The selectors
- *  may be either integer indices or ranges. 
+ *  +self+ corresponding to the given selector(s). The selectors
+ *  may be either integer indices or ranges.
  *  See also <code>Array#select</code>.
- * 
+ *
  *     a = %w{ a b c d e f }
  *     a.values_at(1, 3, 5)
  *     a.values_at(1, 3, 5, 7)
@@ -1952,12 +2253,15 @@ rb_ary_values_at(int argc, VALUE *argv, VALUE ary)
 
 /*
  *  call-seq:
- *     array.select {|item| block } -> an_array
- *  
- *  Invokes the block passing in successive elements from <i>array</i>,
+ *     ary.select {|item| block } -> new_ary
+ *     ary.select                 -> an_enumerator
+ *
+ *  Invokes the block passing in successive elements from +self+,
  *  returning an array containing those elements for which the block
  *  returns a true value (equivalent to <code>Enumerable#select</code>).
- *     
+ *
+ *  If no block is given, an enumerator is returned instead.
+ *
  *     a = %w{ a b c d e f }
  *     a.select {|v| v =~ /[aeiou]/}   #=> ["a", "e"]
  */
@@ -1980,14 +2284,76 @@ rb_ary_select(VALUE ary)
 
 /*
  *  call-seq:
- *     array.delete(obj)            -> obj or nil 
- *     array.delete(obj) { block }  -> obj or nil
- *  
- *  Deletes items from <i>self</i> that are equal to <i>obj</i>. If
+ *     ary.select! {|item| block } -> new_ary or nil
+ *     ary.select!                 -> an_enumerator
+ *
+ *  Invokes the block passing in successive elements from
+ *  +self+, deleting elements for which the block returns a
+ *  false value. It returns +self+ if changes were made,
+ *  otherwise it returns <code>nil</code>.
+ *  See also <code>Array#keep_if</code>
+ *
+ *  If no block is given, an enumerator is returned instead.
+ *
+ */
+
+static VALUE
+rb_ary_select_bang(VALUE ary)
+{
+    long i1, i2;
+
+    RETURN_ENUMERATOR(ary, 0, 0);
+    rb_ary_modify(ary);
+    for (i1 = i2 = 0; i1 < RARRAY_LEN(ary); i1++) {
+	VALUE v = RARRAY_PTR(ary)[i1];
+	if (!RTEST(rb_yield(v))) continue;
+	if (i1 != i2) {
+	    rb_ary_store(ary, i2, v);
+	}
+	i2++;
+    }
+
+    if (RARRAY_LEN(ary) == i2) return Qnil;
+    if (i2 < RARRAY_LEN(ary))
+	ARY_SET_LEN(ary, i2);
+    return ary;
+}
+
+/*
+ *  call-seq:
+ *     ary.keep_if {|item| block } -> ary
+ *     ary.keep_if                 -> an_enumerator
+ *
+ *  Deletes every element of +self+ for which <i>block</i> evaluates
+ *  to false.
+ *  See also <code>Array#select!</code>
+ *
+ *  If no block is given, an enumerator is returned instead.
+ *
+ *     a = %w{ a b c d e f }
+ *     a.keep_if {|v| v =~ /[aeiou]/}   #=> ["a", "e"]
+ */
+
+static VALUE
+rb_ary_keep_if(VALUE ary)
+{
+    RETURN_ENUMERATOR(ary, 0, 0);
+    rb_ary_select_bang(ary);
+    return ary;
+}
+
+/*
+ *  call-seq:
+ *     ary.delete(obj)            -> obj or nil
+ *     ary.delete(obj) { block }  -> obj or nil
+ *
+ *  Deletes items from +self+ that are equal to <i>obj</i>.
+ *  If any items are found, returns <i>obj</i>.   If
  *  the item is not found, returns <code>nil</code>. If the optional
  *  code block is given, returns the result of <i>block</i> if the item
- *  is not found.
- *     
+ *  is not found.  (To remove <code>nil</code> elements and
+ *  get an informative return value, use #compact!)
+ *
  *     a = [ "a", "b", "b", "b", "c" ]
  *     a.delete("b")                   #=> "b"
  *     a                               #=> ["a", "c"]
@@ -2055,12 +2421,12 @@ rb_ary_delete_at(VALUE ary, long pos)
 
 /*
  *  call-seq:
- *     array.delete_at(index)  -> obj or nil
- *  
+ *     ary.delete_at(index)  -> obj or nil
+ *
  *  Deletes the element at the specified index, returning that element,
  *  or <code>nil</code> if the index is out of range. See also
  *  <code>Array#slice!</code>.
- *     
+ *
  *     a = %w( ant bat cat dog )
  *     a.delete_at(2)    #=> "cat"
  *     a                 #=> ["ant", "bat", "dog"]
@@ -2075,14 +2441,14 @@ rb_ary_delete_at_m(VALUE ary, VALUE pos)
 
 /*
  *  call-seq:
- *     array.slice!(index)         -> obj or nil
- *     array.slice!(start, length) -> sub_array or nil
- *     array.slice!(range)         -> sub_array or nil 
- *  
+ *     ary.slice!(index)         -> obj or nil
+ *     ary.slice!(start, length) -> new_ary or nil
+ *     ary.slice!(range)         -> new_ary or nil
+ *
  *  Deletes the element(s) given by an index (optionally with a length)
- *  or by a range. Returns the deleted object, subarray, or
+ *  or by a range. Returns the deleted object (or objects), or
  *  <code>nil</code> if the index is out of range.
- *     
+ *
  *     a = [ "a", "b", "c" ]
  *     a.slice!(1)     #=> "b"
  *     a               #=> ["a", "c"]
@@ -2099,9 +2465,9 @@ rb_ary_slice_bang(int argc, VALUE *argv, VALUE ary)
     long pos, len, orig_len;
 
     rb_ary_modify_check(ary);
-    if (rb_scan_args(argc, argv, "11", &arg1, &arg2) == 2) {
-	pos = NUM2LONG(arg1);
-	len = NUM2LONG(arg2);
+    if (argc == 2) {
+	pos = NUM2LONG(argv[0]);
+	len = NUM2LONG(argv[1]);
       delete_pos_len:
 	if (len < 0) return Qnil;
 	orig_len = RARRAY_LEN(ary);
@@ -2120,6 +2486,12 @@ rb_ary_slice_bang(int argc, VALUE *argv, VALUE ary)
 	return arg2;
     }
 
+    if (argc != 1) {
+	/* error report */
+	rb_scan_args(argc, argv, "11", NULL, NULL);
+    }
+    arg1 = argv[0];
+
     if (!FIXNUM_P(arg1)) {
 	switch (rb_range_beg_len(arg1, &pos, &len, RARRAY_LEN(ary), 0)) {
 	  case Qtrue:
@@ -2139,12 +2511,16 @@ rb_ary_slice_bang(int argc, VALUE *argv, VALUE ary)
 
 /*
  *  call-seq:
- *     array.reject! {|item| block }  -> array or nil
- *  
+ *     ary.reject! {|item| block }  -> ary or nil
+ *     ary.reject!                  -> an_enumerator
+ *
  *  Equivalent to <code>Array#delete_if</code>, deleting elements from
- *  _self_ for which the block evaluates to true, but returns
- *  <code>nil</code> if no changes were made. Also see
- *  <code>Enumerable#reject</code>.
+ *  +self+ for which the block evaluates to true, but returns
+ *  <code>nil</code> if no changes were made.
+ *  See also <code>Enumerable#reject</code> and <code>Array#delete_if</code>.
+ *
+ *  If no block is given, an enumerator is returned instead.
+ *
  */
 
 static VALUE
@@ -2171,10 +2547,15 @@ rb_ary_reject_bang(VALUE ary)
 
 /*
  *  call-seq:
- *     array.reject {|item| block }  -> an_array
- *  
- *  Returns a new array containing the items in _self_
+ *     ary.reject {|item| block }  -> new_ary
+ *     ary.reject                  -> an_enumerator
+ *
+ *  Returns a new array containing the items in +self+
  *  for which the block is not true.
+ *  See also <code>Array#delete_if</code>
+ *
+ *  If no block is given, an enumerator is returned instead.
+ *
  */
 
 static VALUE
@@ -2188,11 +2569,15 @@ rb_ary_reject(VALUE ary)
 
 /*
  *  call-seq:
- *     array.delete_if {|item| block }  -> array
- *  
- *  Deletes every element of <i>self</i> for which <i>block</i> evaluates
- *  to <code>true</code>.
- *     
+ *     ary.delete_if {|item| block }  -> ary
+ *     ary.delete_if                  -> an_enumerator
+ *
+ *  Deletes every element of +self+ for which <i>block</i> evaluates
+ *  to true.
+ *  See also <code>Array#reject!</code>
+ *
+ *  If no block is given, an enumerator is returned instead.
+ *
  *     a = [ "a", "b", "c" ]
  *     a.delete_if {|x| x >= "b" }   #=> ["a"]
  */
@@ -2230,18 +2615,18 @@ take_items(VALUE obj, long n)
 
 /*
  *  call-seq:
- *     array.zip(arg, ...)                   -> an_array
- *     array.zip(arg, ...) {| arr | block }  -> nil
- *  
+ *     ary.zip(arg, ...)                   -> new_ary
+ *     ary.zip(arg, ...) {| arr | block }  -> nil
+ *
  *  Converts any arguments to arrays, then merges elements of
- *  <i>self</i> with corresponding elements from each argument. This
+ *  +self+ with corresponding elements from each argument. This
  *  generates a sequence of <code>self.size</code> <em>n</em>-element
  *  arrays, where <em>n</em> is one more that the count of arguments. If
  *  the size of any argument is less than <code>enumObj.size</code>,
- *  <code>nil</code> values are supplied. If a block given, it is
+ *  <code>nil</code> values are supplied. If a block is given, it is
  *  invoked for each output array, otherwise an array of arrays is
  *  returned.
- *     
+ *
  *     a = [ 4, 5, 6 ]
  *     b = [ 7, 8, 9 ]
  *     [1,2,3].zip(a, b)      #=> [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
@@ -2283,11 +2668,11 @@ rb_ary_zip(int argc, VALUE *argv, VALUE ary)
 
 /*
  *  call-seq:
- *     array.transpose -> an_array
- *  
- *  Assumes that <i>self</i> is an array of arrays and transposes the
+ *     ary.transpose -> new_ary
+ *
+ *  Assumes that +self+ is an array of arrays and transposes the
  *  rows and columns.
- *     
+ *
  *     a = [[1,2], [3,4], [5,6]]
  *     a.transpose   #=> [[1, 3, 5], [2, 4, 6]]
  */
@@ -2322,11 +2707,11 @@ rb_ary_transpose(VALUE ary)
 
 /*
  *  call-seq:
- *     array.replace(other_array)  -> array
- *  
- *  Replaces the contents of <i>self</i> with the contents of
- *  <i>other_array</i>, truncating or expanding if necessary.
- *     
+ *     ary.replace(other_ary)  -> ary
+ *
+ *  Replaces the contents of +self+ with the contents of
+ *  <i>other_ary</i>, truncating or expanding if necessary.
+ *
  *     a = [ "a", "b", "c", "d", "e" ]
  *     a.replace([ "x", "y", "z" ])   #=> ["x", "y", "z"]
  *     a                              #=> ["x", "y", "z"]
@@ -2335,14 +2720,14 @@ rb_ary_transpose(VALUE ary)
 VALUE
 rb_ary_replace(VALUE copy, VALUE orig)
 {
-    orig = to_ary(orig);
     rb_ary_modify_check(copy);
+    orig = to_ary(orig);
     if (copy == orig) return copy;
 
     if (RARRAY_LEN(orig) <= RARRAY_EMBED_LEN_MAX) {
         VALUE *ptr;
         VALUE shared = 0;
-        
+
         if (ARY_OWNS_HEAP_P(copy)) {
             xfree(RARRAY_PTR(copy));
         }
@@ -2362,7 +2747,8 @@ rb_ary_replace(VALUE copy, VALUE orig)
         VALUE shared = ary_make_shared(orig);
         if (ARY_OWNS_HEAP_P(copy)) {
             xfree(RARRAY_PTR(copy));
-        } else {
+        }
+        else {
             rb_ary_unshare_safe(copy);
         }
         FL_UNSET_EMBED(copy);
@@ -2373,11 +2759,11 @@ rb_ary_replace(VALUE copy, VALUE orig)
     return copy;
 }
 
-/* 
+/*
  *  call-seq:
- *     array.clear    ->  array
+ *     ary.clear    -> ary
  *
- *  Removes all elements from _self_.
+ *  Removes all elements from +self+.
  *
  *     a = [ "a", "b", "c", "d", "e" ]
  *     a.clear    #=> [ ]
@@ -2396,20 +2782,21 @@ rb_ary_clear(VALUE ary)
 
 /*
  *  call-seq:
- *     array.fill(obj)                                -> array
- *     array.fill(obj, start [, length])              -> array
- *     array.fill(obj, range )                        -> array
- *     array.fill {|index| block }                    -> array
- *     array.fill(start [, length] ) {|index| block } -> array
- *     array.fill(range) {|index| block }             -> array
- *  
- *  The first three forms set the selected elements of <i>self</i> (which
+ *     ary.fill(obj)                                -> ary
+ *     ary.fill(obj, start [, length])              -> ary
+ *     ary.fill(obj, range )                        -> ary
+ *     ary.fill {|index| block }                    -> ary
+ *     ary.fill(start [, length] ) {|index| block } -> ary
+ *     ary.fill(range) {|index| block }             -> ary
+ *
+ *  The first three forms set the selected elements of +self+ (which
  *  may be the entire array) to <i>obj</i>. A <i>start</i> of
  *  <code>nil</code> is equivalent to zero. A <i>length</i> of
  *  <code>nil</code> is equivalent to <i>self.length</i>. The last three
  *  forms fill the array with the value of the block. The block is
  *  passed the absolute index of each element to be filled.
- *     
+ *  Negative values of <i>start</i> count from the end of the array.
+ *
  *     a = [ "a", "b", "c", "d" ]
  *     a.fill("x")              #=> ["x", "x", "x", "x"]
  *     a.fill("z", 2, 2)        #=> ["x", "x", "z", "z"]
@@ -2424,10 +2811,10 @@ rb_ary_fill(int argc, VALUE *argv, VALUE ary)
     VALUE item, arg1, arg2;
     long beg = 0, end = 0, len = 0;
     VALUE *p, *pend;
-    int block_p = Qfalse;
+    int block_p = FALSE;
 
     if (rb_block_given_p()) {
-	block_p = Qtrue;
+	block_p = TRUE;
 	rb_scan_args(argc, argv, "02", &arg1, &arg2);
 	argc += 1;		/* hackish */
     }
@@ -2489,13 +2876,13 @@ rb_ary_fill(int argc, VALUE *argv, VALUE ary)
     return ary;
 }
 
-/* 
+/*
  *  call-seq:
- *     array + other_array   -> an_array
+ *     ary + other_ary   -> new_ary
  *
  *  Concatenation---Returns a new array built by concatenating the
  *  two arrays together to produce a third array.
- * 
+ *
  *     [ 1, 2, 3 ] + [ 4, 5 ]    #=> [ 1, 2, 3, 4, 5 ]
  */
 
@@ -2514,12 +2901,12 @@ rb_ary_plus(VALUE x, VALUE y)
     return z;
 }
 
-/* 
+/*
  *  call-seq:
- *     array.concat(other_array)   ->  array
+ *     ary.concat(other_ary)   -> ary
+ *
+ *  Appends the elements of <i>other_ary</i> to +self+.
  *
- *  Appends the elements in other_array to _self_.
- *  
  *     [ "a", "b" ].concat( ["c", "d"] ) #=> [ "a", "b", "c", "d" ]
  */
 
@@ -2527,6 +2914,7 @@ rb_ary_plus(VALUE x, VALUE y)
 VALUE
 rb_ary_concat(VALUE x, VALUE y)
 {
+    rb_ary_modify_check(x);
     y = to_ary(y);
     if (RARRAY_LEN(y) > 0) {
 	rb_ary_splice(x, RARRAY_LEN(x), 0, y);
@@ -2535,14 +2923,14 @@ rb_ary_concat(VALUE x, VALUE y)
 }
 
 
-/* 
+/*
  *  call-seq:
- *     array * int     ->    an_array
- *     array * str     ->    a_string
+ *     ary * int     -> new_ary
+ *     ary * str     -> new_string
  *
  *  Repetition---With a String argument, equivalent to
  *  self.join(str). Otherwise, returns a new array
- *  built by concatenating the _int_ copies of _self_.
+ *  built by concatenating the _int_ copies of +self+.
  *
  *
  *     [ 1, 2, 3 ] * 3    #=> [ 1, 2, 3, 1, 2, 3, 1, 2, 3 ]
@@ -2553,8 +2941,8 @@ rb_ary_concat(VALUE x, VALUE y)
 static VALUE
 rb_ary_times(VALUE ary, VALUE times)
 {
-    VALUE ary2, tmp;
-    long i, len;
+    VALUE ary2, tmp, *ptr, *ptr2;
+    long i, t, len;
 
     tmp = rb_check_string_type(times);
     if (!NIL_P(tmp)) {
@@ -2577,8 +2965,11 @@ rb_ary_times(VALUE ary, VALUE times)
     ary2 = ary_new(rb_obj_class(ary), len);
     ARY_SET_LEN(ary2, len);
 
-    for (i=0; i<len; i+=RARRAY_LEN(ary)) {
-	MEMCPY(RARRAY_PTR(ary2)+i, RARRAY_PTR(ary), VALUE, RARRAY_LEN(ary));
+    ptr = RARRAY_PTR(ary);
+    ptr2 = RARRAY_PTR(ary2);
+    t = RARRAY_LEN(ary);
+    for (i=0; i<len; i+=t) {
+	MEMCPY(ptr2+i, ptr, VALUE, t);
     }
   out:
     OBJ_INFECT(ary2, ary);
@@ -2586,9 +2977,9 @@ rb_ary_times(VALUE ary, VALUE times)
     return ary2;
 }
 
-/* 
+/*
  *  call-seq:
- *     array.assoc(obj)   ->  an_array  or  nil
+ *     ary.assoc(obj)   -> new_ary  or  nil
  *
  *  Searches through an array whose elements are also arrays
  *  comparing _obj_ with the first element of each contained array
@@ -2623,13 +3014,13 @@ rb_ary_assoc(VALUE ary, VALUE key)
 
 /*
  *  call-seq:
- *     array.rassoc(obj) -> an_array or nil
- *  
+ *     ary.rassoc(obj) -> new_ary or nil
+ *
  *  Searches through the array whose elements are also arrays. Compares
  *  _obj_ with the second element of each contained array using
  *  <code>==</code>. Returns the first contained array that matches. See
  *  also <code>Array#assoc</code>.
- *     
+ *
  *     a = [ [ 1, "one"], [2, "two"], [3, "three"], ["ii", "two"] ]
  *     a.rassoc("two")    #=> [2, "two"]
  *     a.rassoc("four")   #=> nil
@@ -2656,7 +3047,7 @@ recursive_equal(VALUE ary1, VALUE ary2, int recur)
 {
     long i;
 
-    if (recur) return Qfalse;
+    if (recur) return Qtrue; /* Subtle! */
     for (i=0; i<RARRAY_LEN(ary1); i++) {
 	if (!rb_equal(rb_ary_elt(ary1, i), rb_ary_elt(ary2, i)))
 	    return Qfalse;
@@ -2664,9 +3055,9 @@ recursive_equal(VALUE ary1, VALUE ary2, int recur)
     return Qtrue;
 }
 
-/* 
+/*
  *  call-seq:
- *     array == other_array   ->   bool
+ *     ary == other_ary   ->   bool
  *
  *  Equality---Two arrays are equal if they contain the same number
  *  of elements and if each element is equal to (according to
@@ -2689,7 +3080,7 @@ rb_ary_equal(VALUE ary1, VALUE ary2)
 	return rb_equal(ary2, ary1);
     }
     if (RARRAY_LEN(ary1) != RARRAY_LEN(ary2)) return Qfalse;
-    return rb_exec_recursive(recursive_equal, ary1, ary2);
+    return rb_exec_recursive_paired(recursive_equal, ary1, ary2, ary2);
 }
 
 static VALUE
@@ -2697,7 +3088,7 @@ recursive_eql(VALUE ary1, VALUE ary2, int recur)
 {
     long i;
 
-    if (recur) return Qfalse;
+    if (recur) return Qtrue; /* Subtle! */
     for (i=0; i<RARRAY_LEN(ary1); i++) {
 	if (!rb_eql(rb_ary_elt(ary1, i), rb_ary_elt(ary2, i)))
 	    return Qfalse;
@@ -2707,9 +3098,9 @@ recursive_eql(VALUE ary1, VALUE ary2, int recur)
 
 /*
  *  call-seq:
- *     array.eql?(other)  -> true or false
+ *     ary.eql?(other)  -> true or false
  *
- *  Returns <code>true</code> if _array_ and _other_ are the same object,
+ *  Returns <code>true</code> if +self+ and _other_ are the same object,
  *  or are both arrays with the same content.
  */
 
@@ -2719,30 +3110,33 @@ rb_ary_eql(VALUE ary1, VALUE ary2)
     if (ary1 == ary2) return Qtrue;
     if (TYPE(ary2) != T_ARRAY) return Qfalse;
     if (RARRAY_LEN(ary1) != RARRAY_LEN(ary2)) return Qfalse;
-    return rb_exec_recursive(recursive_eql, ary1, ary2);
+    return rb_exec_recursive_paired(recursive_eql, ary1, ary2, ary2);
 }
 
 static VALUE
 recursive_hash(VALUE ary, VALUE dummy, int recur)
 {
-    long i, h;
+    long i;
+    st_index_t h;
     VALUE n;
 
+    h = rb_hash_start(RARRAY_LEN(ary));
     if (recur) {
-	return LONG2FIX(0);
+	h = rb_hash_uint(h, NUM2LONG(rb_hash(rb_cArray)));
     }
-    h = RARRAY_LEN(ary);
-    for (i=0; i<RARRAY_LEN(ary); i++) {
-	h = (h << 1) | (h<0 ? 1 : 0);
-	n = rb_hash(RARRAY_PTR(ary)[i]);
-	h ^= NUM2LONG(n);
+    else {
+	for (i=0; i<RARRAY_LEN(ary); i++) {
+	    n = rb_hash(RARRAY_PTR(ary)[i]);
+	    h = rb_hash_uint(h, NUM2LONG(n));
+	}
     }
+    h = rb_hash_end(h);
     return LONG2FIX(h);
 }
 
 /*
  *  call-seq:
- *     array.hash   -> fixnum
+ *     ary.hash   -> fixnum
  *
  *  Compute a hash-code for this array. Two arrays with the same content
  *  will have the same hash code (and will compare using <code>eql?</code>).
@@ -2751,17 +3145,17 @@ recursive_hash(VALUE ary, VALUE dummy, int recur)
 static VALUE
 rb_ary_hash(VALUE ary)
 {
-    return rb_exec_recursive(recursive_hash, ary, 0);
+    return rb_exec_recursive_outer(recursive_hash, ary, 0);
 }
 
 /*
  *  call-seq:
- *     array.include?(obj)   -> true or false
- *  
+ *     ary.include?(obj)   -> true or false
+ *
  *  Returns <code>true</code> if the given object is present in
- *  <i>self</i> (that is, if any object <code>==</code> <i>anObject</i>),
+ *  +self+ (that is, if any object <code>==</code> <i>anObject</i>),
  *  <code>false</code> otherwise.
- *     
+ *
  *     a = [ "a", "b", "c" ]
  *     a.include?("b")   #=> true
  *     a.include?("z")   #=> false
@@ -2771,7 +3165,7 @@ VALUE
 rb_ary_includes(VALUE ary, VALUE item)
 {
     long i;
-    
+
     for (i=0; i<RARRAY_LEN(ary); i++) {
 	if (rb_equal(RARRAY_PTR(ary)[i], item)) {
 	    return Qtrue;
@@ -2786,7 +3180,7 @@ recursive_cmp(VALUE ary1, VALUE ary2, int recur)
 {
     long i, len;
 
-    if (recur) return Qnil;
+    if (recur) return Qundef;	/* Subtle! */
     len = RARRAY_LEN(ary1);
     if (len > RARRAY_LEN(ary2)) {
 	len = RARRAY_LEN(ary2);
@@ -2800,13 +3194,13 @@ recursive_cmp(VALUE ary1, VALUE ary2, int recur)
     return Qundef;
 }
 
-/* 
+/*
  *  call-seq:
- *     array <=> other_array   ->  -1, 0, +1
+ *     ary <=> other_ary   ->  -1, 0, +1 or nil
  *
  *  Comparison---Returns an integer (-1, 0,
  *  or +1) if this array is less than, equal to, or greater than
- *  other_array.  Each object in each array is compared
+ *  <i>other_ary</i>.  Each object in each array is compared
  *  (using <=>). If any value isn't
  *  equal, then that inequality is the return value. If all the
  *  values found are equal, then the return is based on a
@@ -2814,7 +3208,7 @@ recursive_cmp(VALUE ary1, VALUE ary2, int recur)
  *  ``equal'' according to <code>Array#<=></code> if and only if they have
  *  the same length and the value of each element is equal to the
  *  value of the corresponding element in the other array.
- *  
+ *
  *     [ "a", "a", "c" ]    <=> [ "a", "b", "c" ]   #=> -1
  *     [ 1, 2, 3, 4, 5, 6 ] <=> [ 1, 2 ]            #=> +1
  *
@@ -2826,9 +3220,10 @@ rb_ary_cmp(VALUE ary1, VALUE ary2)
     long len;
     VALUE v;
 
-    ary2 = to_ary(ary2);
+    ary2 = rb_check_array_type(ary2);
+    if (NIL_P(ary2)) return Qnil;
     if (ary1 == ary2) return INT2FIX(0);
-    v = rb_exec_recursive(recursive_cmp, ary1, ary2);
+    v = rb_exec_recursive_paired(recursive_cmp, ary1, ary2, ary2);
     if (v != Qundef) return v;
     len = RARRAY_LEN(ary1) - RARRAY_LEN(ary2);
     if (len == 0) return INT2FIX(0);
@@ -2837,29 +3232,70 @@ rb_ary_cmp(VALUE ary1, VALUE ary2)
 }
 
 static VALUE
-ary_make_hash(VALUE ary1, VALUE ary2)
+ary_add_hash(VALUE hash, VALUE ary)
 {
-    VALUE hash = rb_hash_new();
     long i;
 
-    for (i=0; i<RARRAY_LEN(ary1); i++) {
-	rb_hash_aset(hash, RARRAY_PTR(ary1)[i], Qtrue);
+    for (i=0; i<RARRAY_LEN(ary); i++) {
+	rb_hash_aset(hash, RARRAY_PTR(ary)[i], Qtrue);
     }
-    if (ary2) {
-	for (i=0; i<RARRAY_LEN(ary2); i++) {
-	    rb_hash_aset(hash, RARRAY_PTR(ary2)[i], Qtrue);
+    return hash;
+}
+
+static inline VALUE
+ary_tmp_hash_new(void)
+{
+    VALUE hash = rb_hash_new();
+
+    RBASIC(hash)->klass = 0;
+    return hash;
+}
+
+static VALUE
+ary_make_hash(VALUE ary)
+{
+    VALUE hash = ary_tmp_hash_new();
+    return ary_add_hash(hash, ary);
+}
+
+static VALUE
+ary_add_hash_by(VALUE hash, VALUE ary)
+{
+    long i;
+
+    for (i = 0; i < RARRAY_LEN(ary); ++i) {
+	VALUE v = rb_ary_elt(ary, i), k = rb_yield(v);
+	if (rb_hash_lookup2(hash, k, Qundef) == Qundef) {
+	    rb_hash_aset(hash, k, v);
 	}
     }
     return hash;
 }
 
-/* 
+static VALUE
+ary_make_hash_by(VALUE ary)
+{
+    VALUE hash = ary_tmp_hash_new();
+    return ary_add_hash_by(hash, ary);
+}
+
+static inline void
+ary_recycle_hash(VALUE hash)
+{
+    if (RHASH(hash)->ntbl) {
+	st_table *tbl = RHASH(hash)->ntbl;
+	RHASH(hash)->ntbl = 0;
+	st_free_table(tbl);
+    }
+}
+
+/*
  *  call-seq:
- *     array - other_array    -> an_array
+ *     ary - other_ary    -> new_ary
  *
  *  Array Difference---Returns a new array that is a copy of
  *  the original array, removing any items that also appear in
- *  other_array. (If you need set-like behavior, see the
+ *  <i>other_ary</i>. (If you need set-like behavior, see the
  *  library class Set.)
  *
  *     [ 1, 1, 2, 2, 3, 3, 4, 5 ] - [ 1, 2, 4 ]  #=>  [ 3, 3, 5 ]
@@ -2872,19 +3308,20 @@ rb_ary_diff(VALUE ary1, VALUE ary2)
     volatile VALUE hash;
     long i;
 
-    hash = ary_make_hash(to_ary(ary2), 0);
+    hash = ary_make_hash(to_ary(ary2));
     ary3 = rb_ary_new();
 
     for (i=0; i<RARRAY_LEN(ary1); i++) {
 	if (st_lookup(RHASH_TBL(hash), RARRAY_PTR(ary1)[i], 0)) continue;
 	rb_ary_push(ary3, rb_ary_elt(ary1, i));
     }
+    ary_recycle_hash(hash);
     return ary3;
 }
 
-/* 
+/*
  *  call-seq:
- *     array & other_array
+ *     ary & other_ary      -> new_ary
  *
  *  Set Intersection---Returns a new array
  *  containing elements common to the two arrays, with no duplicates.
@@ -2902,7 +3339,7 @@ rb_ary_and(VALUE ary1, VALUE ary2)
     ary2 = to_ary(ary2);
     ary3 = rb_ary_new2(RARRAY_LEN(ary1) < RARRAY_LEN(ary2) ?
 	    RARRAY_LEN(ary1) : RARRAY_LEN(ary2));
-    hash = ary_make_hash(ary2, 0);
+    hash = ary_make_hash(ary2);
 
     if (RHASH_EMPTY_P(hash))
         return ary3;
@@ -2913,16 +3350,17 @@ rb_ary_and(VALUE ary1, VALUE ary2)
 	    rb_ary_push(ary3, v);
 	}
     }
+    ary_recycle_hash(hash);
 
     return ary3;
 }
 
-/* 
+/*
  *  call-seq:
- *     array | other_array     ->  an_array
+ *     ary | other_ary     -> new_ary
  *
  *  Set Union---Returns a new array by joining this array with
- *  other_array, removing duplicates.
+ *  <i>other_ary</i>, removing duplicates.
  *
  *     [ "a", "b", "c" ] | [ "c", "d", "a" ]
  *            #=> [ "a", "b", "c", "d" ]
@@ -2937,7 +3375,7 @@ rb_ary_or(VALUE ary1, VALUE ary2)
 
     ary2 = to_ary(ary2);
     ary3 = rb_ary_new2(RARRAY_LEN(ary1)+RARRAY_LEN(ary2));
-    hash = ary_make_hash(ary1, ary2);
+    hash = ary_add_hash(ary_make_hash(ary1), ary2);
 
     for (i=0; i<RARRAY_LEN(ary1); i++) {
 	v = vv = rb_ary_elt(ary1, i);
@@ -2951,69 +3389,120 @@ rb_ary_or(VALUE ary1, VALUE ary2)
 	    rb_ary_push(ary3, v);
 	}
     }
+    ary_recycle_hash(hash);
     return ary3;
 }
 
+static int
+push_value(st_data_t key, st_data_t val, st_data_t ary)
+{
+    rb_ary_push((VALUE)ary, (VALUE)val);
+    return ST_CONTINUE;
+}
+
 /*
  *  call-seq:
- *     array.uniq! -> array or nil
- *  
- *  Removes duplicate elements from _self_.
+ *     ary.uniq! -> ary or nil
+ *
+ *  Removes duplicate elements from +self+.
  *  Returns <code>nil</code> if no changes are made (that is, no
  *  duplicates are found).
- *     
+ *
  *     a = [ "a", "a", "b", "b", "c" ]
  *     a.uniq!   #=> ["a", "b", "c"]
  *     b = [ "a", "b", "c" ]
  *     b.uniq!   #=> nil
+ *     c = [ "a:def", "a:xyz", "b:abc", "b:xyz", "c:jkl" ]
+ *     c.uniq! {|s| s[/^\w+/]}  #=> [ "a:def", "b:abc", "c:jkl" ]
  */
 
 static VALUE
 rb_ary_uniq_bang(VALUE ary)
 {
-    VALUE hash, v, vv;
+    VALUE hash, v;
     long i, j;
 
-    hash = ary_make_hash(ary, 0);
-
-    if (RARRAY_LEN(ary) == RHASH_SIZE(hash)) {
-	return Qnil;
+    rb_ary_modify_check(ary);
+    if (RARRAY_LEN(ary) <= 1)
+        return Qnil;
+    if (rb_block_given_p()) {
+	hash = ary_make_hash_by(ary);
+	if (RARRAY_LEN(ary) == (i = RHASH_SIZE(hash))) {
+	    return Qnil;
+	}
+	ARY_SET_LEN(ary, 0);
+	if (ARY_SHARED_P(ary) && !ARY_EMBED_P(ary)) {
+	    rb_ary_unshare(ary);
+	    FL_SET_EMBED(ary);
+	}
+	ary_resize_capa(ary, i);
+	st_foreach(RHASH_TBL(hash), push_value, ary);
     }
-    for (i=j=0; i<RARRAY_LEN(ary); i++) {
-	v = vv = rb_ary_elt(ary, i);
-	if (st_delete(RHASH_TBL(hash), (st_data_t*)&vv, 0)) {
-	    rb_ary_store(ary, j++, v);
+    else {
+	hash = ary_make_hash(ary);
+	if (RARRAY_LEN(ary) == (long)RHASH_SIZE(hash)) {
+	    return Qnil;
+	}
+	for (i=j=0; i<RARRAY_LEN(ary); i++) {
+	    st_data_t vv = (st_data_t)(v = rb_ary_elt(ary, i));
+	    if (st_delete(RHASH_TBL(hash), &vv, 0)) {
+		rb_ary_store(ary, j++, v);
+	    }
 	}
+	ARY_SET_LEN(ary, j);
     }
-    ARY_SET_LEN(ary, j);
+    ary_recycle_hash(hash);
 
     return ary;
 }
 
 /*
  *  call-seq:
- *     array.uniq   -> an_array
- *  
- *  Returns a new array by removing duplicate values in <i>self</i>.
- *     
+ *     ary.uniq   -> new_ary
+ *
+ *  Returns a new array by removing duplicate values in +self+.
+ *
  *     a = [ "a", "a", "b", "b", "c" ]
  *     a.uniq   #=> ["a", "b", "c"]
+ *     c = [ "a:def", "a:xyz", "b:abc", "b:xyz", "c:jkl" ]
+ *     c.uniq {|s| s[/^\w+/]}  #=> [ "a:def", "b:abc", "c:jkl" ]
  */
 
 static VALUE
 rb_ary_uniq(VALUE ary)
 {
-    ary = rb_ary_dup(ary);
-    rb_ary_uniq_bang(ary);
-    return ary;
+    VALUE hash, uniq, v;
+    long i;
+
+    if (RARRAY_LEN(ary) <= 1)
+        return rb_ary_dup(ary);
+    if (rb_block_given_p()) {
+	hash = ary_make_hash_by(ary);
+	uniq = ary_new(rb_obj_class(ary), RHASH_SIZE(hash));
+	st_foreach(RHASH_TBL(hash), push_value, uniq);
+    }
+    else {
+	hash = ary_make_hash(ary);
+	uniq = ary_new(rb_obj_class(ary), RHASH_SIZE(hash));
+	for (i=0; i<RARRAY_LEN(ary); i++) {
+	    st_data_t vv = (st_data_t)(v = rb_ary_elt(ary, i));
+	    if (st_delete(RHASH_TBL(hash), &vv, 0)) {
+		rb_ary_push(uniq, v);
+	    }
+	}
+    }
+    ary_recycle_hash(hash);
+
+    return uniq;
 }
 
-/* 
+/*
  *  call-seq:
- *     array.compact!    ->   array  or  nil
+ *     ary.compact!    -> ary  or  nil
  *
- *  Removes +nil+ elements from array.
- *  Returns +nil+ if no changes were made.
+ *  Removes +nil+ elements from the array.
+ *  Returns +nil+ if no changes were made, otherwise returns
+ *  </i>ary</i>.
  *
  *     [ "a", nil, "b", nil, "c" ].compact! #=> [ "a", "b", "c" ]
  *     [ "a", "b", "c" ].compact!           #=> nil
@@ -3028,7 +3517,7 @@ rb_ary_compact_bang(VALUE ary)
     rb_ary_modify(ary);
     p = t = RARRAY_PTR(ary);
     end = p + RARRAY_LEN(ary);
-    
+
     while (t < end) {
 	if (NIL_P(*t)) t++;
 	else *p++ = *t++;
@@ -3047,9 +3536,9 @@ rb_ary_compact_bang(VALUE ary)
 
 /*
  *  call-seq:
- *     array.compact     ->  an_array
+ *     ary.compact     -> new_ary
  *
- *  Returns a copy of _self_ with all +nil+ elements removed.
+ *  Returns a copy of +self+ with all +nil+ elements removed.
  *
  *     [ "a", nil, "b", nil, "c", nil ].compact
  *                       #=> [ "a", "b", "c" ]
@@ -3065,18 +3554,18 @@ rb_ary_compact(VALUE ary)
 
 /*
  *  call-seq:
- *     array.count      -> int
- *     array.count(obj) -> int
- *     array.count { |item| block }  -> int
- *  
+ *     ary.count      -> int
+ *     ary.count(obj) -> int
+ *     ary.count { |item| block }  -> int
+ *
  *  Returns the number of elements.  If an argument is given, counts
  *  the number of elements which equals to <i>obj</i>.  If a block is
  *  given, counts the number of elements yielding a true value.
  *
  *     ary = [1, 2, 4, 2]
- *     ary.count             # => 4
- *     ary.count(2)          # => 2
- *     ary.count{|x|x%2==0}  # => 3
+ *     ary.count             #=> 4
+ *     ary.count(2)          #=> 2
+ *     ary.count{|x|x%2==0}  #=> 3
  *
  */
 
@@ -3166,14 +3655,14 @@ flatten(VALUE ary, int level, int *modified)
 
 /*
  *  call-seq:
- *     array.flatten! -> array or nil
- *     array.flatten!(level) -> array or nil
- *  
- *  Flattens _self_ in place.
+ *     ary.flatten!        -> ary or nil
+ *     ary.flatten!(level) -> array or nil
+ *
+ *  Flattens +self+ in place.
  *  Returns <code>nil</code> if no modifications were made (i.e.,
- *  <i>array</i> contains no subarrays.)  If the optional <i>level</i>
+ *  <i>ary</i> contains no subarrays.)  If the optional <i>level</i>
  *  argument determines the level of recursion to flatten.
- *     
+ *
  *     a = [ 1, 2, [3, [4, 5] ] ]
  *     a.flatten!   #=> [1, 2, 3, 4, 5]
  *     a.flatten!   #=> nil
@@ -3189,26 +3678,32 @@ rb_ary_flatten_bang(int argc, VALUE *argv, VALUE ary)
     VALUE result, lv;
 
     rb_scan_args(argc, argv, "01", &lv);
+    rb_ary_modify_check(ary);
     if (!NIL_P(lv)) level = NUM2INT(lv);
-    if (level == 0) return ary;
+    if (level == 0) return Qnil;
 
     result = flatten(ary, level, &mod);
-    if (mod == 0) return Qnil;
+    if (mod == 0) {
+	ary_discard(result);
+	return Qnil;
+    }
+    if (!(mod = ARY_EMBED_P(result))) rb_obj_freeze(result);
     rb_ary_replace(ary, result);
+    if (mod) ARY_SET_EMBED_LEN(result, 0);
 
     return ary;
 }
 
 /*
  *  call-seq:
- *     array.flatten -> an_array
- *     array.flatten(level) -> an_array
- *  
+ *     ary.flatten -> new_ary
+ *     ary.flatten(level) -> new_ary
+ *
  *  Returns a new array that is a one-dimensional flattening of this
  *  array (recursively). That is, for every element that is an array,
  *  extract its elements into the new array.  If the optional
  *  <i>level</i> argument determines the level of recursion to flatten.
- *     
+ *
  *     s = [ 1, 2, 3 ]           #=> [1, 2, 3]
  *     t = [ 4, 5, 6, [7, 8] ]   #=> [4, 5, 6, [7, 8]]
  *     a = [ s, t, 9, 10 ]       #=> [[1, 2, 3], [4, 5, 6, [7, 8]], 9, 10]
@@ -3235,23 +3730,25 @@ rb_ary_flatten(int argc, VALUE *argv, VALUE ary)
 
 /*
  *  call-seq:
- *     array.shuffle!        -> array
- *  
- *  Shuffles elements in _self_ in place.
+ *     ary.shuffle!        -> ary
+ *
+ *  Shuffles elements in +self+ in place.
  */
 
 
 static VALUE
 rb_ary_shuffle_bang(VALUE ary)
 {
+    VALUE *ptr;
     long i = RARRAY_LEN(ary);
 
     rb_ary_modify(ary);
+    ptr = RARRAY_PTR(ary);
     while (i) {
-	long j = rb_genrand_real()*i;
-	VALUE tmp = RARRAY_PTR(ary)[--i];
-	RARRAY_PTR(ary)[i] = RARRAY_PTR(ary)[j];
-	RARRAY_PTR(ary)[j] = tmp;
+	long j = (long)(rb_genrand_real()*i);
+	VALUE tmp = ptr[--i];
+	ptr[i] = ptr[j];
+	ptr[j] = tmp;
     }
     return ary;
 }
@@ -3259,10 +3756,10 @@ rb_ary_shuffle_bang(VALUE ary)
 
 /*
  *  call-seq:
- *     array.shuffle -> an_array
- *  
+ *     ary.shuffle -> new_ary
+ *
  *  Returns a new array with elements of this array shuffled.
- *     
+ *
  *     a = [ 1, 2, 3 ]           #=> [1, 2, 3]
  *     a.shuffle                 #=> [2, 3, 1]
  */
@@ -3278,13 +3775,15 @@ rb_ary_shuffle(VALUE ary)
 
 /*
  *  call-seq:
- *     array.sample        -> obj
- *     array.sample(n)     -> an_array
- *  
- *  Choose a random element, or the random +n+ elements, from the array.
- *  If the array is empty, the first form returns <code>nil</code>, and the
- *  second form returns an empty array.
- *  
+ *     ary.sample        -> obj
+ *     ary.sample(n)     -> new_ary
+ *
+ *  Choose a random element or +n+ random elements from the array. The elements
+ *  are chosen by using random and unique indices into the array in order to
+ *  ensure that an element doesn't repeat itself unless the array already
+ *  contained duplicate elements. If the array is empty the first form returns
+ *  <code>nil</code> and the second form returns an empty array.
+ *
  */
 
 
@@ -3294,31 +3793,31 @@ rb_ary_sample(int argc, VALUE *argv, VALUE ary)
     VALUE nv, result, *ptr;
     long n, len, i, j, k, idx[10];
 
-    len = RARRAY_LEN(ary); 
+    len = RARRAY_LEN(ary);
     if (argc == 0) {
 	if (len == 0) return Qnil;
-	i = len == 1 ? 0 : rb_genrand_real()*len;
+	i = len == 1 ? 0 : (long)(rb_genrand_real()*len);
 	return RARRAY_PTR(ary)[i];
     }
     rb_scan_args(argc, argv, "1", &nv);
     n = NUM2LONG(nv);
     if (n < 0) rb_raise(rb_eArgError, "negative sample number");
-    ptr = RARRAY_PTR(ary); 
-    len = RARRAY_LEN(ary); 
+    ptr = RARRAY_PTR(ary);
+    len = RARRAY_LEN(ary);
     if (n > len) n = len;
     switch (n) {
       case 0: return rb_ary_new2(0);
       case 1:
 	return rb_ary_new4(1, &ptr[(long)(rb_genrand_real()*len)]);
       case 2:
-	i = rb_genrand_real()*len;
-	j = rb_genrand_real()*(len-1);
+	i = (long)(rb_genrand_real()*len);
+	j = (long)(rb_genrand_real()*(len-1));
 	if (j >= i) j++;
 	return rb_ary_new3(2, ptr[i], ptr[j]);
       case 3:
-	i = rb_genrand_real()*len;
-	j = rb_genrand_real()*(len-1);
-	k = rb_genrand_real()*(len-2);
+	i = (long)(rb_genrand_real()*len);
+	j = (long)(rb_genrand_real()*(len-1));
+	k = (long)(rb_genrand_real()*(len-2));
 	{
 	    long l = j, g = i;
 	    if (j >= i) l = i, g = ++j;
@@ -3326,11 +3825,12 @@ rb_ary_sample(int argc, VALUE *argv, VALUE ary)
 	}
 	return rb_ary_new3(3, ptr[i], ptr[j], ptr[k]);
     }
-    if (n < sizeof(idx)/sizeof(idx[0])) {
+    if ((size_t)n < sizeof(idx)/sizeof(idx[0])) {
+	VALUE *ptr_result;
 	long sorted[sizeof(idx)/sizeof(idx[0])];
-	sorted[0] = idx[0] = rb_genrand_real()*len;
+	sorted[0] = idx[0] = (long)(rb_genrand_real()*len);
 	for (i=1; i<n; i++) {
-	    k = rb_genrand_real()*--len;
+	    k = (long)(rb_genrand_real()*--len);
 	    for (j = 0; j < i; ++j) {
 		if (k < sorted[j]) break;
 		++k;
@@ -3339,18 +3839,21 @@ rb_ary_sample(int argc, VALUE *argv, VALUE ary)
 	    sorted[j] = idx[i] = k;
 	}
 	result = rb_ary_new2(n);
+	ptr_result = RARRAY_PTR(result);
 	for (i=0; i<n; i++) {
-	    RARRAY_PTR(result)[i] = RARRAY_PTR(ary)[idx[i]];
+	    ptr_result[i] = ptr[idx[i]];
 	}
     }
     else {
+	VALUE *ptr_result;
 	result = rb_ary_new4(len, ptr);
+	ptr_result = RARRAY_PTR(result);
 	RB_GC_GUARD(ary);
 	for (i=0; i<n; i++) {
 	    j = (long)(rb_genrand_real()*(len-i)) + i;
-	    nv = RARRAY_PTR(result)[j];
-	    RARRAY_PTR(result)[j] = RARRAY_PTR(result)[i];
-	    RARRAY_PTR(result)[i] = nv;
+	    nv = ptr_result[j];
+	    ptr_result[j] = ptr_result[i];
+	    ptr_result[i] = nv;
 	}
     }
     ARY_SET_LEN(result, n);
@@ -3361,18 +3864,21 @@ rb_ary_sample(int argc, VALUE *argv, VALUE ary)
 
 /*
  *  call-seq:
- *     ary.cycle {|obj| block }
- *     ary.cycle(n) {|obj| block }
- *  
+ *     ary.cycle(n=nil) {|obj| block }  -> nil
+ *     ary.cycle(n=nil)                 -> an_enumerator
+ *
  *  Calls <i>block</i> for each element repeatedly _n_ times or
- *  forever if none or nil is given.  If a non-positive number is
- *  given or the array is empty, does nothing.  Returns nil if the
+ *  forever if none or +nil+ is given.  If a non-positive number is
+ *  given or the array is empty, does nothing.  Returns +nil+ if the
  *  loop has finished without getting interrupted.
- *     
+ *
+ *  If no block is given, an enumerator is returned instead.
+ *
+ *
  *     a = ["a", "b", "c"]
  *     a.cycle {|x| puts x }  # print, a, b, c, a, b, c,.. forever.
  *     a.cycle(2) {|x| puts x }  # print, a, b, c, a, b, c.
- *     
+ *
  */
 
 static VALUE
@@ -3401,13 +3907,16 @@ rb_ary_cycle(int argc, VALUE *argv, VALUE ary)
 }
 
 #define tmpbuf(n, size) rb_str_tmp_new((n)*(size))
+#define tmpbuf_discard(s) (rb_str_resize((s), 0L), RBASIC(s)->klass = rb_cString)
+#define tmpary(n) rb_ary_tmp_new(n)
+#define tmpary_discard(a) (ary_discard(a), RBASIC(a)->klass = rb_cArray)
 
 /*
  * Recursively compute permutations of r elements of the set [0..n-1].
  * When we have a complete permutation of array indexes, copy the values
- * at those indexes into a new array and yield that array. 
+ * at those indexes into a new array and yield that array.
  *
- * n: the size of the set 
+ * n: the size of the set
  * r: the number of elements in each permutation
  * p: the array (of size r) that we're filling in
  * index: what index we're filling in now
@@ -3415,7 +3924,7 @@ rb_ary_cycle(int argc, VALUE *argv, VALUE ary)
  * values: the Ruby array that holds the actual values to permute
  */
 static void
-permute0(long n, long r, long *p, long index, int *used, VALUE values)
+permute0(long n, long r, long *p, long index, char *used, VALUE values)
 {
     long i,j;
     for (i = 0; i < n; i++) {
@@ -3424,7 +3933,7 @@ permute0(long n, long r, long *p, long index, int *used, VALUE values)
 	    if (index < r-1) {             /* if not done yet */
 		used[i] = 1;               /* mark index used */
 		permute0(n, r, p, index+1, /* recurse */
-			 used, values);  
+			 used, values);
 		used[i] = 0;               /* index unused */
 	    }
 	    else {
@@ -3438,6 +3947,9 @@ permute0(long n, long r, long *p, long index, int *used, VALUE values)
 		for (j = 0; j < r; j++) result_array[j] = values_array[p[j]];
 		ARY_SET_LEN(result, r);
 		rb_yield(result);
+		if (RBASIC(values)->klass) {
+		    rb_raise(rb_eRuntimeError, "permute reentered");
+		}
 	    }
 	}
     }
@@ -3445,19 +3957,19 @@ permute0(long n, long r, long *p, long index, int *used, VALUE values)
 
 /*
  *  call-seq:
- *     ary.permutation { |p| block }          -> array
- *     ary.permutation                        -> enumerator
- *     ary.permutation(n) { |p| block }       -> array
- *     ary.permutation(n)                     -> enumerator
- *  
+ *     ary.permutation { |p| block }          -> ary
+ *     ary.permutation                        -> an_enumerator
+ *     ary.permutation(n) { |p| block }       -> ary
+ *     ary.permutation(n)                     -> an_enumerator
+ *
  * When invoked with a block, yield all permutations of length <i>n</i>
  * of the elements of <i>ary</i>, then return the array itself.
  * If <i>n</i> is not specified, yield all permutations of all elements.
- * The implementation makes no guarantees about the order in which 
+ * The implementation makes no guarantees about the order in which
  * the permutations are yielded.
  *
- * When invoked without a block, return an enumerator object instead.
- * 
+ * If no block is given, an enumerator is returned instead.
+ *
  * Examples:
  *
  *     a = [1, 2, 3]
@@ -3480,7 +3992,7 @@ rb_ary_permutation(int argc, VALUE *argv, VALUE ary)
     rb_scan_args(argc, argv, "01", &num);
     r = NIL_P(num) ? n : NUM2LONG(num);   /* Permutation size from argument */
 
-    if (r < 0 || n < r) { 
+    if (r < 0 || n < r) {
 	/* no permutations: yield nothing */
     }
     else if (r == 0) { /* exactly one permutation: the zero-length array */
@@ -3494,53 +4006,33 @@ rb_ary_permutation(int argc, VALUE *argv, VALUE ary)
     else {             /* this is the general case */
 	volatile VALUE t0 = tmpbuf(n,sizeof(long));
 	long *p = (long*)RSTRING_PTR(t0);
-	volatile VALUE t1 = tmpbuf(n,sizeof(int));
-	int *used = (int*)RSTRING_PTR(t1);
-	VALUE ary0 = ary_make_substitution(ary); /* private defensive copy of ary */
+	volatile VALUE t1 = tmpbuf(n,sizeof(char));
+	char *used = (char*)RSTRING_PTR(t1);
+	VALUE ary0 = ary_make_shared_copy(ary); /* private defensive copy of ary */
 	RBASIC(ary0)->klass = 0;
 
-	for (i = 0; i < n; i++) used[i] = 0; /* initialize array */
+	MEMZERO(used, char, n); /* initialize array */
 
 	permute0(n, r, p, 0, used, ary0); /* compute and yield permutations */
-	RB_GC_GUARD(t0);
-	RB_GC_GUARD(t1);
+	tmpbuf_discard(t0);
+	tmpbuf_discard(t1);
 	RBASIC(ary0)->klass = rb_cArray;
     }
     return ary;
 }
 
-static long
-combi_len(long n, long k)
-{
-    long i, val = 1;
-
-    if (k*2 > n) k = n-k;
-    if (k == 0) return 1;
-    if (k < 0) return 0;
-    val = 1;
-    for (i=1; i <= k; i++,n--) {
-	long m = val;
-	val *= n;
-	if (val < m) {
-	    rb_raise(rb_eRangeError, "too big for combination");
-	}
-	val /= i;
-    }
-    return val;
-}
-
 /*
  *  call-seq:
  *     ary.combination(n) { |c| block }    -> ary
- *     ary.combination(n)                  -> enumerator
- *  
- * When invoked with a block, yields all combinations of length <i>n</i> 
+ *     ary.combination(n)                  -> an_enumerator
+ *
+ * When invoked with a block, yields all combinations of length <i>n</i>
  * of elements from <i>ary</i> and then returns <i>ary</i> itself.
- * The implementation makes no guarantees about the order in which 
+ * The implementation makes no guarantees about the order in which
  * the combinations are yielded.
  *
- * When invoked without a block, returns an enumerator object instead.
- *     
+ * If no block is given, an enumerator is returned instead.
+ *
  * Examples:
  *
  *     a = [1, 2, 3, 4]
@@ -3550,7 +4042,7 @@ combi_len(long n, long k)
  *     a.combination(4).to_a  #=> [[1,2,3,4]]
  *     a.combination(0).to_a  #=> [[]] # one combination of length 0
  *     a.combination(5).to_a  #=> []   # no combinations of length 5
- *     
+ *
  */
 
 static VALUE
@@ -3575,53 +4067,242 @@ rb_ary_combination(VALUE ary, VALUE num)
     else {
 	volatile VALUE t0 = tmpbuf(n+1, sizeof(long));
 	long *stack = (long*)RSTRING_PTR(t0);
-	long nlen = combi_len(len, n);
-	volatile VALUE cc = rb_ary_new2(n);
+	volatile VALUE cc = tmpary(n);
 	VALUE *chosen = RARRAY_PTR(cc);
 	long lev = 0;
 
-	RBASIC(cc)->klass = 0;
 	MEMZERO(stack, long, n);
 	stack[0] = -1;
-	for (i = 0; i < nlen; i++) {
+	for (;;) {
 	    chosen[lev] = RARRAY_PTR(ary)[stack[lev+1]];
 	    for (lev++; lev < n; lev++) {
 		chosen[lev] = RARRAY_PTR(ary)[stack[lev+1] = stack[lev]+1];
 	    }
 	    rb_yield(rb_ary_new4(n, chosen));
+	    if (RBASIC(t0)->klass) {
+		rb_raise(rb_eRuntimeError, "combination reentered");
+	    }
 	    do {
+		if (lev == 0) goto done;
 		stack[lev--]++;
-	    } while (lev && (stack[lev+1]+n == len+lev+1));
+	    } while (stack[lev+1]+n == len+lev+1);
 	}
+    done:
+	tmpbuf_discard(t0);
+	tmpary_discard(cc);
     }
     return ary;
 }
 
+/*
+ * Recursively compute repeated permutations of r elements of the set
+ * [0..n-1].
+ * When we have a complete repeated permutation of array indexes, copy the
+ * values at those indexes into a new array and yield that array.
+ *
+ * n: the size of the set
+ * r: the number of elements in each permutation
+ * p: the array (of size r) that we're filling in
+ * index: what index we're filling in now
+ * values: the Ruby array that holds the actual values to permute
+ */
+static void
+rpermute0(long n, long r, long *p, long index, VALUE values)
+{
+    long i, j;
+    for (i = 0; i < n; i++) {
+	p[index] = i;
+	if (index < r-1) {              /* if not done yet */
+	    rpermute0(n, r, p, index+1, values); /* recurse */
+	}
+	else {
+	    /* We have a complete permutation of array indexes */
+	    /* Build a ruby array of the corresponding values */
+	    /* And yield it to the associated block */
+	    VALUE result = rb_ary_new2(r);
+	    VALUE *result_array = RARRAY_PTR(result);
+	    const VALUE *values_array = RARRAY_PTR(values);
+
+	    for (j = 0; j < r; j++) result_array[j] = values_array[p[j]];
+	    ARY_SET_LEN(result, r);
+	    rb_yield(result);
+	    if (RBASIC(values)->klass) {
+		rb_raise(rb_eRuntimeError, "repeated permute reentered");
+	    }
+	}
+    }
+}
+
 /*
  *  call-seq:
- *     ary.product(other_ary, ...)
- *  
- *  Returns an array of all combinations of elements from all arrays.
+ *     ary.repeated_permutation(n) { |p| block } -> ary
+ *     ary.repeated_permutation(n)               -> an_enumerator
+ *
+ * When invoked with a block, yield all repeated permutations of length
+ * <i>n</i> of the elements of <i>ary</i>, then return the array itself.
+ * The implementation makes no guarantees about the order in which
+ * the repeated permutations are yielded.
+ *
+ * If no block is given, an enumerator is returned instead.
+ *
+ * Examples:
+ *
+ *     a = [1, 2]
+ *     a.repeated_permutation(1).to_a  #=> [[1], [2]]
+ *     a.repeated_permutation(2).to_a  #=> [[1,1],[1,2],[2,1],[2,2]]
+ *     a.repeated_permutation(3).to_a  #=> [[1,1,1],[1,1,2],[1,2,1],[1,2,2],
+ *                                     #    [2,1,1],[2,1,2],[2,2,1],[2,2,2]]
+ *     a.repeated_permutation(0).to_a  #=> [[]] # one permutation of length 0
+ */
+
+static VALUE
+rb_ary_repeated_permutation(VALUE ary, VALUE num)
+{
+    long r, n, i;
+
+    n = RARRAY_LEN(ary);                  /* Array length */
+    RETURN_ENUMERATOR(ary, 1, &num);      /* Return enumerator if no block */
+    r = NUM2LONG(num);                    /* Permutation size from argument */
+
+    if (r < 0) {
+	/* no permutations: yield nothing */
+    }
+    else if (r == 0) { /* exactly one permutation: the zero-length array */
+	rb_yield(rb_ary_new2(0));
+    }
+    else if (r == 1) { /* this is a special, easy case */
+	for (i = 0; i < RARRAY_LEN(ary); i++) {
+	    rb_yield(rb_ary_new3(1, RARRAY_PTR(ary)[i]));
+	}
+    }
+    else {             /* this is the general case */
+	volatile VALUE t0 = tmpbuf(r, sizeof(long));
+	long *p = (long*)RSTRING_PTR(t0);
+	VALUE ary0 = ary_make_shared_copy(ary); /* private defensive copy of ary */
+	RBASIC(ary0)->klass = 0;
+
+	rpermute0(n, r, p, 0, ary0); /* compute and yield repeated permutations */
+	tmpbuf_discard(t0);
+	RBASIC(ary0)->klass = rb_cArray;
+    }
+    return ary;
+}
+
+static void
+rcombinate0(long n, long r, long *p, long index, long rest, VALUE values)
+{
+    long j;
+    if (rest > 0) {
+	for (; index < n; ++index) {
+	    p[r-rest] = index;
+	    rcombinate0(n, r, p, index, rest-1, values);
+	}
+    }
+    else {
+	VALUE result = rb_ary_new2(r);
+	VALUE *result_array = RARRAY_PTR(result);
+	const VALUE *values_array = RARRAY_PTR(values);
+
+	for (j = 0; j < r; ++j) result_array[j] = values_array[p[j]];
+	ARY_SET_LEN(result, r);
+	rb_yield(result);
+	if (RBASIC(values)->klass) {
+	    rb_raise(rb_eRuntimeError, "repeated combination reentered");
+	}
+    }
+}
+
+/*
+ *  call-seq:
+ *     ary.repeated_combination(n) { |c| block } -> ary
+ *     ary.repeated_combination(n)               -> an_enumerator
+ *
+ * When invoked with a block, yields all repeated combinations of
+ * length <i>n</i> of elements from <i>ary</i> and then returns
+ * <i>ary</i> itself.
+ * The implementation makes no guarantees about the order in which
+ * the repeated combinations are yielded.
+ *
+ * If no block is given, an enumerator is returned instead.
+ *
+ * Examples:
+ *
+ *     a = [1, 2, 3]
+ *     a.repeated_combination(1).to_a  #=> [[1], [2], [3]]
+ *     a.repeated_combination(2).to_a  #=> [[1,1],[1,2],[1,3],[2,2],[2,3],[3,3]]
+ *     a.repeated_combination(3).to_a  #=> [[1,1,1],[1,1,2],[1,1,3],[1,2,2],[1,2,3],
+ *                                     #    [1,3,3],[2,2,2],[2,2,3],[2,3,3],[3,3,3]]
+ *     a.repeated_combination(4).to_a  #=> [[1,1,1,1],[1,1,1,2],[1,1,1,3],[1,1,2,2],[1,1,2,3],
+ *                                     #    [1,1,3,3],[1,2,2,2],[1,2,2,3],[1,2,3,3],[1,3,3,3],
+ *                                     #    [2,2,2,2],[2,2,2,3],[2,2,3,3],[2,3,3,3],[3,3,3,3]]
+ *     a.repeated_combination(0).to_a  #=> [[]] # one combination of length 0
+ *
+ */
+
+static VALUE
+rb_ary_repeated_combination(VALUE ary, VALUE num)
+{
+    long n, i, len;
+
+    n = NUM2LONG(num);                 /* Combination size from argument */
+    RETURN_ENUMERATOR(ary, 1, &num);   /* Return enumerator if no block */
+    len = RARRAY_LEN(ary);
+    if (n < 0) {
+	/* yield nothing */
+    }
+    else if (n == 0) {
+	rb_yield(rb_ary_new2(0));
+    }
+    else if (n == 1) {
+	for (i = 0; i < len; i++) {
+	    rb_yield(rb_ary_new3(1, RARRAY_PTR(ary)[i]));
+	}
+    }
+    else if (len == 0) {
+	/* yield nothing */
+    }
+    else {
+	volatile VALUE t0 = tmpbuf(n, sizeof(long));
+	long *p = (long*)RSTRING_PTR(t0);
+	VALUE ary0 = ary_make_shared_copy(ary); /* private defensive copy of ary */
+	RBASIC(ary0)->klass = 0;
+
+	rcombinate0(len, n, p, 0, n, ary0); /* compute and yield repeated combinations */
+	tmpbuf_discard(t0);
+	RBASIC(ary0)->klass = rb_cArray;
+    }
+    return ary;
+}
+
+/*
+ *  call-seq:
+ *     ary.product(other_ary, ...)                -> new_ary
+ *     ary.product(other_ary, ...) { |p| block }  -> ary
+ *
+ *  Returns an array of all combinations of elements from all arrays,
  *  The length of the returned array is the product of the length
- *  of ary and the argument arrays
- *     
- *     [1,2,3].product([4,5])     # => [[1,4],[1,5],[2,4],[2,5],[3,4],[3,5]]
- *     [1,2].product([1,2])       # => [[1,1],[1,2],[2,1],[2,2]]
- *     [1,2].product([3,4],[5,6]) # => [[1,3,5],[1,3,6],[1,4,5],[1,4,6],
+ *  of +self+ and the argument arrays.
+ *  If given a block, <i>product</i> will yield all combinations
+ *  and return +self+ instead.
+ *
+ *
+ *     [1,2,3].product([4,5])     #=> [[1,4],[1,5],[2,4],[2,5],[3,4],[3,5]]
+ *     [1,2].product([1,2])       #=> [[1,1],[1,2],[2,1],[2,2]]
+ *     [1,2].product([3,4],[5,6]) #=> [[1,3,5],[1,3,6],[1,4,5],[1,4,6],
  *                                #     [2,3,5],[2,3,6],[2,4,5],[2,4,6]]
- *     [1,2].product()            # => [[1],[2]]
- *     [1,2].product([])          # => []
+ *     [1,2].product()            #=> [[1],[2]]
+ *     [1,2].product([])          #=> []
  */
 
 static VALUE
 rb_ary_product(int argc, VALUE *argv, VALUE ary)
 {
     int n = argc+1;    /* How many arrays we're operating on */
-    volatile VALUE t0 = tmpbuf(n, sizeof(VALUE));
+    volatile VALUE t0 = tmpary(n);
     volatile VALUE t1 = tmpbuf(n, sizeof(int));
-    VALUE *arrays = (VALUE*)RSTRING_PTR(t0); /* The arrays we're computing the product of */
+    VALUE *arrays = RARRAY_PTR(t0); /* The arrays we're computing the product of */
     int *counters = (int*)RSTRING_PTR(t1); /* The current position in each one */
-    VALUE result;      /* The array we'll be returning */
+    VALUE result = Qnil;      /* The array we'll be returning, when no block given */
     long i,j;
     long resultlen = 1;
 
@@ -3629,25 +4310,38 @@ rb_ary_product(int argc, VALUE *argv, VALUE ary)
     RBASIC(t1)->klass = 0;
 
     /* initialize the arrays of arrays */
+    ARY_SET_LEN(t0, n);
     arrays[0] = ary;
+    for (i = 1; i < n; i++) arrays[i] = Qnil;
     for (i = 1; i < n; i++) arrays[i] = to_ary(argv[i-1]);
-    
+
     /* initialize the counters for the arrays */
     for (i = 0; i < n; i++) counters[i] = 0;
 
-    /* Compute the length of the result array; return [] if any is empty */
-    for (i = 0; i < n; i++) {
-	long k = RARRAY_LEN(arrays[i]), l = resultlen;
-	if (k == 0) return rb_ary_new2(0);
-	resultlen *= k;
-	if (resultlen < k || resultlen < l || resultlen / k != l) {
-	    rb_raise(rb_eRangeError, "too big to product");
+    /* Otherwise, allocate and fill in an array of results */
+    if (rb_block_given_p()) {
+	/* Make defensive copies of arrays; exit if any is empty */
+	for (i = 0; i < n; i++) {
+	    if (RARRAY_LEN(arrays[i]) == 0) goto done;
+	    arrays[i] = ary_make_shared_copy(arrays[i]);
 	}
     }
-
-    /* Otherwise, allocate and fill in an array of results */
-    result = rb_ary_new2(resultlen);
-    for (i = 0; i < resultlen; i++) {
+    else {
+	/* Compute the length of the result array; return [] if any is empty */
+	for (i = 0; i < n; i++) {
+	    long k = RARRAY_LEN(arrays[i]), l = resultlen;
+	    if (k == 0) {
+		result = rb_ary_new2(0);
+		goto done;
+	    }
+	    resultlen *= k;
+	    if (resultlen < k || resultlen < l || resultlen / k != l) {
+		rb_raise(rb_eRangeError, "too big to product");
+	    }
+	}
+	result = rb_ary_new2(resultlen);
+    }
+    for (;;) {
 	int m;
 	/* fill in one subarray */
 	VALUE subarray = rb_ary_new2(n);
@@ -3656,7 +4350,19 @@ rb_ary_product(int argc, VALUE *argv, VALUE ary)
 	}
 
 	/* put it on the result array */
-	rb_ary_push(result, subarray);
+	if(NIL_P(result)) {
+	    FL_SET(t0, FL_USER5);
+	    rb_yield(subarray);
+	    if (! FL_TEST(t0, FL_USER5)) {
+		rb_raise(rb_eRuntimeError, "product reentered");
+	    }
+	    else {
+		FL_UNSET(t0, FL_USER5);
+	    }
+	}
+	else {
+	    rb_ary_push(result, subarray);
+	}
 
 	/*
 	 * Increment the last counter.  If it overflows, reset to 0
@@ -3664,25 +4370,29 @@ rb_ary_product(int argc, VALUE *argv, VALUE ary)
 	 */
 	m = n-1;
 	counters[m]++;
-	while (m > 0 && counters[m] == RARRAY_LEN(arrays[m])) {
+	while (counters[m] == RARRAY_LEN(arrays[m])) {
 	    counters[m] = 0;
-	    m--;
+	    /* If the first counter overlows, we are done */
+	    if (--m < 0) goto done;
 	    counters[m]++;
 	}
     }
+done:
+    tmpary_discard(t0);
+    tmpbuf_discard(t1);
 
-    return result;
+    return NIL_P(result) ? ary : result;
 }
 
 /*
  *  call-seq:
- *     ary.take(n)               => array
- *  
+ *     ary.take(n)               -> new_ary
+ *
  *  Returns first n elements from <i>ary</i>.
- *     
+ *
  *     a = [1, 2, 3, 4, 5, 0]
- *     a.take(3)             # => [1, 2, 3]
- *     
+ *     a.take(3)             #=> [1, 2, 3]
+ *
  */
 
 static VALUE
@@ -3697,14 +4407,17 @@ rb_ary_take(VALUE obj, VALUE n)
 
 /*
  *  call-seq:
- *     ary.take_while {|arr| block }   => array
- *  
- *  Passes elements to the block until the block returns nil or false,
+ *     ary.take_while {|arr| block }   -> new_ary
+ *     ary.take_while                  -> an_enumerator
+ *
+ *  Passes elements to the block until the block returns +nil+ or +false+,
  *  then stops iterating and returns an array of all prior elements.
- *     
+ *
+ *  If no block is given, an enumerator is returned instead.
+ *
  *     a = [1, 2, 3, 4, 5, 0]
- *     a.take_while {|i| i < 3 }   # => [1, 2]
- *     
+ *     a.take_while {|i| i < 3 }   #=> [1, 2]
+ *
  */
 
 static VALUE
@@ -3721,14 +4434,14 @@ rb_ary_take_while(VALUE ary)
 
 /*
  *  call-seq:
- *     ary.drop(n)               => array
- *  
+ *     ary.drop(n)               -> new_ary
+ *
  *  Drops first n elements from <i>ary</i>, and returns rest elements
  *  in an array.
- *     
+ *
  *     a = [1, 2, 3, 4, 5, 0]
- *     a.drop(3)             # => [4, 5, 0]
- *     
+ *     a.drop(3)             #=> [4, 5, 0]
+ *
  */
 
 static VALUE
@@ -3747,15 +4460,18 @@ rb_ary_drop(VALUE ary, VALUE n)
 
 /*
  *  call-seq:
- *     ary.drop_while {|arr| block }   => array
- *  
+ *     ary.drop_while {|arr| block }   -> new_ary
+ *     ary.drop_while                  -> an_enumerator
+ *
  *  Drops elements up to, but not including, the first element for
- *  which the block returns nil or false and returns an array
+ *  which the block returns +nil+ or +false+ and returns an array
  *  containing the remaining elements.
- *     
+ *
+ *  If no block is given, an enumerator is returned instead.
+ *
  *     a = [1, 2, 3, 4, 5, 0]
- *     a.drop_while {|i| i < 3 }   # => [3, 4, 5, 0]
- *     
+ *     a.drop_while {|i| i < 3 }   #=> [3, 4, 5, 0]
+ *
  */
 
 static VALUE
@@ -3772,11 +4488,11 @@ rb_ary_drop_while(VALUE ary)
 
 
 
-/* Arrays are ordered, integer-indexed collections of any object. 
- * Array indexing starts at 0, as in C or Java.  A negative index is 
- * assumed to be relative to the end of the array---that is, an index of -1 
- * indicates the last element of the array, -2 is the next to last 
- * element in the array, and so on. 
+/* Arrays are ordered, integer-indexed collections of any object.
+ * Array indexing starts at 0, as in C or Java.  A negative index is
+ * assumed to be relative to the end of the array---that is, an index of -1
+ * indicates the last element of the array, -2 is the next to last
+ * element in the array, and so on.
  */
 
 void
@@ -3794,8 +4510,8 @@ Init_Array(void)
     rb_define_method(rb_cArray, "initialize", rb_ary_initialize, -1);
     rb_define_method(rb_cArray, "initialize_copy", rb_ary_replace, 1);
 
-    rb_define_method(rb_cArray, "to_s", rb_ary_inspect, 0);
     rb_define_method(rb_cArray, "inspect", rb_ary_inspect, 0);
+    rb_define_alias(rb_cArray,  "to_s", "inspect");
     rb_define_method(rb_cArray, "to_a", rb_ary_to_a, 0);
     rb_define_method(rb_cArray, "to_ary", rb_ary_to_ary_m, 0);
     rb_define_method(rb_cArray, "frozen?",  rb_ary_frozen_p, 0);
@@ -3829,13 +4545,18 @@ Init_Array(void)
     rb_define_method(rb_cArray, "join", rb_ary_join_m, -1);
     rb_define_method(rb_cArray, "reverse", rb_ary_reverse_m, 0);
     rb_define_method(rb_cArray, "reverse!", rb_ary_reverse_bang, 0);
+    rb_define_method(rb_cArray, "rotate", rb_ary_rotate_m, -1);
+    rb_define_method(rb_cArray, "rotate!", rb_ary_rotate_bang, -1);
     rb_define_method(rb_cArray, "sort", rb_ary_sort, 0);
     rb_define_method(rb_cArray, "sort!", rb_ary_sort_bang, 0);
+    rb_define_method(rb_cArray, "sort_by!", rb_ary_sort_by_bang, 0);
     rb_define_method(rb_cArray, "collect", rb_ary_collect, 0);
     rb_define_method(rb_cArray, "collect!", rb_ary_collect_bang, 0);
     rb_define_method(rb_cArray, "map", rb_ary_collect, 0);
     rb_define_method(rb_cArray, "map!", rb_ary_collect_bang, 0);
     rb_define_method(rb_cArray, "select", rb_ary_select, 0);
+    rb_define_method(rb_cArray, "select!", rb_ary_select_bang, 0);
+    rb_define_method(rb_cArray, "keep_if", rb_ary_keep_if, 0);
     rb_define_method(rb_cArray, "values_at", rb_ary_values_at, -1);
     rb_define_method(rb_cArray, "delete", rb_ary_delete, 1);
     rb_define_method(rb_cArray, "delete_at", rb_ary_delete_at_m, 1);
@@ -3876,6 +4597,8 @@ Init_Array(void)
     rb_define_method(rb_cArray, "cycle", rb_ary_cycle, -1);
     rb_define_method(rb_cArray, "permutation", rb_ary_permutation, -1);
     rb_define_method(rb_cArray, "combination", rb_ary_combination, 1);
+    rb_define_method(rb_cArray, "repeated_permutation", rb_ary_repeated_permutation, 1);
+    rb_define_method(rb_cArray, "repeated_combination", rb_ary_repeated_combination, 1);
     rb_define_method(rb_cArray, "product", rb_ary_product, -1);
 
     rb_define_method(rb_cArray, "take", rb_ary_take, 1);