diff options
Diffstat (limited to 'enum.c')
| -rw-r--r-- | enum.c | 3688 |
1 files changed, 1293 insertions, 2395 deletions
@@ -9,39 +9,18 @@ **********************************************************************/ -#include "id.h" #include "internal.h" -#include "internal/compar.h" -#include "internal/enum.h" -#include "internal/hash.h" -#include "internal/imemo.h" -#include "internal/numeric.h" -#include "internal/object.h" -#include "internal/proc.h" -#include "internal/rational.h" -#include "internal/re.h" #include "ruby/util.h" -#include "ruby_assert.h" +#include "id.h" #include "symbol.h" +#include <assert.h> + VALUE rb_mEnumerable; static ID id_next; -static ID id__alone; -static ID id__separator; -static ID id_chunk_categorize; -static ID id_chunk_enumerable; -static ID id_sliceafter_enum; -static ID id_sliceafter_pat; -static ID id_sliceafter_pred; -static ID id_slicebefore_enumerable; -static ID id_slicebefore_sep_pat; -static ID id_slicebefore_sep_pred; -static ID id_slicewhen_enum; -static ID id_slicewhen_inverted; -static ID id_slicewhen_pred; - -#define id_div idDiv +static ID id_div; + #define id_each idEach #define id_eqq idEqq #define id_cmp idCmp @@ -65,9 +44,9 @@ static VALUE enum_yield(int argc, VALUE ary) { if (argc > 1) - return rb_yield_force_blockarg(ary); + return rb_yield_force_blockarg(ary); if (argc == 1) - return rb_yield(ary); + return rb_yield(ary); return rb_yield_values2(0, 0); } @@ -77,9 +56,9 @@ enum_yield_array(VALUE ary) long len = RARRAY_LEN(ary); if (len > 1) - return rb_yield_force_blockarg(ary); + return rb_yield_force_blockarg(ary); if (len == 1) - return rb_yield(RARRAY_AREF(ary, 0)); + return rb_yield(RARRAY_AREF(ary, 0)); return rb_yield_values2(0, 0); } @@ -90,23 +69,7 @@ grep_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args)) ENUM_WANT_SVALUE(); if (RTEST(rb_funcallv(memo->v1, id_eqq, 1, &i)) == RTEST(memo->u3.value)) { - rb_ary_push(memo->v2, i); - } - return Qnil; -} - -static VALUE -grep_regexp_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args)) -{ - struct MEMO *memo = MEMO_CAST(args); - VALUE converted_element, match; - ENUM_WANT_SVALUE(); - - /* In case element can't be converted to a Symbol or String: not a match (don't raise) */ - converted_element = SYMBOL_P(i) ? i : rb_check_string_type(i); - match = NIL_P(converted_element) ? Qfalse : rb_reg_match_p(memo->v1, i, 0); - if (match == memo->u3.value) { - rb_ary_push(memo->v2, i); + rb_ary_push(memo->v2, i); } return Qnil; } @@ -118,93 +81,64 @@ grep_iter_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args)) ENUM_WANT_SVALUE(); if (RTEST(rb_funcallv(memo->v1, id_eqq, 1, &i)) == RTEST(memo->u3.value)) { - rb_ary_push(memo->v2, enum_yield(argc, i)); + rb_ary_push(memo->v2, enum_yield(argc, i)); } return Qnil; } -static VALUE -enum_grep0(VALUE obj, VALUE pat, VALUE test) -{ - VALUE ary = rb_ary_new(); - struct MEMO *memo = MEMO_NEW(pat, ary, test); - rb_block_call_func_t fn; - if (rb_block_given_p()) { - fn = grep_iter_i; - } - else if (RB_TYPE_P(pat, T_REGEXP) && - LIKELY(rb_method_basic_definition_p(CLASS_OF(pat), idEqq))) { - fn = grep_regexp_i; - } - else { - fn = grep_i; - } - rb_block_call(obj, id_each, 0, 0, fn, (VALUE)memo); - - return ary; -} - /* - * call-seq: - * grep(pattern) -> array - * grep(pattern) {|element| ... } -> array - * - * Returns an array of objects based elements of +self+ that match the given pattern. - * - * With no block given, returns an array containing each element - * for which <tt>pattern === element</tt> is +true+: - * - * a = ['foo', 'bar', 'car', 'moo'] - * a.grep(/ar/) # => ["bar", "car"] - * (1..10).grep(3..8) # => [3, 4, 5, 6, 7, 8] - * ['a', 'b', 0, 1].grep(Integer) # => [0, 1] + * call-seq: + * enum.grep(pattern) -> array + * enum.grep(pattern) { |obj| block } -> array * - * With a block given, - * calls the block with each matching element and returns an array containing each - * object returned by the block: + * Returns an array of every element in <i>enum</i> for which + * <code>Pattern === element</code>. If the optional <em>block</em> is + * supplied, each matching element is passed to it, and the block's + * result is stored in the output array. * - * a = ['foo', 'bar', 'car', 'moo'] - * a.grep(/ar/) {|element| element.upcase } # => ["BAR", "CAR"] + * (1..100).grep 38..44 #=> [38, 39, 40, 41, 42, 43, 44] + * c = IO.constants + * c.grep(/SEEK/) #=> [:SEEK_SET, :SEEK_CUR, :SEEK_END] + * res = c.grep(/SEEK/) { |v| IO.const_get(v) } + * res #=> [0, 1, 2] * - * Related: #grep_v. */ static VALUE enum_grep(VALUE obj, VALUE pat) { - return enum_grep0(obj, pat, Qtrue); + VALUE ary = rb_ary_new(); + struct MEMO *memo = MEMO_NEW(pat, ary, Qtrue); + + rb_block_call(obj, id_each, 0, 0, rb_block_given_p() ? grep_iter_i : grep_i, (VALUE)memo); + + return ary; } /* - * call-seq: - * grep_v(pattern) -> array - * grep_v(pattern) {|element| ... } -> array - * - * Returns an array of objects based on elements of +self+ - * that <em>don't</em> match the given pattern. - * - * With no block given, returns an array containing each element - * for which <tt>pattern === element</tt> is +false+: - * - * a = ['foo', 'bar', 'car', 'moo'] - * a.grep_v(/ar/) # => ["foo", "moo"] - * (1..10).grep_v(3..8) # => [1, 2, 9, 10] - * ['a', 'b', 0, 1].grep_v(Integer) # => ["a", "b"] + * call-seq: + * enum.grep_v(pattern) -> array + * enum.grep_v(pattern) { |obj| block } -> array * - * With a block given, - * calls the block with each non-matching element and returns an array containing each - * object returned by the block: + * Inverted version of Enumerable#grep. + * Returns an array of every element in <i>enum</i> for which + * not <code>Pattern === element</code>. * - * a = ['foo', 'bar', 'car', 'moo'] - * a.grep_v(/ar/) {|element| element.upcase } # => ["FOO", "MOO"] + * (1..10).grep_v 2..5 #=> [1, 6, 7, 8, 9, 10] + * res =(1..10).grep_v(2..5) { |v| v * 2 } + * res #=> [2, 12, 14, 16, 18, 20] * - * Related: #grep. */ static VALUE enum_grep_v(VALUE obj, VALUE pat) { - return enum_grep0(obj, pat, Qfalse); + VALUE ary = rb_ary_new(); + struct MEMO *memo = MEMO_NEW(pat, ary, Qfalse); + + rb_block_call(obj, id_each, 0, 0, rb_block_given_p() ? grep_iter_i : grep_i, (VALUE)memo); + + return ary; } #define COUNT_BIGNUM IMEMO_FL_USER0 @@ -214,13 +148,13 @@ static void imemo_count_up(struct MEMO *memo) { if (memo->flags & COUNT_BIGNUM) { - MEMO_V3_SET(memo, rb_int_succ(memo->u3.value)); + MEMO_V3_SET(memo, rb_int_succ(memo->u3.value)); } else if (++memo->u3.cnt == 0) { - /* overflow */ - unsigned long buf[2] = {0, 1}; - MEMO_V3_SET(memo, rb_big_unpack(buf, 2)); - memo->flags |= COUNT_BIGNUM; + /* overflow */ + unsigned long buf[2] = {0, 1}; + MEMO_V3_SET(memo, rb_big_unpack(buf, 2)); + memo->flags |= COUNT_BIGNUM; } } @@ -228,10 +162,10 @@ static VALUE imemo_count_value(struct MEMO *memo) { if (memo->flags & COUNT_BIGNUM) { - return memo->u3.value; + return memo->u3.value; } else { - return ULONG2NUM(memo->u3.cnt); + return ULONG2NUM(memo->u3.cnt); } } @@ -243,7 +177,7 @@ count_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memop)) ENUM_WANT_SVALUE(); if (rb_equal(i, memo->v1)) { - imemo_count_up(memo); + imemo_count_up(memo); } return Qnil; } @@ -254,7 +188,7 @@ count_iter_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memop)) struct MEMO *memo = MEMO_CAST(memop); if (RTEST(rb_yield_values2(argc, argv))) { - imemo_count_up(memo); + imemo_count_up(memo); } return Qnil; } @@ -269,28 +203,20 @@ count_all_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memop)) } /* - * call-seq: - * count -> integer - * count(object) -> integer - * count {|element| ... } -> integer - * - * Returns the count of elements, based on an argument or block criterion, if given. - * - * With no argument and no block given, returns the number of elements: - * - * [0, 1, 2].count # => 3 - * {foo: 0, bar: 1, baz: 2}.count # => 3 - * - * With argument +object+ given, - * returns the number of elements that are <tt>==</tt> to +object+: - * - * [0, 1, 2, 1].count(1) # => 2 + * call-seq: + * enum.count -> int + * enum.count(item) -> int + * enum.count { |obj| block } -> int * - * With a block given, calls the block with each element - * and returns the number of elements for which the block returns a truthy value: + * Returns the number of items in +enum+ through enumeration. + * If an argument is given, the number of items in +enum+ that + * are equal to +item+ are counted. If a block is given, it + * counts the number of elements yielding a true value. * - * [0, 1, 2, 3].count {|element| element < 2} # => 2 - * {foo: 0, bar: 1, baz: 2}.count {|key, value| value < 2} # => 2 + * ary = [1, 2, 4, 2] + * ary.count #=> 4 + * ary.count(2) #=> 2 + * ary.count{ |x| x%2==0 } #=> 3 * */ @@ -302,18 +228,18 @@ enum_count(int argc, VALUE *argv, VALUE obj) rb_block_call_func *func; if (argc == 0) { - if (rb_block_given_p()) { - func = count_iter_i; - } - else { - func = count_all_i; - } + if (rb_block_given_p()) { + func = count_iter_i; + } + else { + func = count_all_i; + } } else { - rb_scan_args(argc, argv, "1", &item); - if (rb_block_given_p()) { - rb_warn("given block not used"); - } + rb_scan_args(argc, argv, "1", &item); + if (rb_block_given_p()) { + rb_warn("given block not used"); + } func = count_i; } @@ -322,75 +248,59 @@ enum_count(int argc, VALUE *argv, VALUE obj) return imemo_count_value(memo); } -NORETURN(static void found(VALUE i, VALUE memop)); -static void -found(VALUE i, VALUE memop) { - struct MEMO *memo = MEMO_CAST(memop); - MEMO_V1_SET(memo, i); - memo->u3.cnt = 1; - rb_iter_break(); -} - -static VALUE -find_i_fast(RB_BLOCK_CALL_FUNC_ARGLIST(i, memop)) -{ - if (RTEST(rb_yield_values2(argc, argv))) { - ENUM_WANT_SVALUE(); - found(i, memop); - } - return Qnil; -} - static VALUE find_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memop)) { ENUM_WANT_SVALUE(); if (RTEST(enum_yield(argc, i))) { - found(i, memop); + struct MEMO *memo = MEMO_CAST(memop); + MEMO_V1_SET(memo, i); + memo->u3.cnt = 1; + rb_iter_break(); } return Qnil; } /* - * call-seq: - * find(if_none_proc = nil) {|element| ... } -> object or nil - * find(if_none_proc = nil) -> enumerator - * - * Returns the first element for which the block returns a truthy value. - * - * With a block given, calls the block with successive elements of the collection; - * returns the first element for which the block returns a truthy value: + * call-seq: + * enum.detect(ifnone = nil) { |obj| block } -> obj or nil + * enum.find(ifnone = nil) { |obj| block } -> obj or nil + * enum.detect(ifnone = nil) -> an_enumerator + * enum.find(ifnone = nil) -> an_enumerator * - * (0..9).find {|element| element > 2} # => 3 + * Passes each entry in <i>enum</i> to <em>block</em>. Returns the + * first for which <em>block</em> is not false. If no + * object matches, calls <i>ifnone</i> and returns its result when it + * is specified, or returns <code>nil</code> otherwise. * - * If no such element is found, calls +if_none_proc+ and returns its return value. + * If no block is given, an enumerator is returned instead. * - * (0..9).find(proc {false}) {|element| element > 12} # => false - * {foo: 0, bar: 1, baz: 2}.find {|key, value| key.start_with?('b') } # => [:bar, 1] - * {foo: 0, bar: 1, baz: 2}.find(proc {[]}) {|key, value| key.start_with?('c') } # => [] + * (1..100).detect => #<Enumerator: 1..100:detect> + * (1..100).find => #<Enumerator: 1..100:find> * - * With no block given, returns an Enumerator. + * (1..10).detect { |i| i % 5 == 0 and i % 7 == 0 } #=> nil + * (1..10).find { |i| i % 5 == 0 and i % 7 == 0 } #=> nil + * (1..100).detect { |i| i % 5 == 0 and i % 7 == 0 } #=> 35 + * (1..100).find { |i| i % 5 == 0 and i % 7 == 0 } #=> 35 * */ + static VALUE enum_find(int argc, VALUE *argv, VALUE obj) { struct MEMO *memo; VALUE if_none; - if_none = rb_check_arity(argc, 0, 1) ? argv[0] : Qnil; + rb_scan_args(argc, argv, "01", &if_none); RETURN_ENUMERATOR(obj, argc, argv); memo = MEMO_NEW(Qundef, 0, 0); - if (rb_block_pair_yield_optimizable()) - rb_block_call2(obj, id_each, 0, 0, find_i_fast, (VALUE)memo, RB_BLOCK_NO_USE_PACKED_ARGS); - else - rb_block_call2(obj, id_each, 0, 0, find_i, (VALUE)memo, RB_BLOCK_NO_USE_PACKED_ARGS); + rb_block_call(obj, id_each, 0, 0, find_i, (VALUE)memo); if (memo->u3.cnt) { - return memo->v1; + return memo->v1; } if (!NIL_P(if_none)) { - return rb_funcallv(if_none, id_call, 0, 0); + return rb_funcallv(if_none, id_call, 0, 0); } return Qnil; } @@ -403,8 +313,8 @@ find_index_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memop)) ENUM_WANT_SVALUE(); if (rb_equal(i, memo->v2)) { - MEMO_V1_SET(memo, imemo_count_value(memo)); - rb_iter_break(); + MEMO_V1_SET(memo, imemo_count_value(memo)); + rb_iter_break(); } imemo_count_up(memo); return Qnil; @@ -416,34 +326,29 @@ find_index_iter_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memop)) struct MEMO *memo = MEMO_CAST(memop); if (RTEST(rb_yield_values2(argc, argv))) { - MEMO_V1_SET(memo, imemo_count_value(memo)); - rb_iter_break(); + MEMO_V1_SET(memo, imemo_count_value(memo)); + rb_iter_break(); } imemo_count_up(memo); return Qnil; } /* - * call-seq: - * find_index(object) -> integer or nil - * find_index {|element| ... } -> integer or nil - * find_index -> enumerator - * - * Returns the index of the first element that meets a specified criterion, - * or +nil+ if no such element is found. - * - * With argument +object+ given, - * returns the index of the first element that is <tt>==</tt> +object+: - * - * ['a', 'b', 'c', 'b'].find_index('b') # => 1 + * call-seq: + * enum.find_index(value) -> int or nil + * enum.find_index { |obj| block } -> int or nil + * enum.find_index -> an_enumerator * - * With a block given, calls the block with successive elements; - * returns the first element for which the block returns a truthy value: + * Compares each entry in <i>enum</i> with <em>value</em> or passes + * to <em>block</em>. Returns the index for the first for which the + * evaluated value is non-false. If no object matches, returns + * <code>nil</code> * - * ['a', 'b', 'c', 'b'].find_index {|element| element.start_with?('b') } # => 1 - * {foo: 0, bar: 1, baz: 2}.find_index {|key, value| value > 1 } # => 2 + * If neither block nor argument is given, an enumerator is returned instead. * - * With no argument and no block given, returns an Enumerator. + * (1..10).find_index { |i| i % 5 == 0 and i % 7 == 0 } #=> nil + * (1..100).find_index { |i| i % 5 == 0 and i % 7 == 0 } #=> 34 + * (1..100).find_index(50) #=> 49 * */ @@ -459,10 +364,10 @@ enum_find_index(int argc, VALUE *argv, VALUE obj) func = find_index_iter_i; } else { - rb_scan_args(argc, argv, "1", &condition_value); - if (rb_block_given_p()) { - rb_warn("given block not used"); - } + rb_scan_args(argc, argv, "1", &condition_value); + if (rb_block_given_p()) { + rb_warn("given block not used"); + } func = find_index_i; } @@ -477,7 +382,7 @@ find_all_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary)) ENUM_WANT_SVALUE(); if (RTEST(enum_yield(argc, i))) { - rb_ary_push(ary, i); + rb_ary_push(ary, i); } return Qnil; } @@ -507,23 +412,25 @@ enum_size_over_p(VALUE obj, long n) } /* - * call-seq: - * select {|element| ... } -> array - * select -> enumerator + * call-seq: + * enum.find_all { |obj| block } -> array + * enum.select { |obj| block } -> array + * enum.find_all -> an_enumerator + * enum.select -> an_enumerator * - * Returns an array containing elements selected by the block. + * Returns an array containing all elements of +enum+ + * for which the given +block+ returns a true value. * - * With a block given, calls the block with successive elements; - * returns an array of those elements for which the block returns a truthy value: + * If no block is given, an Enumerator is returned instead. * - * (0..9).select {|element| element % 3 == 0 } # => [0, 3, 6, 9] - * a = {foo: 0, bar: 1, baz: 2}.select {|key, value| key.start_with?('b') } - * a # => {:bar=>1, :baz=>2} * - * With no block given, returns an Enumerator. + * (1..10).find_all { |i| i % 3 == 0 } #=> [3, 6, 9] * - * Related: #reject. + * [1,2,3,4,5].select { |num| num.even? } #=> [2, 4] + * + * See also Enumerable#reject. */ + static VALUE enum_find_all(VALUE obj) { @@ -538,74 +445,31 @@ enum_find_all(VALUE obj) } static VALUE -filter_map_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary)) -{ - i = rb_yield_values2(argc, argv); - - if (RTEST(i)) { - rb_ary_push(ary, i); - } - - return Qnil; -} - -/* - * call-seq: - * filter_map {|element| ... } -> array - * filter_map -> enumerator - * - * Returns an array containing truthy elements returned by the block. - * - * With a block given, calls the block with successive elements; - * returns an array containing each truthy value returned by the block: - * - * (0..9).filter_map {|i| i * 2 if i.even? } # => [0, 4, 8, 12, 16] - * {foo: 0, bar: 1, baz: 2}.filter_map {|key, value| key if value.even? } # => [:foo, :baz] - * - * When no block given, returns an Enumerator. - * - */ -static VALUE -enum_filter_map(VALUE obj) -{ - VALUE ary; - - RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size); - - ary = rb_ary_new(); - rb_block_call(obj, id_each, 0, 0, filter_map_i, ary); - - return ary; -} - - -static VALUE reject_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary)) { ENUM_WANT_SVALUE(); if (!RTEST(enum_yield(argc, i))) { - rb_ary_push(ary, i); + rb_ary_push(ary, i); } return Qnil; } /* - * call-seq: - * reject {|element| ... } -> array - * reject -> enumerator + * call-seq: + * enum.reject { |obj| block } -> array + * enum.reject -> an_enumerator * - * Returns an array of objects rejected by the block. + * Returns an array for all elements of +enum+ for which the given + * +block+ returns <code>false</code>. * - * With a block given, calls the block with successive elements; - * returns an array of those elements for which the block returns +nil+ or +false+: + * If no block is given, an Enumerator is returned instead. * - * (0..9).reject {|i| i * 2 if i.even? } # => [1, 3, 5, 7, 9] - * {foo: 0, bar: 1, baz: 2}.reject {|key, value| key if value.odd? } # => {:foo=>0, :baz=>2} + * (1..10).reject { |i| i % 3 == 0 } #=> [1, 2, 4, 5, 7, 8, 10] * - * When no block given, returns an Enumerator. + * [1, 2, 3, 4, 5].reject { |num| num.even? } #=> [1, 3, 5] * - * Related: #select. + * See also Enumerable#find_all. */ static VALUE @@ -632,27 +496,29 @@ collect_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary)) static VALUE collect_all(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary)) { + rb_thread_check_ints(); rb_ary_push(ary, rb_enum_values_pack(argc, argv)); return Qnil; } /* - * call-seq: - * map {|element| ... } -> array - * map -> enumerator - * - * Returns an array of objects returned by the block. + * call-seq: + * enum.collect { |obj| block } -> array + * enum.map { |obj| block } -> array + * enum.collect -> an_enumerator + * enum.map -> an_enumerator * - * With a block given, calls the block with successive elements; - * returns an array of the objects returned by the block: + * Returns a new array with the results of running <em>block</em> once + * for every element in <i>enum</i>. * - * (0..4).map {|i| i*i } # => [0, 1, 4, 9, 16] - * {foo: 0, bar: 1, baz: 2}.map {|key, value| value*2} # => [0, 2, 4] + * If no block is given, an enumerator is returned instead. * - * With no block given, returns an Enumerator. + * (1..4).map { |i| i*i } #=> [1, 4, 9, 16] + * (1..4).collect { "cat" } #=> ["cat", "cat", "cat", "cat"] * */ + static VALUE enum_collect(VALUE obj) { @@ -677,33 +543,31 @@ flat_map_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary)) tmp = rb_check_array_type(i); if (NIL_P(tmp)) { - rb_ary_push(ary, i); + rb_ary_push(ary, i); } else { - rb_ary_concat(ary, tmp); + rb_ary_concat(ary, tmp); } return Qnil; } /* - * call-seq: - * flat_map {|element| ... } -> array - * flat_map -> enumerator - * - * Returns an array of flattened objects returned by the block. + * call-seq: + * enum.flat_map { |obj| block } -> array + * enum.collect_concat { |obj| block } -> array + * enum.flat_map -> an_enumerator + * enum.collect_concat -> an_enumerator * - * With a block given, calls the block with successive elements; - * returns a flattened array of objects returned by the block: + * Returns a new array with the concatenated results of running + * <em>block</em> once for every element in <i>enum</i>. * - * [0, 1, 2, 3].flat_map {|element| -element } # => [0, -1, -2, -3] - * [0, 1, 2, 3].flat_map {|element| [element, -element] } # => [0, 0, 1, -1, 2, -2, 3, -3] - * [[0, 1], [2, 3]].flat_map {|e| e + [100] } # => [0, 1, 100, 2, 3, 100] - * {foo: 0, bar: 1, baz: 2}.flat_map {|key, value| [key, value] } # => [:foo, 0, :bar, 1, :baz, 2] + * If no block is given, an enumerator is returned instead. * - * With no block given, returns an Enumerator. + * [1, 2, 3, 4].flat_map { |e| [e, -e] } #=> [1, -1, 2, -2, 3, -3, 4, -4] + * [[1, 2], [3, 4]].flat_map { |e| e + [100] } #=> [1, 2, 100, 3, 4, 100] * - * Alias: #collect_concat. */ + static VALUE enum_flat_map(VALUE obj) { @@ -719,75 +583,65 @@ enum_flat_map(VALUE obj) /* * call-seq: - * to_a(*args) -> array + * enum.to_a(*args) -> array + * enum.entries(*args) -> array * - * Returns an array containing the items in +self+: + * Returns an array containing the items in <i>enum</i>. * - * (0..4).to_a # => [0, 1, 2, 3, 4] + * (1..7).to_a #=> [1, 2, 3, 4, 5, 6, 7] + * { 'a'=>1, 'b'=>2, 'c'=>3 }.to_a #=> [["a", 1], ["b", 2], ["c", 3]] * + * require 'prime' + * Prime.entries 10 #=> [2, 3, 5, 7] */ static VALUE enum_to_a(int argc, VALUE *argv, VALUE obj) { VALUE ary = rb_ary_new(); - rb_block_call_kw(obj, id_each, argc, argv, collect_all, ary, RB_PASS_CALLED_KEYWORDS); + rb_block_call(obj, id_each, argc, argv, collect_all, ary); + OBJ_INFECT(ary, obj); return ary; } static VALUE -enum_hashify_into(VALUE obj, int argc, const VALUE *argv, rb_block_call_func *iter, VALUE hash) -{ - rb_block_call(obj, id_each, argc, argv, iter, hash); - return hash; -} - -static VALUE -enum_hashify(VALUE obj, int argc, const VALUE *argv, rb_block_call_func *iter) -{ - return enum_hashify_into(obj, argc, argv, iter, rb_hash_new()); -} - -static VALUE enum_to_h_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, hash)) { + VALUE key_value_pair; ENUM_WANT_SVALUE(); - return rb_hash_set_pair(hash, i); -} - -static VALUE -enum_to_h_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, hash)) -{ - return rb_hash_set_pair(hash, rb_yield_values2(argc, argv)); + rb_thread_check_ints(); + key_value_pair = rb_check_array_type(i); + if (NIL_P(key_value_pair)) { + rb_raise(rb_eTypeError, "wrong element type %s (expected array)", + rb_builtin_class_name(i)); + } + if (RARRAY_LEN(key_value_pair) != 2) { + rb_raise(rb_eArgError, "element has wrong array length (expected 2, was %ld)", + RARRAY_LEN(key_value_pair)); + } + rb_hash_aset(hash, RARRAY_AREF(key_value_pair, 0), RARRAY_AREF(key_value_pair, 1)); + return Qnil; } /* * call-seq: - * to_h(*args) -> hash - * to_h(*args) {|element| ... } -> hash - * - * When +self+ consists of 2-element arrays, - * returns a hash each of whose entries is the key-value pair - * formed from one of those arrays: - * - * [[:foo, 0], [:bar, 1], [:baz, 2]].to_h # => {:foo=>0, :bar=>1, :baz=>2} + * enum.to_h(*args) -> hash * - * When a block is given, the block is called with each element of +self+; - * the block should return a 2-element array which becomes a key-value pair - * in the returned hash: + * Returns the result of interpreting <i>enum</i> as a list of + * <tt>[key, value]</tt> pairs. * - * (0..3).to_h {|i| [i, i ** 2]} # => {0=>0, 1=>1, 2=>4, 3=>9} - * - * Raises an exception if an element of +self+ is not a 2-element array, - * and a block is not passed. + * %i[hello world].each_with_index.to_h + * # => {:hello => 0, :world => 1} */ static VALUE enum_to_h(int argc, VALUE *argv, VALUE obj) { - rb_block_call_func *iter = rb_block_given_p() ? enum_to_h_ii : enum_to_h_i; - return enum_hashify(obj, argc, argv, iter); + VALUE hash = rb_hash_new(); + rb_block_call(obj, id_each, argc, argv, enum_to_h_i, hash); + OBJ_INFECT(hash, obj); + return hash; } static VALUE @@ -797,11 +651,11 @@ inject_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, p)) ENUM_WANT_SVALUE(); - if (UNDEF_P(memo->v1)) { - MEMO_V1_SET(memo, i); + if (memo->v1 == Qundef) { + MEMO_V1_SET(memo, i); } else { - MEMO_V1_SET(memo, rb_yield_values(2, memo->v1, i)); + MEMO_V1_SET(memo, rb_yield_values(2, memo->v1, i)); } return Qnil; } @@ -814,18 +668,18 @@ inject_op_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, p)) ENUM_WANT_SVALUE(); - if (UNDEF_P(memo->v1)) { - MEMO_V1_SET(memo, i); + if (memo->v1 == Qundef) { + MEMO_V1_SET(memo, i); } else if (SYMBOL_P(name = memo->u3.value)) { - const ID mid = SYM2ID(name); - MEMO_V1_SET(memo, rb_funcallv_public(memo->v1, mid, 1, &i)); + const ID mid = SYM2ID(name); + MEMO_V1_SET(memo, rb_funcallv(memo->v1, mid, 1, &i)); } else { - VALUE args[2]; - args[0] = name; - args[1] = i; - MEMO_V1_SET(memo, rb_f_send(numberof(args), args, memo->v1)); + VALUE args[2]; + args[0] = name; + args[1] = i; + MEMO_V1_SET(memo, rb_f_send(numberof(args), args, memo->v1)); } return Qnil; } @@ -838,9 +692,9 @@ ary_inject_op(VALUE ary, VALUE init, VALUE op) long i, n; if (RARRAY_LEN(ary) == 0) - return UNDEF_P(init) ? Qnil : init; + return init == Qundef ? Qnil : init; - if (UNDEF_P(init)) { + if (init == Qundef) { v = RARRAY_AREF(ary, 0); i = 1; if (RARRAY_LEN(ary) == 1) @@ -853,20 +707,20 @@ ary_inject_op(VALUE ary, VALUE init, VALUE op) id = SYM2ID(op); if (id == idPLUS) { - if (RB_INTEGER_TYPE_P(v) && - rb_method_basic_definition_p(rb_cInteger, idPLUS) && - rb_obj_respond_to(v, idPLUS, FALSE)) { + if (RB_INTEGER_TYPE_P(v) && + rb_method_basic_definition_p(rb_cInteger, idPLUS) && + rb_obj_respond_to(v, idPLUS, FALSE)) { n = 0; for (; i < RARRAY_LEN(ary); i++) { e = RARRAY_AREF(ary, i); if (FIXNUM_P(e)) { n += FIX2LONG(e); /* should not overflow long type */ if (!FIXABLE(n)) { - v = rb_big_plus(LONG2NUM(n), v); + v = rb_big_plus(ULONG2NUM(n), v); n = 0; } } - else if (RB_BIGNUM_TYPE_P(e)) + else if (RB_TYPE_P(e, T_BIGNUM)) v = rb_big_plus(e, v); else goto not_integer; @@ -881,160 +735,55 @@ ary_inject_op(VALUE ary, VALUE init, VALUE op) } } for (; i < RARRAY_LEN(ary); i++) { - VALUE arg = RARRAY_AREF(ary, i); - v = rb_funcallv_public(v, id, 1, &arg); + v = rb_funcallv_public(v, id, 1, &RARRAY_CONST_PTR(ary)[i]); } return v; } /* * call-seq: - * inject(symbol) -> object - * inject(initial_value, symbol) -> object - * inject {|memo, value| ... } -> object - * inject(initial_value) {|memo, value| ... } -> object - * - * Returns the result of applying a reducer to an initial value and - * the first element of the Enumerable. It then takes the result and applies the - * function to it and the second element of the collection, and so on. The - * return value is the result returned by the final call to the function. - * - * You can think of - * - * [ a, b, c, d ].inject(i) { |r, v| fn(r, v) } - * - * as being - * - * fn(fn(fn(fn(i, a), b), c), d) - * - * In a way the +inject+ function _injects_ the function - * between the elements of the enumerable. - * - * +inject+ is aliased as +reduce+. You use it when you want to - * _reduce_ a collection to a single value. - * - * <b>The Calling Sequences</b> - * - * Let's start with the most verbose: - * - * enum.inject(initial_value) do |result, next_value| - * # do something with +result+ and +next_value+ - * # the value returned by the block becomes the - * # value passed in to the next iteration - * # as +result+ - * end - * - * For example: - * - * product = [ 2, 3, 4 ].inject(1) do |result, next_value| - * result * next_value - * end - * product #=> 24 - * - * When this runs, the block is first called with +1+ (the initial value) and - * +2+ (the first element of the array). The block returns <tt>1*2</tt>, so on - * the next iteration the block is called with +2+ (the previous result) and - * +3+. The block returns +6+, and is called one last time with +6+ and +4+. - * The result of the block, +24+ becomes the value returned by +inject+. This - * code returns the product of the elements in the enumerable. - * - * <b>First Shortcut: Default Initial value</b> - * - * In the case of the previous example, the initial value, +1+, wasn't really - * necessary: the calculation of the product of a list of numbers is self-contained. - * - * In these circumstances, you can omit the +initial_value+ parameter. +inject+ - * will then initially call the block with the first element of the collection - * as the +result+ parameter and the second element as the +next_value+. - * - * [ 2, 3, 4 ].inject do |result, next_value| - * result * next_value - * end - * - * This shortcut is convenient, but can only be used when the block produces a result - * which can be passed back to it as a first parameter. - * - * Here's an example where that's not the case: it returns a hash where the keys are words - * and the values are the number of occurrences of that word in the enumerable. - * - * freqs = File.read("README.md") - * .scan(/\w{2,}/) - * .reduce(Hash.new(0)) do |counts, word| - * counts[word] += 1 - * counts - * end - * freqs #=> {"Actions"=>4, - * "Status"=>5, - * "MinGW"=>3, - * "https"=>27, - * "github"=>10, - * "com"=>15, ... - * - * Note that the last line of the block is just the word +counts+. This ensures the - * return value of the block is the result that's being calculated. - * - * <b>Second Shortcut: a Reducer function</b> - * - * A <i>reducer function</i> is a function that takes a partial result and the next value, - * returning the next partial result. The block that is given to +inject+ is a reducer. - * - * You can also write a reducer as a function and pass the name of that function - * (as a symbol) to +inject+. However, for this to work, the function - * - * 1. Must be defined on the type of the result value - * 2. Must accept a single parameter, the next value in the collection, and - * 3. Must return an updated result which will also implement the function. - * - * Here's an example that adds elements to a string. The two calls invoke the functions - * String#concat and String#+ on the result so far, passing it the next value. - * - * s = [ "cat", " ", "dog" ].inject("", :concat) - * s #=> "cat dog" - * s = [ "cat", " ", "dog" ].inject("The result is:", :+) - * s #=> "The result is: cat dog" - * - * Here's a more complex example when the result object maintains - * state of a different type to the enumerable elements. - * - * class Turtle - * - * def initialize - * @x = @y = 0 - * end - * - * def move(dir) - * case dir - * when "n" then @y += 1 - * when "s" then @y -= 1 - * when "e" then @x += 1 - * when "w" then @x -= 1 - * end - * self - * end - * end - * - * position = "nnneesw".chars.reduce(Turtle.new, :move) - * position #=>> #<Turtle:0x00000001052f4698 @y=2, @x=1> - * - * <b>Third Shortcut: Reducer With no Initial Value</b> - * - * If your reducer returns a value that it can accept as a parameter, then you - * don't have to pass in an initial value. Here <tt>:*</tt> is the name of the - * _times_ function: - * - * product = [ 2, 3, 4 ].inject(:*) - * product # => 24 - * - * String concatenation again: - * - * s = [ "cat", " ", "dog" ].inject(:+) - * s #=> "cat dog" - * - * And an example that converts a hash to an array of two-element subarrays. - * - * nested = {foo: 0, bar: 1}.inject([], :push) - * nested # => [[:foo, 0], [:bar, 1]] - * + * enum.inject(initial, sym) -> obj + * enum.inject(sym) -> obj + * enum.inject(initial) { |memo, obj| block } -> obj + * enum.inject { |memo, obj| block } -> obj + * enum.reduce(initial, sym) -> obj + * enum.reduce(sym) -> obj + * enum.reduce(initial) { |memo, obj| block } -> obj + * enum.reduce { |memo, obj| block } -> obj + * + * Combines all elements of <i>enum</i> by applying a binary + * operation, specified by a block or a symbol that names a + * method or operator. + * + * The <i>inject</i> and <i>reduce</i> methods are aliases. There + * is no performance benefit to either. + * + * If you specify a block, then for each element in <i>enum</i> + * the block is passed an accumulator value (<i>memo</i>) and the element. + * If you specify a symbol instead, then each element in the collection + * will be passed to the named method of <i>memo</i>. + * In either case, the result becomes the new value for <i>memo</i>. + * At the end of the iteration, the final value of <i>memo</i> is the + * return value for the method. + * + * If you do not explicitly specify an <i>initial</i> value for <i>memo</i>, + * then the first element of collection is used as the initial value + * of <i>memo</i>. + * + * + * # Sum some numbers + * (5..10).reduce(:+) #=> 45 + * # Same using a block and inject + * (5..10).inject { |sum, n| sum + n } #=> 45 + * # Multiply some numbers + * (5..10).reduce(1, :*) #=> 151200 + * # Same using a block + * (5..10).inject(1) { |product, n| product * n } #=> 151200 + * # find the longest word + * longest = %w{ cat sheep bear }.inject do |memo, word| + * memo.length > word.length ? memo : word + * end + * longest #=> "sheep" * */ static VALUE @@ -1044,36 +793,28 @@ enum_inject(int argc, VALUE *argv, VALUE obj) VALUE init, op; rb_block_call_func *iter = inject_i; ID id; - int num_args; - if (rb_block_given_p()) { - num_args = rb_scan_args(argc, argv, "02", &init, &op); - } - else { - num_args = rb_scan_args(argc, argv, "11", &init, &op); - } - - switch (num_args) { + switch (rb_scan_args(argc, argv, "02", &init, &op)) { case 0: - init = Qundef; - break; + init = Qundef; + break; case 1: - if (rb_block_given_p()) { - break; - } - id = rb_check_id(&init); - op = id ? ID2SYM(id) : init; - init = Qundef; - iter = inject_op_i; - break; + if (rb_block_given_p()) { + break; + } + id = rb_check_id(&init); + op = id ? ID2SYM(id) : init; + init = Qundef; + iter = inject_op_i; + break; case 2: - if (rb_block_given_p()) { - rb_warning("given block not used"); - } - id = rb_check_id(&op); - if (id) op = ID2SYM(id); - iter = inject_op_i; - break; + if (rb_block_given_p()) { + rb_warning("given block not used"); + } + id = rb_check_id(&op); + if (id) op = ID2SYM(id); + iter = inject_op_i; + break; } if (iter == inject_op_i && @@ -1085,7 +826,7 @@ enum_inject(int argc, VALUE *argv, VALUE obj) memo = MEMO_NEW(init, Qnil, op); rb_block_call(obj, id_each, 0, 0, iter, (VALUE)memo); - if (UNDEF_P(memo->v1)) return Qnil; + if (memo->v1 == Qundef) return Qnil; return memo->v1; } @@ -1097,10 +838,10 @@ partition_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, arys)) ENUM_WANT_SVALUE(); if (RTEST(enum_yield(argc, i))) { - ary = memo->v1; + ary = memo->v1; } else { - ary = memo->v2; + ary = memo->v2; } rb_ary_push(ary, i); return Qnil; @@ -1108,29 +849,16 @@ partition_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, arys)) /* * call-seq: - * partition {|element| ... } -> [true_array, false_array] - * partition -> enumerator + * enum.partition { |obj| block } -> [ true_array, false_array ] + * enum.partition -> an_enumerator * - * With a block given, returns an array of two arrays: + * Returns two arrays, the first containing the elements of + * <i>enum</i> for which the block evaluates to true, the second + * containing the rest. * - * - The first having those elements for which the block returns a truthy value. - * - The other having all other elements. + * If no block is given, an enumerator is returned instead. * - * Examples: - * - * p = (1..4).partition {|i| i.even? } - * p # => [[2, 4], [1, 3]] - * p = ('a'..'d').partition {|c| c < 'c' } - * p # => [["a", "b"], ["c", "d"]] - * h = {foo: 0, bar: 1, baz: 2, bat: 3} - * p = h.partition {|key, value| key.start_with?('b') } - * p # => [[[:bar, 1], [:baz, 2], [:bat, 3]], [[:foo, 0]]] - * p = h.partition {|key, value| value < 2 } - * p # => [[[:foo, 0], [:bar, 1]], [[:baz, 2], [:bat, 3]]] - * - * With no block given, returns an Enumerator. - * - * Related: Enumerable#group_by. + * (1..6).partition { |v| v.even? } #=> [[2, 4, 6], [1, 3, 5]] * */ @@ -1158,144 +886,45 @@ group_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, hash)) group = enum_yield(argc, i); values = rb_hash_aref(hash, group); if (!RB_TYPE_P(values, T_ARRAY)) { - values = rb_ary_new3(1, i); - rb_hash_aset(hash, group, values); + values = rb_ary_new3(1, i); + rb_hash_aset(hash, group, values); } else { - rb_ary_push(values, i); + rb_ary_push(values, i); } return Qnil; } /* * call-seq: - * group_by {|element| ... } -> hash - * group_by -> enumerator - * - * With a block given returns a hash: + * enum.group_by { |obj| block } -> a_hash + * enum.group_by -> an_enumerator * - * - Each key is a return value from the block. - * - Each value is an array of those elements for which the block returned that key. + * Groups the collection by result of the block. Returns a hash where the + * keys are the evaluated result from the block and the values are + * arrays of elements in the collection that correspond to the key. * - * Examples: + * If no block is given an enumerator is returned. * - * g = (1..6).group_by {|i| i%3 } - * g # => {1=>[1, 4], 2=>[2, 5], 0=>[3, 6]} - * h = {foo: 0, bar: 1, baz: 0, bat: 1} - * g = h.group_by {|key, value| value } - * g # => {0=>[[:foo, 0], [:baz, 0]], 1=>[[:bar, 1], [:bat, 1]]} - * - * With no block given, returns an Enumerator. + * (1..6).group_by { |i| i%3 } #=> {0=>[3, 6], 1=>[1, 4], 2=>[2, 5]} * */ static VALUE enum_group_by(VALUE obj) { - RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size); + VALUE hash; - return enum_hashify(obj, 0, 0, group_by_i); -} + RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size); -static int -tally_up(st_data_t *group, st_data_t *value, st_data_t arg, int existing) -{ - VALUE tally = (VALUE)*value; - VALUE hash = (VALUE)arg; - if (!existing) { - tally = INT2FIX(1); - } - else if (FIXNUM_P(tally) && tally < INT2FIX(FIXNUM_MAX)) { - tally += INT2FIX(1) & ~FIXNUM_FLAG; - } - else { - Check_Type(tally, T_BIGNUM); - tally = rb_big_plus(tally, INT2FIX(1)); - RB_OBJ_WRITTEN(hash, Qundef, tally); - } - *value = (st_data_t)tally; - if (!SPECIAL_CONST_P(*group)) RB_OBJ_WRITTEN(hash, Qundef, *group); - return ST_CONTINUE; -} + hash = rb_hash_new(); + rb_block_call(obj, id_each, 0, 0, group_by_i, hash); + OBJ_INFECT(hash, obj); -static VALUE -rb_enum_tally_up(VALUE hash, VALUE group) -{ - rb_hash_stlike_update(hash, group, tally_up, (st_data_t)hash); return hash; } static VALUE -tally_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, hash)) -{ - ENUM_WANT_SVALUE(); - rb_enum_tally_up(hash, i); - return Qnil; -} - -/* - * call-seq: - * tally(hash = {}) -> hash - * - * When argument +hash+ is not given, - * returns a new hash whose keys are the distinct elements in +self+; - * each integer value is the count of occurrences of each element: - * - * %w[a b c b c a c b].tally # => {"a"=>2, "b"=>3, "c"=>3} - * - * When argument +hash+ is given, - * returns +hash+, possibly augmented; for each element +ele+ in +self+: - * - * - Adds it as a key with a zero value if that key does not already exist: - * - * hash[ele] = 0 unless hash.include?(ele) - * - * - Increments the value of key +ele+: - * - * hash[ele] += 1 - * - * This is useful for accumulating tallies across multiple enumerables: - * - * h = {} # => {} - * %w[a c d b c a].tally(h) # => {"a"=>2, "c"=>2, "d"=>1, "b"=>1} - * %w[b a z].tally(h) # => {"a"=>3, "c"=>2, "d"=>1, "b"=>2, "z"=>1} - * %w[b a m].tally(h) # => {"a"=>4, "c"=>2, "d"=>1, "b"=>3, "z"=>1, "m"=>1} - * - * The key to be added or found for an element depends on the class of +self+; - * see {Enumerable in Ruby Classes}[rdoc-ref:Enumerable@Enumerable+in+Ruby+Classes]. - * - * Examples: - * - * - Array (and certain array-like classes): - * the key is the element (as above). - * - Hash (and certain hash-like classes): - * the key is the 2-element array formed from the key-value pair: - * - * h = {} # => {} - * {foo: 'a', bar: 'b'}.tally(h) # => {[:foo, "a"]=>1, [:bar, "b"]=>1} - * {foo: 'c', bar: 'd'}.tally(h) # => {[:foo, "a"]=>1, [:bar, "b"]=>1, [:foo, "c"]=>1, [:bar, "d"]=>1} - * {foo: 'a', bar: 'b'}.tally(h) # => {[:foo, "a"]=>2, [:bar, "b"]=>2, [:foo, "c"]=>1, [:bar, "d"]=>1} - * {foo: 'c', bar: 'd'}.tally(h) # => {[:foo, "a"]=>2, [:bar, "b"]=>2, [:foo, "c"]=>2, [:bar, "d"]=>2} - * - */ - -static VALUE -enum_tally(int argc, VALUE *argv, VALUE obj) -{ - VALUE hash; - if (rb_check_arity(argc, 0, 1)) { - hash = rb_to_hash_type(argv[0]); - rb_check_frozen(hash); - } - else { - hash = rb_hash_new(); - } - - return enum_hashify_into(obj, 0, 0, tally_i, hash); -} - -NORETURN(static VALUE first_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, params))); -static VALUE first_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, params)) { struct MEMO *memo = MEMO_CAST(params); @@ -1304,33 +933,25 @@ first_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, params)) MEMO_V1_SET(memo, i); rb_iter_break(); - UNREACHABLE_RETURN(Qnil); + UNREACHABLE; } static VALUE enum_take(VALUE obj, VALUE n); /* * call-seq: - * first -> element or nil - * first(n) -> array - * - * Returns the first element or elements. + * enum.first -> obj or nil + * enum.first(n) -> an_array * - * With no argument, returns the first element, or +nil+ if there is none: + * Returns the first element, or the first +n+ elements, of the enumerable. + * If the enumerable is empty, the first form returns <code>nil</code>, and the + * second form returns an empty array. * - * (1..4).first # => 1 - * %w[a b c].first # => "a" - * {foo: 1, bar: 1, baz: 2}.first # => [:foo, 1] - * [].first # => nil - * - * With integer argument +n+, returns an array - * containing the first +n+ elements that exist: - * - * (1..4).first(2) # => [1, 2] - * %w[a b c d].first(3) # => ["a", "b", "c"] - * %w[a b c d].first(50) # => ["a", "b", "c", "d"] - * {foo: 1, bar: 1, baz: 2}.first(2) # => [[:foo, 1], [:bar, 1]] - * [].first(2) # => [] + * %w[foo bar baz].first #=> "foo" + * %w[foo bar baz].first(2) #=> ["foo", "bar"] + * %w[foo bar baz].first(10) #=> ["foo", "bar", "baz"] + * [].first #=> nil + * [].first(10) #=> [] * */ @@ -1340,44 +961,37 @@ enum_first(int argc, VALUE *argv, VALUE obj) struct MEMO *memo; rb_check_arity(argc, 0, 1); if (argc > 0) { - return enum_take(obj, argv[0]); + return enum_take(obj, argv[0]); } else { - memo = MEMO_NEW(Qnil, 0, 0); - rb_block_call(obj, id_each, 0, 0, first_i, (VALUE)memo); - return memo->v1; + memo = MEMO_NEW(Qnil, 0, 0); + rb_block_call(obj, id_each, 0, 0, first_i, (VALUE)memo); + return memo->v1; } } + /* * call-seq: - * sort -> array - * sort {|a, b| ... } -> array - * - * Returns an array containing the sorted elements of +self+. - * The ordering of equal elements is indeterminate and may be unstable. - * - * With no block given, the sort compares - * using the elements' own method <tt>#<=></tt>: + * enum.sort -> array + * enum.sort { |a, b| block } -> array * - * %w[b c a d].sort # => ["a", "b", "c", "d"] - * {foo: 0, bar: 1, baz: 2}.sort # => [[:bar, 1], [:baz, 2], [:foo, 0]] + * Returns an array containing the items in <i>enum</i> sorted. * - * With a block given, comparisons in the block determine the ordering. - * The block is called with two elements +a+ and +b+, and must return: + * Comparisons for the sort will be done using the items' own + * <code><=></code> operator or using an optional code block. * - * - A negative integer if <tt>a < b</tt>. - * - Zero if <tt>a == b</tt>. - * - A positive integer if <tt>a > b</tt>. + * The block must implement a comparison between +a+ and +b+ and return + * an integer less than 0 when +b+ follows +a+, +0+ when +a+ and +b+ + * are equivalent, or an integer greater than 0 when +a+ follows +b+. * - * Examples: + * The result is not guaranteed to be stable. When the comparison of two + * elements returns +0+, the order of the elements is unpredictable. * - * a = %w[b c a d] - * a.sort {|a, b| b <=> a } # => ["d", "c", "b", "a"] - * h = {foo: 0, bar: 1, baz: 2} - * h.sort {|a, b| b <=> a } # => [[:foo, 0], [:baz, 2], [:bar, 1]] + * %w(rhea kea flea).sort #=> ["flea", "kea", "rhea"] + * (1..10).sort { |a, b| b <=> a } #=> [10, 9, 8, 7, 6, 5, 4, 3, 2, 1] * - * See also #sort_by. It implements a Schwartzian transform + * See also Enumerable#sort_by. It implements a Schwartzian transform * which is useful when key computation or comparison is expensive. */ @@ -1388,12 +1002,10 @@ enum_sort(VALUE obj) } #define SORT_BY_BUFSIZE 16 -#define SORT_BY_UNIFORMED(num, flo, fix) (((num&1)<<2)|((flo&1)<<1)|fix) struct sort_by_data { const VALUE ary; const VALUE buf; - uint8_t n; - uint8_t primitive_uniformed; + long n; }; static VALUE @@ -1408,23 +1020,18 @@ sort_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, _data)) v = enum_yield(argc, i); if (RBASIC(ary)->klass) { - rb_raise(rb_eRuntimeError, "sort_by reentered"); + rb_raise(rb_eRuntimeError, "sort_by reentered"); } if (RARRAY_LEN(data->buf) != SORT_BY_BUFSIZE*2) { - rb_raise(rb_eRuntimeError, "sort_by reentered"); + rb_raise(rb_eRuntimeError, "sort_by reentered"); } - if (data->primitive_uniformed) { - data->primitive_uniformed &= SORT_BY_UNIFORMED((FIXNUM_P(v)) || (RB_FLOAT_TYPE_P(v)), - RB_FLOAT_TYPE_P(v), - FIXNUM_P(v)); - } RARRAY_ASET(data->buf, data->n*2, v); RARRAY_ASET(data->buf, data->n*2+1, i); data->n++; if (data->n == SORT_BY_BUFSIZE) { - rb_ary_concat(ary, data->buf); - data->n = 0; + rb_ary_concat(ary, data->buf); + data->n = 0; } return Qnil; } @@ -1432,217 +1039,41 @@ sort_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, _data)) static int sort_by_cmp(const void *ap, const void *bp, void *data) { + struct cmp_opt_data cmp_opt = { 0, 0 }; VALUE a; VALUE b; VALUE ary = (VALUE)data; if (RBASIC(ary)->klass) { - rb_raise(rb_eRuntimeError, "sort_by reentered"); + rb_raise(rb_eRuntimeError, "sort_by reentered"); } a = *(VALUE *)ap; b = *(VALUE *)bp; - return OPTIMIZED_CMP(a, b); -} - - -/* - This is parts of uniform sort -*/ - -#define uless rb_uniform_is_less -#define UNIFORM_SWAP(a,b)\ - do{struct rb_uniform_sort_data tmp = a; a = b; b = tmp;} while(0) - -struct rb_uniform_sort_data { - VALUE v; - VALUE i; -}; - -static inline bool -rb_uniform_is_less(VALUE a, VALUE b) -{ - - if (FIXNUM_P(a) && FIXNUM_P(b)) { - return (SIGNED_VALUE)a < (SIGNED_VALUE)b; - } - else if (FIXNUM_P(a)) { - RUBY_ASSERT(RB_FLOAT_TYPE_P(b)); - return rb_float_cmp(b, a) > 0; - } - else { - RUBY_ASSERT(RB_FLOAT_TYPE_P(a)); - return rb_float_cmp(a, b) < 0; - } -} - -static inline bool -rb_uniform_is_larger(VALUE a, VALUE b) -{ - - if (FIXNUM_P(a) && FIXNUM_P(b)) { - return (SIGNED_VALUE)a > (SIGNED_VALUE)b; - } - else if (FIXNUM_P(a)) { - RUBY_ASSERT(RB_FLOAT_TYPE_P(b)); - return rb_float_cmp(b, a) < 0; - } - else { - RUBY_ASSERT(RB_FLOAT_TYPE_P(a)); - return rb_float_cmp(a, b) > 0; - } -} - -#define med3_val(a,b,c) (uless(a,b)?(uless(b,c)?b:uless(c,a)?a:c):(uless(c,b)?b:uless(a,c)?a:c)) - -static void -rb_uniform_insertionsort_2(struct rb_uniform_sort_data* ptr_begin, - struct rb_uniform_sort_data* ptr_end) -{ - if ((ptr_end - ptr_begin) < 2) return; - struct rb_uniform_sort_data tmp, *j, *k, - *index = ptr_begin+1; - for (; index < ptr_end; index++) { - tmp = *index; - j = k = index; - if (uless(tmp.v, ptr_begin->v)) { - while (ptr_begin < j) { - *j = *(--k); - j = k; - } - } - else { - while (uless(tmp.v, (--k)->v)) { - *j = *k; - j = k; - } - } - *j = tmp; - } -} - -static inline void -rb_uniform_heap_down_2(struct rb_uniform_sort_data* ptr_begin, - size_t offset, size_t len) -{ - size_t c; - struct rb_uniform_sort_data tmp = ptr_begin[offset]; - while ((c = (offset<<1)+1) <= len) { - if (c < len && uless(ptr_begin[c].v, ptr_begin[c+1].v)) { - c++; - } - if (!uless(tmp.v, ptr_begin[c].v)) break; - ptr_begin[offset] = ptr_begin[c]; - offset = c; - } - ptr_begin[offset] = tmp; -} - -static void -rb_uniform_heapsort_2(struct rb_uniform_sort_data* ptr_begin, - struct rb_uniform_sort_data* ptr_end) -{ - size_t n = ptr_end - ptr_begin; - if (n < 2) return; - - for (size_t offset = n>>1; offset > 0;) { - rb_uniform_heap_down_2(ptr_begin, --offset, n-1); - } - for (size_t offset = n-1; offset > 0;) { - UNIFORM_SWAP(*ptr_begin, ptr_begin[offset]); - rb_uniform_heap_down_2(ptr_begin, 0, --offset); - } -} - - -static void -rb_uniform_quicksort_intro_2(struct rb_uniform_sort_data* ptr_begin, - struct rb_uniform_sort_data* ptr_end, size_t d) -{ - - if (ptr_end - ptr_begin <= 16) { - rb_uniform_insertionsort_2(ptr_begin, ptr_end); - return; - } - if (d == 0) { - rb_uniform_heapsort_2(ptr_begin, ptr_end); - return; - } - - VALUE x = med3_val(ptr_begin->v, - ptr_begin[(ptr_end - ptr_begin)>>1].v, - ptr_end[-1].v); - struct rb_uniform_sort_data *i = ptr_begin; - struct rb_uniform_sort_data *j = ptr_end-1; - - do { - while (uless(i->v, x)) i++; - while (uless(x, j->v)) j--; - if (i <= j) { - UNIFORM_SWAP(*i, *j); - i++; - j--; - } - } while (i <= j); - j++; - if (ptr_end - j > 1) rb_uniform_quicksort_intro_2(j, ptr_end, d-1); - if (i - ptr_begin > 1) rb_uniform_quicksort_intro_2(ptr_begin, i, d-1); -} - -/** - * Direct primitive data compare sort. Implement with intro sort. - * @param[in] ptr_begin The begin address of target rb_ary's raw pointer. - * @param[in] ptr_end The end address of target rb_ary's raw pointer. -**/ -static void -rb_uniform_intro_sort_2(struct rb_uniform_sort_data* ptr_begin, - struct rb_uniform_sort_data* ptr_end) -{ - size_t n = ptr_end - ptr_begin; - size_t d = CHAR_BIT * sizeof(n) - nlz_intptr(n) - 1; - bool sorted_flag = true; - - for (struct rb_uniform_sort_data* ptr = ptr_begin+1; ptr < ptr_end; ptr++) { - if (rb_uniform_is_larger((ptr-1)->v, (ptr)->v)) { - sorted_flag = false; - break; - } - } - - if (sorted_flag) { - return; - } - rb_uniform_quicksort_intro_2(ptr_begin, ptr_end, d<<1); + return OPTIMIZED_CMP(a, b, cmp_opt); } -#undef uless - - /* * call-seq: - * sort_by {|element| ... } -> array - * sort_by -> enumerator + * enum.sort_by { |obj| block } -> array + * enum.sort_by -> an_enumerator * - * With a block given, returns an array of elements of +self+, - * sorted according to the value returned by the block for each element. - * The ordering of equal elements is indeterminate and may be unstable. + * Sorts <i>enum</i> using a set of keys generated by mapping the + * values in <i>enum</i> through the given block. * - * Examples: + * The result is not guaranteed to be stable. When two keys are equal, + * the order of the corresponding elements is unpredictable. * - * a = %w[xx xxx x xxxx] - * a.sort_by {|s| s.size } # => ["x", "xx", "xxx", "xxxx"] - * a.sort_by {|s| -s.size } # => ["xxxx", "xxx", "xx", "x"] - * h = {foo: 2, bar: 1, baz: 0} - * h.sort_by{|key, value| value } # => [[:baz, 0], [:bar, 1], [:foo, 2]] - * h.sort_by{|key, value| key } # => [[:bar, 1], [:baz, 0], [:foo, 2]] + * If no block is given, an enumerator is returned instead. * - * With no block given, returns an Enumerator. + * %w{apple pear fig}.sort_by { |word| word.length } + * #=> ["fig", "pear", "apple"] * - * The current implementation of #sort_by generates an array of - * tuples containing the original collection element and the mapped - * value. This makes #sort_by fairly expensive when the keysets are - * simple. + * The current implementation of <code>sort_by</code> generates an + * array of tuples containing the original collection element and the + * mapped value. This makes <code>sort_by</code> fairly expensive when + * the keysets are simple. * * require 'benchmark' * @@ -1661,15 +1092,15 @@ rb_uniform_intro_sort_2(struct rb_uniform_sort_data* ptr_begin, * * However, consider the case where comparing the keys is a non-trivial * operation. The following code sorts some files on modification time - * using the basic #sort method. + * using the basic <code>sort</code> method. * * files = Dir["*"] * sorted = files.sort { |a, b| File.new(a).mtime <=> File.new(b).mtime } * sorted #=> ["mon", "tues", "wed", "thurs"] * - * This sort is inefficient: it generates two new File + * This sort is inefficient: it generates two new <code>File</code> * objects during every comparison. A slightly better technique is to - * use the Kernel#test method to generate the modification + * use the <code>Kernel#test</code> method to generate the modification * times directly. * * files = Dir["*"] @@ -1678,27 +1109,23 @@ rb_uniform_intro_sort_2(struct rb_uniform_sort_data* ptr_begin, * } * sorted #=> ["mon", "tues", "wed", "thurs"] * - * This still generates many unnecessary Time objects. A more - * efficient technique is to cache the sort keys (modification times - * in this case) before the sort. Perl users often call this approach - * a Schwartzian transform, after Randal Schwartz. We construct a - * temporary array, where each element is an array containing our - * sort key along with the filename. We sort this array, and then - * extract the filename from the result. + * This still generates many unnecessary <code>Time</code> objects. A + * more efficient technique is to cache the sort keys (modification + * times in this case) before the sort. Perl users often call this + * approach a Schwartzian transform, after Randal Schwartz. We + * construct a temporary array, where each element is an array + * containing our sort key along with the filename. We sort this array, + * and then extract the filename from the result. * * sorted = Dir["*"].collect { |f| * [test(?M, f), f] * }.sort.collect { |f| f[1] } * sorted #=> ["mon", "tues", "wed", "thurs"] * - * This is exactly what #sort_by does internally. + * This is exactly what <code>sort_by</code> does internally. * * sorted = Dir["*"].sort_by { |f| test(?M, f) } * sorted #=> ["mon", "tues", "wed", "thurs"] - * - * To produce the reverse of a specific order, the following can be used: - * - * ary.sort_by { ... }.reverse! */ static VALUE @@ -1712,58 +1139,47 @@ enum_sort_by(VALUE obj) RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size); if (RB_TYPE_P(obj, T_ARRAY) && RARRAY_LEN(obj) <= LONG_MAX/2) { - ary = rb_ary_new2(RARRAY_LEN(obj)*2); + ary = rb_ary_new2(RARRAY_LEN(obj)*2); } else { - ary = rb_ary_new(); + ary = rb_ary_new(); } RBASIC_CLEAR_CLASS(ary); - buf = rb_ary_hidden_new(SORT_BY_BUFSIZE*2); + buf = rb_ary_tmp_new(SORT_BY_BUFSIZE*2); rb_ary_store(buf, SORT_BY_BUFSIZE*2-1, Qnil); memo = MEMO_NEW(0, 0, 0); + OBJ_INFECT(memo, obj); data = (struct sort_by_data *)&memo->v1; RB_OBJ_WRITE(memo, &data->ary, ary); RB_OBJ_WRITE(memo, &data->buf, buf); data->n = 0; - data->primitive_uniformed = SORT_BY_UNIFORMED((CMP_OPTIMIZABLE(FLOAT) && CMP_OPTIMIZABLE(INTEGER)), - CMP_OPTIMIZABLE(FLOAT), - CMP_OPTIMIZABLE(INTEGER)); rb_block_call(obj, id_each, 0, 0, sort_by_i, (VALUE)memo); ary = data->ary; buf = data->buf; if (data->n) { - rb_ary_resize(buf, data->n*2); - rb_ary_concat(ary, buf); + rb_ary_resize(buf, data->n*2); + rb_ary_concat(ary, buf); } if (RARRAY_LEN(ary) > 2) { - if (data->primitive_uniformed) { - RARRAY_PTR_USE(ary, ptr, - rb_uniform_intro_sort_2((struct rb_uniform_sort_data*)ptr, - (struct rb_uniform_sort_data*)(ptr + RARRAY_LEN(ary)))); - } - else { - RARRAY_PTR_USE(ary, ptr, - ruby_qsort(ptr, RARRAY_LEN(ary)/2, 2*sizeof(VALUE), - sort_by_cmp, (void *)ary)); - } + RARRAY_PTR_USE(ary, ptr, + ruby_qsort(ptr, RARRAY_LEN(ary)/2, 2*sizeof(VALUE), + sort_by_cmp, (void *)ary)); } if (RBASIC(ary)->klass) { - rb_raise(rb_eRuntimeError, "sort_by reentered"); + rb_raise(rb_eRuntimeError, "sort_by reentered"); } for (i=1; i<RARRAY_LEN(ary); i+=2) { - RARRAY_ASET(ary, i/2, RARRAY_AREF(ary, i)); + RARRAY_ASET(ary, i/2, RARRAY_AREF(ary, i)); } rb_ary_resize(ary, RARRAY_LEN(ary)/2); RBASIC_SET_CLASS_RAW(ary, rb_cArray); + OBJ_INFECT(ary, memo); return ary; } #define ENUMFUNC(name) argc ? name##_eqq : rb_block_given_p() ? name##_iter_i : name##_i -#define ENUM_BLOCK_CALL(name) \ - rb_block_call2(obj, id_each, 0, 0, ENUMFUNC(name), (VALUE)memo, rb_block_given_p() && rb_block_pair_yield_optimizable() ? RB_BLOCK_NO_USE_PACKED_ARGS : 0); - #define MEMO_ENUM_NEW(v1) (rb_check_arity(argc, 0, 1), MEMO_NEW((v1), (argc ? *argv : 0), 0)) #define DEFINE_ENUMFUNCS(name) \ @@ -1791,64 +1207,36 @@ name##_eqq(RB_BLOCK_CALL_FUNC_ARGLIST(i, memo)) \ static VALUE \ enum_##name##_func(VALUE result, struct MEMO *memo) -#define WARN_UNUSED_BLOCK(argc) do { \ - if ((argc) > 0 && rb_block_given_p()) { \ - rb_warn("given block not used"); \ - } \ -} while (0) - DEFINE_ENUMFUNCS(all) { if (!RTEST(result)) { - MEMO_V1_SET(memo, Qfalse); - rb_iter_break(); + MEMO_V1_SET(memo, Qfalse); + rb_iter_break(); } return Qnil; } /* * call-seq: - * all? -> true or false - * all?(pattern) -> true or false - * all? {|element| ... } -> true or false - * - * Returns whether every element meets a given criterion. - * - * If +self+ has no element, returns +true+ and argument or block - * are not used. - * - * With no argument and no block, - * returns whether every element is truthy: - * - * (1..4).all? # => true - * %w[a b c d].all? # => true - * [1, 2, nil].all? # => false - * ['a','b', false].all? # => false - * [].all? # => true - * - * With argument +pattern+ and no block, - * returns whether for each element +element+, - * <tt>pattern === element</tt>: - * - * (1..4).all?(Integer) # => true - * (1..4).all?(Numeric) # => true - * (1..4).all?(Float) # => false - * %w[bar baz bat bam].all?(/ba/) # => true - * %w[bar baz bat bam].all?(/bar/) # => false - * %w[bar baz bat bam].all?('ba') # => false - * {foo: 0, bar: 1, baz: 2}.all?(Array) # => true - * {foo: 0, bar: 1, baz: 2}.all?(Hash) # => false - * [].all?(Integer) # => true - * - * With a block given, returns whether the block returns a truthy value - * for every element: - * - * (1..4).all? {|element| element < 5 } # => true - * (1..4).all? {|element| element < 4 } # => false - * {foo: 0, bar: 1, baz: 2}.all? {|key, value| value < 3 } # => true - * {foo: 0, bar: 1, baz: 2}.all? {|key, value| value < 2 } # => false - * - * Related: #any?, #none? #one?. + * enum.all? [{ |obj| block } ] -> true or false + * enum.all?(pattern) -> true or false + * + * Passes each element of the collection to the given block. The method + * returns <code>true</code> if the block never returns + * <code>false</code> or <code>nil</code>. If the block is not given, + * Ruby adds an implicit block of <code>{ |obj| obj }</code> which will + * cause #all? to return +true+ when none of the collection members are + * +false+ or +nil+. + * + * If instead a pattern is supplied, the method returns whether + * <code>pattern === element</code> for every collection member. + * + * %w[ant bear cat].all? { |word| word.length >= 3 } #=> true + * %w[ant bear cat].all? { |word| word.length >= 4 } #=> false + * %w[ant bear cat].all?(/t/) #=> false + * [1, 2i, 3.14].all?(Numeric) #=> true + * [nil, true, 99].all? #=> false + * [].all? #=> true * */ @@ -1856,105 +1244,82 @@ static VALUE enum_all(int argc, VALUE *argv, VALUE obj) { struct MEMO *memo = MEMO_ENUM_NEW(Qtrue); - WARN_UNUSED_BLOCK(argc); - ENUM_BLOCK_CALL(all); + rb_block_call(obj, id_each, 0, 0, ENUMFUNC(all), (VALUE)memo); return memo->v1; } DEFINE_ENUMFUNCS(any) { if (RTEST(result)) { - MEMO_V1_SET(memo, Qtrue); - rb_iter_break(); + MEMO_V1_SET(memo, Qtrue); + rb_iter_break(); } return Qnil; } /* * call-seq: - * any? -> true or false - * any?(pattern) -> true or false - * any? {|element| ... } -> true or false - * - * Returns whether any element meets a given criterion. - * - * If +self+ has no element, returns +false+ and argument or block - * are not used. - * - * With no argument and no block, - * returns whether any element is truthy: - * - * (1..4).any? # => true - * %w[a b c d].any? # => true - * [1, false, nil].any? # => true - * [].any? # => false - * - * With argument +pattern+ and no block, - * returns whether for any element +element+, - * <tt>pattern === element</tt>: - * - * [nil, false, 0].any?(Integer) # => true - * [nil, false, 0].any?(Numeric) # => true - * [nil, false, 0].any?(Float) # => false - * %w[bar baz bat bam].any?(/m/) # => true - * %w[bar baz bat bam].any?(/foo/) # => false - * %w[bar baz bat bam].any?('ba') # => false - * {foo: 0, bar: 1, baz: 2}.any?(Array) # => true - * {foo: 0, bar: 1, baz: 2}.any?(Hash) # => false - * [].any?(Integer) # => false - * - * With a block given, returns whether the block returns a truthy value - * for any element: - * - * (1..4).any? {|element| element < 2 } # => true - * (1..4).any? {|element| element < 1 } # => false - * {foo: 0, bar: 1, baz: 2}.any? {|key, value| value < 1 } # => true - * {foo: 0, bar: 1, baz: 2}.any? {|key, value| value < 0 } # => false - * - * Related: #all?, #none?, #one?. + * enum.any? [{ |obj| block }] -> true or false + * enum.any?(pattern) -> true or false + * + * Passes each element of the collection to the given block. The method + * returns <code>true</code> if the block ever returns a value other + * than <code>false</code> or <code>nil</code>. If the block is not + * given, Ruby adds an implicit block of <code>{ |obj| obj }</code> that + * will cause #any? to return +true+ if at least one of the collection + * members is not +false+ or +nil+. + * + * If instead a pattern is supplied, the method returns whether + * <code>pattern === element</code> for any collection member. + * + * %w[ant bear cat].any? { |word| word.length >= 3 } #=> true + * %w[ant bear cat].any? { |word| word.length >= 4 } #=> true + * %w[ant bear cat].any?(/d/) #=> false + * [nil, true, 99].any?(Integer) #=> true + * [nil, true, 99].any? #=> true + * [].any? #=> false + * */ static VALUE enum_any(int argc, VALUE *argv, VALUE obj) { struct MEMO *memo = MEMO_ENUM_NEW(Qfalse); - WARN_UNUSED_BLOCK(argc); - ENUM_BLOCK_CALL(any); + rb_block_call(obj, id_each, 0, 0, ENUMFUNC(any), (VALUE)memo); return memo->v1; } DEFINE_ENUMFUNCS(one) { if (RTEST(result)) { - if (UNDEF_P(memo->v1)) { - MEMO_V1_SET(memo, Qtrue); - } - else if (memo->v1 == Qtrue) { - MEMO_V1_SET(memo, Qfalse); - rb_iter_break(); - } + if (memo->v1 == Qundef) { + MEMO_V1_SET(memo, Qtrue); + } + else if (memo->v1 == Qtrue) { + MEMO_V1_SET(memo, Qfalse); + rb_iter_break(); + } } return Qnil; } struct nmin_data { - long n; - long bufmax; - long curlen; - VALUE buf; - VALUE limit; - int (*cmpfunc)(const void *, const void *, void *); - int rev: 1; /* max if 1 */ - int by: 1; /* min_by if 1 */ + long n; + long bufmax; + long curlen; + VALUE buf; + VALUE limit; + int (*cmpfunc)(const void *, const void *, void *); + int rev; /* max if 1 */ + int by; /* min_by if 1 */ + const char *method; }; static VALUE cmpint_reenter_check(struct nmin_data *data, VALUE val) { if (RBASIC(data->buf)->klass) { - rb_raise(rb_eRuntimeError, "%s%s reentered", - data->rev ? "max" : "min", - data->by ? "_by" : ""); + rb_raise(rb_eRuntimeError, "%s reentered", data->method); } return val; } @@ -1962,10 +1327,11 @@ cmpint_reenter_check(struct nmin_data *data, VALUE val) static int nmin_cmp(const void *ap, const void *bp, void *_data) { + struct cmp_opt_data cmp_opt = { 0, 0 }; struct nmin_data *data = (struct nmin_data *)_data; VALUE a = *(const VALUE *)ap, b = *(const VALUE *)bp; #define rb_cmpint(cmp, a, b) rb_cmpint(cmpint_reenter_check(data, (cmp)), a, b) - return OPTIMIZED_CMP(a, b); + return OPTIMIZED_CMP(a, b, cmp_opt); #undef rb_cmpint } @@ -1993,7 +1359,7 @@ nmin_filter(struct nmin_data *data) long i, j; if (data->curlen <= data->n) - return; + return; n = data->n; beg = RARRAY_PTR(data->buf); @@ -2013,57 +1379,57 @@ nmin_filter(struct nmin_data *data) } while (0) while (1) { - long pivot_index = left + (right-left)/2; - long num_pivots = 1; - - SWAP(pivot_index, right); - pivot_index = right; - - store_index = left; - i = left; - while (i <= right-num_pivots) { - int c = data->cmpfunc(GETPTR(i), GETPTR(pivot_index), data); - if (data->rev) - c = -c; - if (c == 0) { - SWAP(i, right-num_pivots); - num_pivots++; - continue; - } - if (c < 0) { - SWAP(i, store_index); - store_index++; - } - i++; - } - j = store_index; - for (i = right; right-num_pivots < i; i--) { - if (i <= j) - break; - SWAP(j, i); - j++; - } - - if (store_index <= n && n <= store_index+num_pivots) - break; - - if (n < store_index) { - right = store_index-1; - } - else { - left = store_index+num_pivots; - } + long pivot_index = left + (right-left)/2; + long num_pivots = 1; + + SWAP(pivot_index, right); + pivot_index = right; + + store_index = left; + i = left; + while (i <= right-num_pivots) { + int c = data->cmpfunc(GETPTR(i), GETPTR(pivot_index), data); + if (data->rev) + c = -c; + if (c == 0) { + SWAP(i, right-num_pivots); + num_pivots++; + continue; + } + if (c < 0) { + SWAP(i, store_index); + store_index++; + } + i++; + } + j = store_index; + for (i = right; right-num_pivots < i; i--) { + if (i <= j) + break; + SWAP(j, i); + j++; + } + + if (store_index <= n && n <= store_index+num_pivots) + break; + + if (n < store_index) { + right = store_index-1; + } + else { + left = store_index+num_pivots; + } } #undef GETPTR #undef SWAP - data->limit = RARRAY_AREF(data->buf, store_index*eltsize); /* the last pivot */ + data->limit = RARRAY_PTR(data->buf)[store_index*eltsize]; /* the last pivot */ data->curlen = data->n; rb_ary_resize(data->buf, data->n * eltsize); } static VALUE -nmin_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, _data)) +nmin_i(VALUE i, VALUE *_data, int argc, VALUE *argv) { struct nmin_data *data = (struct nmin_data *)_data; VALUE cmpv; @@ -2071,11 +1437,11 @@ nmin_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, _data)) ENUM_WANT_SVALUE(); if (data->by) - cmpv = enum_yield(argc, i); + cmpv = enum_yield(argc, i); else - cmpv = i; + cmpv = i; - if (!UNDEF_P(data->limit)) { + if (data->limit != Qundef) { int c = data->cmpfunc(&cmpv, &data->limit, data); if (data->rev) c = -c; @@ -2084,13 +1450,13 @@ nmin_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, _data)) } if (data->by) - rb_ary_push(data->buf, cmpv); + rb_ary_push(data->buf, cmpv); rb_ary_push(data->buf, i); data->curlen++; if (data->curlen == data->bufmax) { - nmin_filter(data); + nmin_filter(data); } return Qnil; @@ -2111,44 +1477,42 @@ rb_nmin_run(VALUE obj, VALUE num, int by, int rev, int ary) rb_raise(rb_eArgError, "too big size"); data.bufmax = data.n * 4; data.curlen = 0; - data.buf = rb_ary_hidden_new(data.bufmax * (by ? 2 : 1)); + data.buf = rb_ary_tmp_new(data.bufmax * (by ? 2 : 1)); data.limit = Qundef; data.cmpfunc = by ? nmin_cmp : rb_block_given_p() ? nmin_block_cmp : - nmin_cmp; + nmin_cmp; data.rev = rev; data.by = by; + data.method = rev ? (by ? "max_by" : "max") + : (by ? "min_by" : "min"); if (ary) { - long i; - for (i = 0; i < RARRAY_LEN(obj); i++) { - VALUE args[1]; - args[0] = RARRAY_AREF(obj, i); - nmin_i(obj, (VALUE)&data, 1, args, Qundef); - } + long i; + for (i = 0; i < RARRAY_LEN(obj); i++) { + VALUE args[1]; + args[0] = RARRAY_AREF(obj, i); + nmin_i(obj, (VALUE*)&data, 1, args); + } } else { - rb_block_call(obj, id_each, 0, 0, nmin_i, (VALUE)&data); + rb_block_call(obj, id_each, 0, 0, nmin_i, (VALUE)&data); } nmin_filter(&data); result = data.buf; if (by) { - long i; - RARRAY_PTR_USE(result, ptr, { - ruby_qsort(ptr, - RARRAY_LEN(result)/2, - sizeof(VALUE)*2, - data.cmpfunc, (void *)&data); - for (i=1; i<RARRAY_LEN(result); i+=2) { - ptr[i/2] = ptr[i]; - } - }); - rb_ary_resize(result, RARRAY_LEN(result)/2); + long i; + ruby_qsort(RARRAY_PTR(result), + RARRAY_LEN(result)/2, + sizeof(VALUE)*2, + data.cmpfunc, (void *)&data); + for (i=1; i<RARRAY_LEN(result); i+=2) { + RARRAY_PTR(result)[i/2] = RARRAY_PTR(result)[i]; + } + rb_ary_resize(result, RARRAY_LEN(result)/2); } else { - RARRAY_PTR_USE(result, ptr, { - ruby_qsort(ptr, RARRAY_LEN(result), sizeof(VALUE), - data.cmpfunc, (void *)&data); - }); + ruby_qsort(RARRAY_PTR(result), RARRAY_LEN(result), sizeof(VALUE), + data.cmpfunc, (void *)&data); } if (rev) { rb_ary_reverse(result); @@ -2160,45 +1524,26 @@ rb_nmin_run(VALUE obj, VALUE num, int by, int rev, int ary) /* * call-seq: - * one? -> true or false - * one?(pattern) -> true or false - * one? {|element| ... } -> true or false - * - * Returns whether exactly one element meets a given criterion. - * - * With no argument and no block, - * returns whether exactly one element is truthy: - * - * (1..1).one? # => true - * [1, nil, false].one? # => true - * (1..4).one? # => false - * {foo: 0}.one? # => true - * {foo: 0, bar: 1}.one? # => false - * [].one? # => false - * - * With argument +pattern+ and no block, - * returns whether for exactly one element +element+, - * <tt>pattern === element</tt>: - * - * [nil, false, 0].one?(Integer) # => true - * [nil, false, 0].one?(Numeric) # => true - * [nil, false, 0].one?(Float) # => false - * %w[bar baz bat bam].one?(/m/) # => true - * %w[bar baz bat bam].one?(/foo/) # => false - * %w[bar baz bat bam].one?('ba') # => false - * {foo: 0, bar: 1, baz: 2}.one?(Array) # => false - * {foo: 0}.one?(Array) # => true - * [].one?(Integer) # => false - * - * With a block given, returns whether the block returns a truthy value - * for exactly one element: - * - * (1..4).one? {|element| element < 2 } # => true - * (1..4).one? {|element| element < 1 } # => false - * {foo: 0, bar: 1, baz: 2}.one? {|key, value| value < 1 } # => true - * {foo: 0, bar: 1, baz: 2}.one? {|key, value| value < 2 } # => false - * - * Related: #none?, #all?, #any?. + * enum.one? [{ |obj| block }] -> true or false + * enum.one?(pattern) -> true or false + * + * Passes each element of the collection to the given block. The method + * returns <code>true</code> if the block returns <code>true</code> + * exactly once. If the block is not given, <code>one?</code> will return + * <code>true</code> only if exactly one of the collection members is + * true. + * + * If instead a pattern is supplied, the method returns whether + * <code>pattern === element</code> for exactly one collection member. + * + * %w{ant bear cat}.one? { |word| word.length == 4 } #=> true + * %w{ant bear cat}.one? { |word| word.length > 4 } #=> false + * %w{ant bear cat}.one? { |word| word.length < 4 } #=> false + * %w{ant bear cat}.one?(/t/) #=> false + * [ nil, true, 99 ].one? #=> false + * [ nil, true, false ].one? #=> true + * [ nil, true, 99 ].one?(Integer) #=> true + * [].one? #=> false * */ static VALUE @@ -2207,74 +1552,54 @@ enum_one(int argc, VALUE *argv, VALUE obj) struct MEMO *memo = MEMO_ENUM_NEW(Qundef); VALUE result; - WARN_UNUSED_BLOCK(argc); - ENUM_BLOCK_CALL(one); + rb_block_call(obj, id_each, 0, 0, ENUMFUNC(one), (VALUE)memo); result = memo->v1; - if (UNDEF_P(result)) return Qfalse; + if (result == Qundef) return Qfalse; return result; } DEFINE_ENUMFUNCS(none) { if (RTEST(result)) { - MEMO_V1_SET(memo, Qfalse); - rb_iter_break(); + MEMO_V1_SET(memo, Qfalse); + rb_iter_break(); } return Qnil; } /* * call-seq: - * none? -> true or false - * none?(pattern) -> true or false - * none? {|element| ... } -> true or false - * - * Returns whether no element meets a given criterion. - * - * With no argument and no block, - * returns whether no element is truthy: - * - * (1..4).none? # => false - * [nil, false].none? # => true - * {foo: 0}.none? # => false - * {foo: 0, bar: 1}.none? # => false - * [].none? # => true - * - * With argument +pattern+ and no block, - * returns whether for no element +element+, - * <tt>pattern === element</tt>: - * - * [nil, false, 1.1].none?(Integer) # => true - * %w[bar baz bat bam].none?(/m/) # => false - * %w[bar baz bat bam].none?(/foo/) # => true - * %w[bar baz bat bam].none?('ba') # => true - * {foo: 0, bar: 1, baz: 2}.none?(Hash) # => true - * {foo: 0}.none?(Array) # => false - * [].none?(Integer) # => true - * - * With a block given, returns whether the block returns a truthy value - * for no element: - * - * (1..4).none? {|element| element < 1 } # => true - * (1..4).none? {|element| element < 2 } # => false - * {foo: 0, bar: 1, baz: 2}.none? {|key, value| value < 0 } # => true - * {foo: 0, bar: 1, baz: 2}.none? {|key, value| value < 1 } # => false - * - * Related: #one?, #all?, #any?. - * + * enum.none? [{ |obj| block }] -> true or false + * enum.none?(pattern) -> true or false + * + * Passes each element of the collection to the given block. The method + * returns <code>true</code> if the block never returns <code>true</code> + * for all elements. If the block is not given, <code>none?</code> will return + * <code>true</code> only if none of the collection members is true. + * + * If instead a pattern is supplied, the method returns whether + * <code>pattern === element</code> for none of the collection members. + * + * %w{ant bear cat}.none? { |word| word.length == 5 } #=> true + * %w{ant bear cat}.none? { |word| word.length >= 4 } #=> false + * %w{ant bear cat}.none?(/d/) #=> true + * [1, 3.14, 42].none?(Float) #=> false + * [].none? #=> true + * [nil].none? #=> true + * [nil, false].none? #=> true + * [nil, false, true].none? #=> false */ static VALUE enum_none(int argc, VALUE *argv, VALUE obj) { struct MEMO *memo = MEMO_ENUM_NEW(Qtrue); - - WARN_UNUSED_BLOCK(argc); - ENUM_BLOCK_CALL(none); + rb_block_call(obj, id_each, 0, 0, ENUMFUNC(none), (VALUE)memo); return memo->v1; } struct min_t { VALUE min; + struct cmp_opt_data cmp_opt; }; static VALUE @@ -2284,13 +1609,13 @@ min_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args)) ENUM_WANT_SVALUE(); - if (UNDEF_P(memo->min)) { - memo->min = i; + if (memo->min == Qundef) { + memo->min = i; } else { - if (OPTIMIZED_CMP(i, memo->min) < 0) { - memo->min = i; - } + if (OPTIMIZED_CMP(i, memo->min, memo->cmp_opt) < 0) { + memo->min = i; + } } return Qnil; } @@ -2303,14 +1628,14 @@ min_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, args)) ENUM_WANT_SVALUE(); - if (UNDEF_P(memo->min)) { - memo->min = i; + if (memo->min == Qundef) { + memo->min = i; } else { - cmp = rb_yield_values(2, i, memo->min); - if (rb_cmpint(cmp, i, memo->min) < 0) { - memo->min = i; - } + cmp = rb_yield_values(2, i, memo->min); + if (rb_cmpint(cmp, i, memo->min) < 0) { + memo->min = i; + } } return Qnil; } @@ -2318,86 +1643,58 @@ min_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, args)) /* * call-seq: - * min -> element - * min(n) -> array - * min {|a, b| ... } -> element - * min(n) {|a, b| ... } -> array - * - * Returns the element with the minimum element according to a given criterion. - * The ordering of equal elements is indeterminate and may be unstable. - * - * With no argument and no block, returns the minimum element, - * using the elements' own method <tt>#<=></tt> for comparison: - * - * (1..4).min # => 1 - * (-4..-1).min # => -4 - * %w[d c b a].min # => "a" - * {foo: 0, bar: 1, baz: 2}.min # => [:bar, 1] - * [].min # => nil - * - * With positive integer argument +n+ given, and no block, - * returns an array containing the first +n+ minimum elements that exist: - * - * (1..4).min(2) # => [1, 2] - * (-4..-1).min(2) # => [-4, -3] - * %w[d c b a].min(2) # => ["a", "b"] - * {foo: 0, bar: 1, baz: 2}.min(2) # => [[:bar, 1], [:baz, 2]] - * [].min(2) # => [] - * - * With a block given, the block determines the minimum elements. - * The block is called with two elements +a+ and +b+, and must return: - * - * - A negative integer if <tt>a < b</tt>. - * - Zero if <tt>a == b</tt>. - * - A positive integer if <tt>a > b</tt>. - * - * With a block given and no argument, - * returns the minimum element as determined by the block: - * - * %w[xxx x xxxx xx].min {|a, b| a.size <=> b.size } # => "x" - * h = {foo: 0, bar: 1, baz: 2} - * h.min {|pair1, pair2| pair1[1] <=> pair2[1] } # => [:foo, 0] - * [].min {|a, b| a <=> b } # => nil - * - * With a block given and positive integer argument +n+ given, - * returns an array containing the first +n+ minimum elements that exist, - * as determined by the block. - * - * %w[xxx x xxxx xx].min(2) {|a, b| a.size <=> b.size } # => ["x", "xx"] - * h = {foo: 0, bar: 1, baz: 2} - * h.min(2) {|pair1, pair2| pair1[1] <=> pair2[1] } - * # => [[:foo, 0], [:bar, 1]] - * [].min(2) {|a, b| a <=> b } # => [] - * - * Related: #min_by, #minmax, #max. - * + * enum.min -> obj + * enum.min { |a, b| block } -> obj + * enum.min(n) -> array + * enum.min(n) { |a, b| block } -> array + * + * Returns the object in _enum_ with the minimum value. The + * first form assumes all objects implement <code>Comparable</code>; + * the second uses the block to return <em>a <=> b</em>. + * + * a = %w(albatross dog horse) + * a.min #=> "albatross" + * a.min { |a, b| a.length <=> b.length } #=> "dog" + * + * If the +n+ argument is given, minimum +n+ elements are returned + * as a sorted array. + * + * a = %w[albatross dog horse] + * a.min(2) #=> ["albatross", "dog"] + * a.min(2) {|a, b| a.length <=> b.length } #=> ["dog", "horse"] + * [5, 1, 3, 4, 2].min(3) #=> [1, 2, 3] */ static VALUE enum_min(int argc, VALUE *argv, VALUE obj) { VALUE memo; - struct min_t *m = NEW_MEMO_FOR(struct min_t, memo); + struct min_t *m = NEW_CMP_OPT_MEMO(struct min_t, memo); VALUE result; VALUE num; - if (rb_check_arity(argc, 0, 1) && !NIL_P(num = argv[0])) + rb_scan_args(argc, argv, "01", &num); + + if (!NIL_P(num)) return rb_nmin_run(obj, num, 0, 0, 0); m->min = Qundef; + m->cmp_opt.opt_methods = 0; + m->cmp_opt.opt_inited = 0; if (rb_block_given_p()) { - rb_block_call(obj, id_each, 0, 0, min_ii, memo); + rb_block_call(obj, id_each, 0, 0, min_ii, memo); } else { - rb_block_call(obj, id_each, 0, 0, min_i, memo); + rb_block_call(obj, id_each, 0, 0, min_i, memo); } result = m->min; - if (UNDEF_P(result)) return Qnil; + if (result == Qundef) return Qnil; return result; } struct max_t { VALUE max; + struct cmp_opt_data cmp_opt; }; static VALUE @@ -2407,13 +1704,13 @@ max_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args)) ENUM_WANT_SVALUE(); - if (UNDEF_P(memo->max)) { - memo->max = i; + if (memo->max == Qundef) { + memo->max = i; } else { - if (OPTIMIZED_CMP(i, memo->max) > 0) { - memo->max = i; - } + if (OPTIMIZED_CMP(i, memo->max, memo->cmp_opt) > 0) { + memo->max = i; + } } return Qnil; } @@ -2426,95 +1723,66 @@ max_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, args)) ENUM_WANT_SVALUE(); - if (UNDEF_P(memo->max)) { - memo->max = i; + if (memo->max == Qundef) { + memo->max = i; } else { - cmp = rb_yield_values(2, i, memo->max); - if (rb_cmpint(cmp, i, memo->max) > 0) { - memo->max = i; - } + cmp = rb_yield_values(2, i, memo->max); + if (rb_cmpint(cmp, i, memo->max) > 0) { + memo->max = i; + } } return Qnil; } /* * call-seq: - * max -> element - * max(n) -> array - * max {|a, b| ... } -> element - * max(n) {|a, b| ... } -> array - * - * Returns the element with the maximum element according to a given criterion. - * The ordering of equal elements is indeterminate and may be unstable. - * - * With no argument and no block, returns the maximum element, - * using the elements' own method <tt>#<=></tt> for comparison: - * - * (1..4).max # => 4 - * (-4..-1).max # => -1 - * %w[d c b a].max # => "d" - * {foo: 0, bar: 1, baz: 2}.max # => [:foo, 0] - * [].max # => nil - * - * With positive integer argument +n+ given, and no block, - * returns an array containing the first +n+ maximum elements that exist: - * - * (1..4).max(2) # => [4, 3] - * (-4..-1).max(2) # => [-1, -2] - * %w[d c b a].max(2) # => ["d", "c"] - * {foo: 0, bar: 1, baz: 2}.max(2) # => [[:foo, 0], [:baz, 2]] - * [].max(2) # => [] - * - * With a block given, the block determines the maximum elements. - * The block is called with two elements +a+ and +b+, and must return: - * - * - A negative integer if <tt>a < b</tt>. - * - Zero if <tt>a == b</tt>. - * - A positive integer if <tt>a > b</tt>. - * - * With a block given and no argument, - * returns the maximum element as determined by the block: - * - * %w[xxx x xxxx xx].max {|a, b| a.size <=> b.size } # => "xxxx" - * h = {foo: 0, bar: 1, baz: 2} - * h.max {|pair1, pair2| pair1[1] <=> pair2[1] } # => [:baz, 2] - * [].max {|a, b| a <=> b } # => nil - * - * With a block given and positive integer argument +n+ given, - * returns an array containing the first +n+ maximum elements that exist, - * as determined by the block. - * - * %w[xxx x xxxx xx].max(2) {|a, b| a.size <=> b.size } # => ["xxxx", "xxx"] - * h = {foo: 0, bar: 1, baz: 2} - * h.max(2) {|pair1, pair2| pair1[1] <=> pair2[1] } - * # => [[:baz, 2], [:bar, 1]] - * [].max(2) {|a, b| a <=> b } # => [] - * - * Related: #min, #minmax, #max_by. - * + * enum.max -> obj + * enum.max { |a, b| block } -> obj + * enum.max(n) -> array + * enum.max(n) { |a, b| block } -> array + * + * Returns the object in _enum_ with the maximum value. The + * first form assumes all objects implement <code>Comparable</code>; + * the second uses the block to return <em>a <=> b</em>. + * + * a = %w(albatross dog horse) + * a.max #=> "horse" + * a.max { |a, b| a.length <=> b.length } #=> "albatross" + * + * If the +n+ argument is given, maximum +n+ elements are returned + * as an array, sorted in descending order. + * + * a = %w[albatross dog horse] + * a.max(2) #=> ["horse", "dog"] + * a.max(2) {|a, b| a.length <=> b.length } #=> ["albatross", "horse"] + * [5, 1, 3, 4, 2].max(3) #=> [5, 4, 3] */ static VALUE enum_max(int argc, VALUE *argv, VALUE obj) { VALUE memo; - struct max_t *m = NEW_MEMO_FOR(struct max_t, memo); + struct max_t *m = NEW_CMP_OPT_MEMO(struct max_t, memo); VALUE result; VALUE num; - if (rb_check_arity(argc, 0, 1) && !NIL_P(num = argv[0])) + rb_scan_args(argc, argv, "01", &num); + + if (!NIL_P(num)) return rb_nmin_run(obj, num, 0, 1, 0); m->max = Qundef; + m->cmp_opt.opt_methods = 0; + m->cmp_opt.opt_inited = 0; if (rb_block_given_p()) { - rb_block_call(obj, id_each, 0, 0, max_ii, (VALUE)memo); + rb_block_call(obj, id_each, 0, 0, max_ii, (VALUE)memo); } else { - rb_block_call(obj, id_each, 0, 0, max_i, (VALUE)memo); + rb_block_call(obj, id_each, 0, 0, max_i, (VALUE)memo); } result = m->max; - if (UNDEF_P(result)) return Qnil; + if (result == Qundef) return Qnil; return result; } @@ -2522,6 +1790,7 @@ struct minmax_t { VALUE min; VALUE max; VALUE last; + struct cmp_opt_data cmp_opt; }; static void @@ -2529,19 +1798,19 @@ minmax_i_update(VALUE i, VALUE j, struct minmax_t *memo) { int n; - if (UNDEF_P(memo->min)) { - memo->min = i; - memo->max = j; + if (memo->min == Qundef) { + memo->min = i; + memo->max = j; } else { - n = OPTIMIZED_CMP(i, memo->min); - if (n < 0) { - memo->min = i; - } - n = OPTIMIZED_CMP(j, memo->max); - if (n > 0) { - memo->max = j; - } + n = OPTIMIZED_CMP(i, memo->min, memo->cmp_opt); + if (n < 0) { + memo->min = i; + } + n = OPTIMIZED_CMP(j, memo->max, memo->cmp_opt); + if (n > 0) { + memo->max = j; + } } } @@ -2554,14 +1823,14 @@ minmax_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, _memo)) ENUM_WANT_SVALUE(); - if (UNDEF_P(memo->last)) { + if (memo->last == Qundef) { memo->last = i; return Qnil; } j = memo->last; memo->last = Qundef; - n = OPTIMIZED_CMP(j, i); + n = OPTIMIZED_CMP(j, i, memo->cmp_opt); if (n == 0) i = j; else if (n < 0) { @@ -2581,19 +1850,19 @@ minmax_ii_update(VALUE i, VALUE j, struct minmax_t *memo) { int n; - if (UNDEF_P(memo->min)) { - memo->min = i; - memo->max = j; + if (memo->min == Qundef) { + memo->min = i; + memo->max = j; } else { - n = rb_cmpint(rb_yield_values(2, i, memo->min), i, memo->min); - if (n < 0) { - memo->min = i; - } - n = rb_cmpint(rb_yield_values(2, j, memo->max), j, memo->max); - if (n > 0) { - memo->max = j; - } + n = rb_cmpint(rb_yield_values(2, i, memo->min), i, memo->min); + if (n < 0) { + memo->min = i; + } + n = rb_cmpint(rb_yield_values(2, j, memo->max), j, memo->max); + if (n > 0) { + memo->max = j; + } } } @@ -2606,7 +1875,7 @@ minmax_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, _memo)) ENUM_WANT_SVALUE(); - if (UNDEF_P(memo->last)) { + if (memo->last == Qundef) { memo->last = i; return Qnil; } @@ -2630,55 +1899,41 @@ minmax_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, _memo)) /* * call-seq: - * minmax -> [minimum, maximum] - * minmax {|a, b| ... } -> [minimum, maximum] - * - * Returns a 2-element array containing the minimum and maximum elements - * according to a given criterion. - * The ordering of equal elements is indeterminate and may be unstable. - * - * With no argument and no block, returns the minimum and maximum elements, - * using the elements' own method <tt>#<=></tt> for comparison: - * - * (1..4).minmax # => [1, 4] - * (-4..-1).minmax # => [-4, -1] - * %w[d c b a].minmax # => ["a", "d"] - * {foo: 0, bar: 1, baz: 2}.minmax # => [[:bar, 1], [:foo, 0]] - * [].minmax # => [nil, nil] + * enum.minmax -> [min, max] + * enum.minmax { |a, b| block } -> [min, max] * - * With a block given, returns the minimum and maximum elements - * as determined by the block: - * - * %w[xxx x xxxx xx].minmax {|a, b| a.size <=> b.size } # => ["x", "xxxx"] - * h = {foo: 0, bar: 1, baz: 2} - * h.minmax {|pair1, pair2| pair1[1] <=> pair2[1] } - * # => [[:foo, 0], [:baz, 2]] - * [].minmax {|a, b| a <=> b } # => [nil, nil] - * - * Related: #min, #max, #minmax_by. + * Returns a two element array which contains the minimum and the + * maximum value in the enumerable. The first form assumes all + * objects implement <code>Comparable</code>; the second uses the + * block to return <em>a <=> b</em>. * + * a = %w(albatross dog horse) + * a.minmax #=> ["albatross", "horse"] + * a.minmax { |a, b| a.length <=> b.length } #=> ["dog", "albatross"] */ static VALUE enum_minmax(VALUE obj) { VALUE memo; - struct minmax_t *m = NEW_MEMO_FOR(struct minmax_t, memo); + struct minmax_t *m = NEW_CMP_OPT_MEMO(struct minmax_t, memo); m->min = Qundef; m->last = Qundef; + m->cmp_opt.opt_methods = 0; + m->cmp_opt.opt_inited = 0; if (rb_block_given_p()) { - rb_block_call(obj, id_each, 0, 0, minmax_ii, memo); - if (!UNDEF_P(m->last)) - minmax_ii_update(m->last, m->last, m); + rb_block_call(obj, id_each, 0, 0, minmax_ii, memo); + if (m->last != Qundef) + minmax_ii_update(m->last, m->last, m); } else { - rb_block_call(obj, id_each, 0, 0, minmax_i, memo); - if (!UNDEF_P(m->last)) - minmax_i_update(m->last, m->last, m); + rb_block_call(obj, id_each, 0, 0, minmax_i, memo); + if (m->last != Qundef) + minmax_i_update(m->last, m->last, m); } - if (!UNDEF_P(m->min)) { - return rb_assoc_new(m->min, m->max); + if (m->min != Qundef) { + return rb_assoc_new(m->min, m->max); } return rb_assoc_new(Qnil, Qnil); } @@ -2686,57 +1941,45 @@ enum_minmax(VALUE obj) static VALUE min_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args)) { + struct cmp_opt_data cmp_opt = { 0, 0 }; struct MEMO *memo = MEMO_CAST(args); VALUE v; ENUM_WANT_SVALUE(); v = enum_yield(argc, i); - if (UNDEF_P(memo->v1)) { - MEMO_V1_SET(memo, v); - MEMO_V2_SET(memo, i); + if (memo->v1 == Qundef) { + MEMO_V1_SET(memo, v); + MEMO_V2_SET(memo, i); } - else if (OPTIMIZED_CMP(v, memo->v1) < 0) { - MEMO_V1_SET(memo, v); - MEMO_V2_SET(memo, i); + else if (OPTIMIZED_CMP(v, memo->v1, cmp_opt) < 0) { + MEMO_V1_SET(memo, v); + MEMO_V2_SET(memo, i); } return Qnil; } /* * call-seq: - * min_by {|element| ... } -> element - * min_by(n) {|element| ... } -> array - * min_by -> enumerator - * min_by(n) -> enumerator - * - * Returns the elements for which the block returns the minimum values. - * - * With a block given and no argument, - * returns the element for which the block returns the minimum value: - * - * (1..4).min_by {|element| -element } # => 4 - * %w[a b c d].min_by {|element| -element.ord } # => "d" - * {foo: 0, bar: 1, baz: 2}.min_by {|key, value| -value } # => [:baz, 2] - * [].min_by {|element| -element } # => nil + * enum.min_by {|obj| block } -> obj + * enum.min_by -> an_enumerator + * enum.min_by(n) {|obj| block } -> array + * enum.min_by(n) -> an_enumerator * - * With a block given and positive integer argument +n+ given, - * returns an array containing the +n+ elements - * for which the block returns minimum values: + * Returns the object in <i>enum</i> that gives the minimum + * value from the given block. * - * (1..4).min_by(2) {|element| -element } - * # => [4, 3] - * %w[a b c d].min_by(2) {|element| -element.ord } - * # => ["d", "c"] - * {foo: 0, bar: 1, baz: 2}.min_by(2) {|key, value| -value } - * # => [[:baz, 2], [:bar, 1]] - * [].min_by(2) {|element| -element } - * # => [] + * If no block is given, an enumerator is returned instead. * - * Returns an Enumerator if no block is given. + * a = %w(albatross dog horse) + * a.min_by { |x| x.length } #=> "dog" * - * Related: #min, #minmax, #max_by. + * If the +n+ argument is given, minimum +n+ elements are returned + * as an array. These +n+ elements are sorted by the value from the + * given block. * + * a = %w[albatross dog horse] + * p a.min_by(2) {|x| x.length } #=> ["dog", "horse"] */ static VALUE @@ -2745,11 +1988,11 @@ enum_min_by(int argc, VALUE *argv, VALUE obj) struct MEMO *memo; VALUE num; - rb_check_arity(argc, 0, 1); + rb_scan_args(argc, argv, "01", &num); RETURN_SIZED_ENUMERATOR(obj, argc, argv, enum_size); - if (argc && !NIL_P(num = argv[0])) + if (!NIL_P(num)) return rb_nmin_run(obj, num, 1, 0, 0); memo = MEMO_NEW(Qundef, Qnil, 0); @@ -2760,56 +2003,89 @@ enum_min_by(int argc, VALUE *argv, VALUE obj) static VALUE max_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args)) { + struct cmp_opt_data cmp_opt = { 0, 0 }; struct MEMO *memo = MEMO_CAST(args); VALUE v; ENUM_WANT_SVALUE(); v = enum_yield(argc, i); - if (UNDEF_P(memo->v1)) { - MEMO_V1_SET(memo, v); - MEMO_V2_SET(memo, i); + if (memo->v1 == Qundef) { + MEMO_V1_SET(memo, v); + MEMO_V2_SET(memo, i); } - else if (OPTIMIZED_CMP(v, memo->v1) > 0) { - MEMO_V1_SET(memo, v); - MEMO_V2_SET(memo, i); + else if (OPTIMIZED_CMP(v, memo->v1, cmp_opt) > 0) { + MEMO_V1_SET(memo, v); + MEMO_V2_SET(memo, i); } return Qnil; } /* * call-seq: - * max_by {|element| ... } -> element - * max_by(n) {|element| ... } -> array - * max_by -> enumerator - * max_by(n) -> enumerator - * - * Returns the elements for which the block returns the maximum values. - * - * With a block given and no argument, - * returns the element for which the block returns the maximum value: - * - * (1..4).max_by {|element| -element } # => 1 - * %w[a b c d].max_by {|element| -element.ord } # => "a" - * {foo: 0, bar: 1, baz: 2}.max_by {|key, value| -value } # => [:foo, 0] - * [].max_by {|element| -element } # => nil - * - * With a block given and positive integer argument +n+ given, - * returns an array containing the +n+ elements - * for which the block returns maximum values: - * - * (1..4).max_by(2) {|element| -element } - * # => [1, 2] - * %w[a b c d].max_by(2) {|element| -element.ord } - * # => ["a", "b"] - * {foo: 0, bar: 1, baz: 2}.max_by(2) {|key, value| -value } - * # => [[:foo, 0], [:bar, 1]] - * [].max_by(2) {|element| -element } - * # => [] - * - * Returns an Enumerator if no block is given. - * - * Related: #max, #minmax, #min_by. + * enum.max_by {|obj| block } -> obj + * enum.max_by -> an_enumerator + * enum.max_by(n) {|obj| block } -> obj + * enum.max_by(n) -> an_enumerator + * + * Returns the object in <i>enum</i> that gives the maximum + * value from the given block. + * + * If no block is given, an enumerator is returned instead. + * + * a = %w(albatross dog horse) + * a.max_by { |x| x.length } #=> "albatross" + * + * If the +n+ argument is given, maximum +n+ elements are returned + * as an array. These +n+ elements are sorted by the value from the + * given block, in descending order. + * + * a = %w[albatross dog horse] + * a.max_by(2) {|x| x.length } #=> ["albatross", "horse"] + * + * enum.max_by(n) can be used to implement weighted random sampling. + * Following example implements and use Enumerable#wsample. + * + * module Enumerable + * # weighted random sampling. + * # + * # Pavlos S. Efraimidis, Paul G. Spirakis + * # Weighted random sampling with a reservoir + * # Information Processing Letters + * # Volume 97, Issue 5 (16 March 2006) + * def wsample(n) + * self.max_by(n) {|v| rand ** (1.0/yield(v)) } + * end + * end + * e = (-20..20).to_a*10000 + * a = e.wsample(20000) {|x| + * Math.exp(-(x/5.0)**2) # normal distribution + * } + * # a is 20000 samples from e. + * p a.length #=> 20000 + * h = a.group_by {|x| x } + * -10.upto(10) {|x| puts "*" * (h[x].length/30.0).to_i if h[x] } + * #=> * + * # *** + * # ****** + * # *********** + * # ****************** + * # ***************************** + * # ***************************************** + * # **************************************************** + * # *************************************************************** + * # ******************************************************************** + * # *********************************************************************** + * # *********************************************************************** + * # ************************************************************** + * # **************************************************** + * # *************************************** + * # *************************** + * # ****************** + * # *********** + * # ******* + * # *** + * # * * */ @@ -2819,11 +2095,11 @@ enum_max_by(int argc, VALUE *argv, VALUE obj) struct MEMO *memo; VALUE num; - rb_check_arity(argc, 0, 1); + rb_scan_args(argc, argv, "01", &num); RETURN_SIZED_ENUMERATOR(obj, argc, argv, enum_size); - if (argc && !NIL_P(num = argv[0])) + if (!NIL_P(num)) return rb_nmin_run(obj, num, 1, 1, 0); memo = MEMO_NEW(Qundef, Qnil, 0); @@ -2843,27 +2119,30 @@ struct minmax_by_t { static void minmax_by_i_update(VALUE v1, VALUE v2, VALUE i1, VALUE i2, struct minmax_by_t *memo) { - if (UNDEF_P(memo->min_bv)) { - memo->min_bv = v1; - memo->max_bv = v2; - memo->min = i1; - memo->max = i2; + struct cmp_opt_data cmp_opt = { 0, 0 }; + + if (memo->min_bv == Qundef) { + memo->min_bv = v1; + memo->max_bv = v2; + memo->min = i1; + memo->max = i2; } else { - if (OPTIMIZED_CMP(v1, memo->min_bv) < 0) { - memo->min_bv = v1; - memo->min = i1; - } - if (OPTIMIZED_CMP(v2, memo->max_bv) > 0) { - memo->max_bv = v2; - memo->max = i2; - } + if (OPTIMIZED_CMP(v1, memo->min_bv, cmp_opt) < 0) { + memo->min_bv = v1; + memo->min = i1; + } + if (OPTIMIZED_CMP(v2, memo->max_bv, cmp_opt) > 0) { + memo->max_bv = v2; + memo->max = i2; + } } } static VALUE minmax_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, _memo)) { + struct cmp_opt_data cmp_opt = { 0, 0 }; struct minmax_by_t *memo = MEMO_FOR(struct minmax_by_t, _memo); VALUE vi, vj, j; int n; @@ -2872,7 +2151,7 @@ minmax_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, _memo)) vi = enum_yield(argc, i); - if (UNDEF_P(memo->last_bv)) { + if (memo->last_bv == Qundef) { memo->last_bv = vi; memo->last = i; return Qnil; @@ -2881,7 +2160,7 @@ minmax_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, _memo)) j = memo->last; memo->last_bv = Qundef; - n = OPTIMIZED_CMP(vj, vi); + n = OPTIMIZED_CMP(vj, vi, cmp_opt); if (n == 0) { i = j; vi = vj; @@ -2903,25 +2182,17 @@ minmax_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, _memo)) /* * call-seq: - * minmax_by {|element| ... } -> [minimum, maximum] - * minmax_by -> enumerator - * - * Returns a 2-element array containing the elements - * for which the block returns minimum and maximum values: + * enum.minmax_by { |obj| block } -> [min, max] + * enum.minmax_by -> an_enumerator * - * (1..4).minmax_by {|element| -element } - * # => [4, 1] - * %w[a b c d].minmax_by {|element| -element.ord } - * # => ["d", "a"] - * {foo: 0, bar: 1, baz: 2}.minmax_by {|key, value| -value } - * # => [[:baz, 2], [:foo, 0]] - * [].minmax_by {|element| -element } - * # => [nil, nil] + * Returns a two element array containing the objects in + * <i>enum</i> that correspond to the minimum and maximum values respectively + * from the given block. * - * Returns an Enumerator if no block is given. - * - * Related: #max_by, #minmax, #min_by. + * If no block is given, an enumerator is returned instead. * + * a = %w(albatross dog horse) + * a.minmax_by { |x| x.length } #=> ["dog", "albatross"] */ static VALUE @@ -2939,7 +2210,7 @@ enum_minmax_by(VALUE obj) m->last_bv = Qundef; m->last = Qundef; rb_block_call(obj, id_each, 0, 0, minmax_by_i, memo); - if (!UNDEF_P(m->last_bv)) + if (m->last_bv != Qundef) minmax_by_i_update(m->last_bv, m->last_bv, m->last, m->last, m); m = MEMO_FOR(struct minmax_by_t, memo); return rb_assoc_new(m->min, m->max); @@ -2951,26 +2222,24 @@ member_i(RB_BLOCK_CALL_FUNC_ARGLIST(iter, args)) struct MEMO *memo = MEMO_CAST(args); if (rb_equal(rb_enum_values_pack(argc, argv), memo->v1)) { - MEMO_V2_SET(memo, Qtrue); - rb_iter_break(); + MEMO_V2_SET(memo, Qtrue); + rb_iter_break(); } return Qnil; } /* * call-seq: - * include?(object) -> true or false + * enum.include?(obj) -> true or false + * enum.member?(obj) -> true or false * - * Returns whether for any element <tt>object == element</tt>: + * Returns <code>true</code> if any member of <i>enum</i> equals + * <i>obj</i>. Equality is tested using <code>==</code>. * - * (1..4).include?(2) # => true - * (1..4).include?(5) # => false - * (1..4).include?('2') # => false - * %w[a b c d].include?('b') # => true - * %w[a b c d].include?('2') # => false - * {foo: 0, bar: 1, baz: 2}.include?(:foo) # => true - * {foo: 0, bar: 1, baz: 2}.include?('foo') # => false - * {foo: 0, bar: 1, baz: 2}.include?(0) # => false + * IO.constants.include? :SEEK_SET #=> true + * IO.constants.include? :SEEK_NO_FURTHER #=> false + * IO.constants.member? :SEEK_SET #=> true + * IO.constants.member? :SEEK_NO_FURTHER #=> false * */ @@ -2984,96 +2253,77 @@ enum_member(VALUE obj, VALUE val) } static VALUE -each_with_index_i(RB_BLOCK_CALL_FUNC_ARGLIST(_, index)) +each_with_index_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memo)) { - struct vm_ifunc *ifunc = rb_current_ifunc(); - ifunc->data = (const void *)rb_int_succ(index); + struct MEMO *m = MEMO_CAST(memo); + VALUE n = imemo_count_value(m); - return rb_yield_values(2, rb_enum_values_pack(argc, argv), index); + imemo_count_up(m); + return rb_yield_values(2, rb_enum_values_pack(argc, argv), n); } /* * call-seq: - * each_with_index(*args) {|element, i| ..... } -> self - * each_with_index(*args) -> enumerator - * - * Invoke <tt>self.each</tt> with <tt>*args</tt>. - * With a block given, the block receives each element and its index; - * returns +self+: - * - * h = {} - * (1..4).each_with_index {|element, i| h[element] = i } # => 1..4 - * h # => {1=>0, 2=>1, 3=>2, 4=>3} + * enum.each_with_index(*args) { |obj, i| block } -> enum + * enum.each_with_index(*args) -> an_enumerator * - * h = {} - * %w[a b c d].each_with_index {|element, i| h[element] = i } - * # => ["a", "b", "c", "d"] - * h # => {"a"=>0, "b"=>1, "c"=>2, "d"=>3} + * Calls <em>block</em> with two arguments, the item and its index, + * for each item in <i>enum</i>. Given arguments are passed through + * to #each(). * - * a = [] - * h = {foo: 0, bar: 1, baz: 2} - * h.each_with_index {|element, i| a.push([i, element]) } - * # => {:foo=>0, :bar=>1, :baz=>2} - * a # => [[0, [:foo, 0]], [1, [:bar, 1]], [2, [:baz, 2]]] + * If no block is given, an enumerator is returned instead. * - * With no block given, returns an Enumerator. + * hash = Hash.new + * %w(cat dog wombat).each_with_index { |item, index| + * hash[item] = index + * } + * hash #=> {"cat"=>0, "dog"=>1, "wombat"=>2} * */ static VALUE enum_each_with_index(int argc, VALUE *argv, VALUE obj) { + struct MEMO *memo; + RETURN_SIZED_ENUMERATOR(obj, argc, argv, enum_size); - rb_block_call(obj, id_each, argc, argv, each_with_index_i, INT2FIX(0)); + memo = MEMO_NEW(0, 0, 0); + rb_block_call(obj, id_each, argc, argv, each_with_index_i, (VALUE)memo); return obj; } /* * call-seq: - * reverse_each(*args) {|element| ... } -> self - * reverse_each(*args) -> enumerator + * enum.reverse_each(*args) { |item| block } -> enum + * enum.reverse_each(*args) -> an_enumerator * - * With a block given, calls the block with each element, - * but in reverse order; returns +self+: + * Builds a temporary array and traverses that array in reverse order. * - * a = [] - * (1..4).reverse_each {|element| a.push(-element) } # => 1..4 - * a # => [-4, -3, -2, -1] + * If no block is given, an enumerator is returned instead. * - * a = [] - * %w[a b c d].reverse_each {|element| a.push(element) } - * # => ["a", "b", "c", "d"] - * a # => ["d", "c", "b", "a"] + * (1..3).reverse_each { |v| p v } * - * a = [] - * h.reverse_each {|element| a.push(element) } - * # => {:foo=>0, :bar=>1, :baz=>2} - * a # => [[:baz, 2], [:bar, 1], [:foo, 0]] - * - * With no block given, returns an Enumerator. + * produces: * + * 3 + * 2 + * 1 */ static VALUE enum_reverse_each(int argc, VALUE *argv, VALUE obj) { VALUE ary; - long len; + long i; RETURN_SIZED_ENUMERATOR(obj, argc, argv, enum_size); ary = enum_to_a(argc, argv, obj); - len = RARRAY_LEN(ary); - while (len--) { - long nlen; - rb_yield(RARRAY_AREF(ary, len)); - nlen = RARRAY_LEN(ary); - if (nlen < len) { - len = nlen; - } + for (i = RARRAY_LEN(ary); --i >= 0; ) { + rb_yield(RARRAY_AREF(ary, i)); } return obj; @@ -3090,39 +2340,30 @@ each_val_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, p)) /* * call-seq: - * each_entry(*args) {|element| ... } -> self - * each_entry(*args) -> enumerator - * - * Calls the given block with each element, - * converting multiple values from yield to an array; returns +self+: - * - * a = [] - * (1..4).each_entry {|element| a.push(element) } # => 1..4 - * a # => [1, 2, 3, 4] - * - * a = [] - * h = {foo: 0, bar: 1, baz:2} - * h.each_entry {|element| a.push(element) } - * # => {:foo=>0, :bar=>1, :baz=>2} - * a # => [[:foo, 0], [:bar, 1], [:baz, 2]] - * - * class Foo - * include Enumerable - * def each - * yield 1 - * yield 1, 2 - * yield - * end - * end - * Foo.new.each_entry {|yielded| p yielded } - * - * Output: + * enum.each_entry { |obj| block } -> enum + * enum.each_entry -> an_enumerator + * + * Calls <i>block</i> once for each element in +self+, passing that + * element as a parameter, converting multiple values from yield to an + * array. + * + * If no block is given, an enumerator is returned instead. + * + * class Foo + * include Enumerable + * def each + * yield 1 + * yield 1, 2 + * yield + * end + * end + * Foo.new.each_entry{ |o| p o } * - * 1 - * [1, 2] - * nil + * produces: * - * With no block given, returns an Enumerator. + * 1 + * [1, 2] + * nil * */ @@ -3164,14 +2405,14 @@ each_slice_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, m)) rb_ary_push(ary, i); if (RARRAY_LEN(ary) == size) { - v = rb_yield(ary); + v = rb_yield(ary); - if (memo->v2) { - MEMO_V1_SET(memo, rb_ary_new2(size)); - } - else { - rb_ary_clear(ary); - } + if (memo->v2) { + MEMO_V1_SET(memo, rb_ary_new2(size)); + } + else { + rb_ary_clear(ary); + } } return v; @@ -3182,15 +2423,10 @@ enum_each_slice_size(VALUE obj, VALUE args, VALUE eobj) { VALUE n, size; long slice_size = NUM2LONG(RARRAY_AREF(args, 0)); - ID infinite_p; - CONST_ID(infinite_p, "infinite?"); if (slice_size <= 0) rb_raise(rb_eArgError, "invalid slice size"); size = enum_size(obj, 0, 0); - if (NIL_P(size)) return Qnil; - if (RB_FLOAT_TYPE_P(size) && RTEST(rb_funcall(size, infinite_p, 0))) { - return size; - } + if (size == Qnil) return Qnil; n = add_int(size, slice_size-1); return div_int(n, slice_size); @@ -3198,22 +2434,18 @@ enum_each_slice_size(VALUE obj, VALUE args, VALUE eobj) /* * call-seq: - * each_slice(n) { ... } -> self - * each_slice(n) -> enumerator - * - * Calls the block with each successive disjoint +n+-tuple of elements; - * returns +self+: + * enum.each_slice(n) { ... } -> nil + * enum.each_slice(n) -> an_enumerator * - * a = [] - * (1..10).each_slice(3) {|tuple| a.push(tuple) } - * a # => [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]] + * Iterates the given block for each slice of <n> elements. If no + * block is given, returns an enumerator. * - * a = [] - * h = {foo: 0, bar: 1, baz: 2, bat: 3, bam: 4} - * h.each_slice(2) {|tuple| a.push(tuple) } - * a # => [[[:foo, 0], [:bar, 1]], [[:baz, 2], [:bat, 3]], [[:bam, 4]]] - * - * With no block given, returns an Enumerator. + * (1..10).each_slice(3) { |a| p a } + * # outputs below + * [1, 2, 3] + * [4, 5, 6] + * [7, 8, 9] + * [10] * */ static VALUE @@ -3234,7 +2466,7 @@ enum_each_slice(VALUE obj, VALUE n) ary = memo->v1; if (RARRAY_LEN(ary) > 0) rb_yield(ary); - return obj; + return Qnil; } static VALUE @@ -3247,14 +2479,14 @@ each_cons_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args)) ENUM_WANT_SVALUE(); if (RARRAY_LEN(ary) == size) { - rb_ary_shift(ary); + rb_ary_shift(ary); } rb_ary_push(ary, i); if (RARRAY_LEN(ary) == size) { - if (memo->v2) { - ary = rb_ary_dup(ary); - } - v = rb_yield(ary); + if (memo->v2) { + ary = rb_ary_dup(ary); + } + v = rb_yield(ary); } return v; } @@ -3262,36 +2494,38 @@ each_cons_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args)) static VALUE enum_each_cons_size(VALUE obj, VALUE args, VALUE eobj) { + struct cmp_opt_data cmp_opt = { 0, 0 }; const VALUE zero = LONG2FIX(0); VALUE n, size; long cons_size = NUM2LONG(RARRAY_AREF(args, 0)); if (cons_size <= 0) rb_raise(rb_eArgError, "invalid size"); size = enum_size(obj, 0, 0); - if (NIL_P(size)) return Qnil; + if (size == Qnil) return Qnil; n = add_int(size, 1 - cons_size); - return (OPTIMIZED_CMP(n, zero) == -1) ? zero : n; + return (OPTIMIZED_CMP(n, zero, cmp_opt) == -1) ? zero : n; } /* * call-seq: - * each_cons(n) { ... } -> self - * each_cons(n) -> enumerator - * - * Calls the block with each successive overlapped +n+-tuple of elements; - * returns +self+: - * - * a = [] - * (1..5).each_cons(3) {|element| a.push(element) } - * a # => [[1, 2, 3], [2, 3, 4], [3, 4, 5]] - * - * a = [] - * h = {foo: 0, bar: 1, baz: 2, bam: 3} - * h.each_cons(2) {|element| a.push(element) } - * a # => [[[:foo, 0], [:bar, 1]], [[:bar, 1], [:baz, 2]], [[:baz, 2], [:bam, 3]]] - * - * With no block given, returns an Enumerator. + * enum.each_cons(n) { ... } -> nil + * enum.each_cons(n) -> an_enumerator + * + * Iterates the given block for each array of consecutive <n> + * elements. If no block is given, returns an enumerator. + * + * e.g.: + * (1..10).each_cons(3) { |a| p a } + * # outputs below + * [1, 2, 3] + * [2, 3, 4] + * [3, 4, 5] + * [4, 5, 6] + * [5, 6, 7] + * [6, 7, 8] + * [7, 8, 9] + * [8, 9, 10] * */ static VALUE @@ -3304,11 +2538,11 @@ enum_each_cons(VALUE obj, VALUE n) if (size <= 0) rb_raise(rb_eArgError, "invalid size"); RETURN_SIZED_ENUMERATOR(obj, 1, &n, enum_each_cons_size); arity = rb_block_arity(); - if (enum_size_over_p(obj, size)) return obj; + if (enum_size_over_p(obj, size)) return Qnil; memo = MEMO_NEW(rb_ary_new2(size), dont_recycle_block_arg(arity), size); rb_block_call(obj, id_each, 0, 0, each_cons_i, (VALUE)memo); - return obj; + return Qnil; } static VALUE @@ -3320,19 +2554,16 @@ each_with_object_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memo)) /* * call-seq: - * each_with_object(object) { |(*args), memo_object| ... } -> object - * each_with_object(object) -> enumerator + * enum.each_with_object(obj) { |(*args), memo_obj| ... } -> obj + * enum.each_with_object(obj) -> an_enumerator * - * Calls the block once for each element, passing both the element - * and the given object: + * Iterates the given block for each element with an arbitrary + * object given, and returns the initially given object. * - * (1..4).each_with_object([]) {|i, a| a.push(i**2) } - * # => [1, 4, 9, 16] + * If no block is given, returns an enumerator. * - * {foo: 0, bar: 1, baz: 2}.each_with_object({}) {|(k, v), h| h[v] = k } - * # => {0=>:foo, 1=>:bar, 2=>:baz} - * - * With no block given, returns an Enumerator. + * evens = (1..10).each_with_object([]) { |i, a| a << i*2 } + * #=> [2, 4, 6, 8, 10, 12, 14, 16, 18, 20] * */ static VALUE @@ -3358,20 +2589,20 @@ zip_ary(RB_BLOCK_CALL_FUNC_ARGLIST(val, memoval)) tmp = rb_ary_new2(RARRAY_LEN(args) + 1); rb_ary_store(tmp, 0, rb_enum_values_pack(argc, argv)); for (i=0; i<RARRAY_LEN(args); i++) { - VALUE e = RARRAY_AREF(args, i); + VALUE e = RARRAY_AREF(args, i); - if (RARRAY_LEN(e) <= n) { - rb_ary_push(tmp, Qnil); - } - else { - rb_ary_push(tmp, RARRAY_AREF(e, n)); - } + if (RARRAY_LEN(e) <= n) { + rb_ary_push(tmp, Qnil); + } + else { + rb_ary_push(tmp, RARRAY_AREF(e, n)); + } } if (NIL_P(result)) { - enum_yield_array(tmp); + enum_yield_array(tmp); } else { - rb_ary_push(result, tmp); + rb_ary_push(result, tmp); } RB_GC_GUARD(args); @@ -3380,16 +2611,14 @@ zip_ary(RB_BLOCK_CALL_FUNC_ARGLIST(val, memoval)) } static VALUE -call_next(VALUE w) +call_next(VALUE *v) { - VALUE *v = (VALUE *)w; return v[0] = rb_funcallv(v[1], id_next, 0, 0); } static VALUE -call_stop(VALUE w, VALUE _) +call_stop(VALUE *v) { - VALUE *v = (VALUE *)w; return v[0] = Qundef; } @@ -3405,26 +2634,26 @@ zip_i(RB_BLOCK_CALL_FUNC_ARGLIST(val, memoval)) tmp = rb_ary_new2(RARRAY_LEN(args) + 1); rb_ary_store(tmp, 0, rb_enum_values_pack(argc, argv)); for (i=0; i<RARRAY_LEN(args); i++) { - if (NIL_P(RARRAY_AREF(args, i))) { - rb_ary_push(tmp, Qnil); - } - else { - VALUE v[2]; - - v[1] = RARRAY_AREF(args, i); - rb_rescue2(call_next, (VALUE)v, call_stop, (VALUE)v, rb_eStopIteration, (VALUE)0); - if (UNDEF_P(v[0])) { - RARRAY_ASET(args, i, Qnil); - v[0] = Qnil; - } - rb_ary_push(tmp, v[0]); - } + if (NIL_P(RARRAY_AREF(args, i))) { + rb_ary_push(tmp, Qnil); + } + else { + VALUE v[2]; + + v[1] = RARRAY_AREF(args, i); + rb_rescue2(call_next, (VALUE)v, call_stop, (VALUE)v, rb_eStopIteration, (VALUE)0); + if (v[0] == Qundef) { + RARRAY_ASET(args, i, Qnil); + v[0] = Qnil; + } + rb_ary_push(tmp, v[0]); + } } if (NIL_P(result)) { - enum_yield_array(tmp); + enum_yield_array(tmp); } else { - rb_ary_push(result, tmp); + rb_ary_push(result, tmp); } RB_GC_GUARD(args); @@ -3434,68 +2663,29 @@ zip_i(RB_BLOCK_CALL_FUNC_ARGLIST(val, memoval)) /* * call-seq: - * zip(*other_enums) -> array - * zip(*other_enums) {|array| ... } -> nil - * - * With no block given, returns a new array +new_array+ of size self.size - * whose elements are arrays. - * Each nested array <tt>new_array[n]</tt> - * is of size <tt>other_enums.size+1</tt>, and contains: - * - * - The +n+-th element of self. - * - The +n+-th element of each of the +other_enums+. - * - * If all +other_enums+ and self are the same size, - * all elements are included in the result, and there is no +nil+-filling: - * - * a = [:a0, :a1, :a2, :a3] - * b = [:b0, :b1, :b2, :b3] - * c = [:c0, :c1, :c2, :c3] - * d = a.zip(b, c) - * d # => [[:a0, :b0, :c0], [:a1, :b1, :c1], [:a2, :b2, :c2], [:a3, :b3, :c3]] - * - * f = {foo: 0, bar: 1, baz: 2} - * g = {goo: 3, gar: 4, gaz: 5} - * h = {hoo: 6, har: 7, haz: 8} - * d = f.zip(g, h) - * d # => [ - * # [[:foo, 0], [:goo, 3], [:hoo, 6]], - * # [[:bar, 1], [:gar, 4], [:har, 7]], - * # [[:baz, 2], [:gaz, 5], [:haz, 8]] - * # ] - * - * If any enumerable in other_enums is smaller than self, - * fills to <tt>self.size</tt> with +nil+: - * - * a = [:a0, :a1, :a2, :a3] - * b = [:b0, :b1, :b2] - * c = [:c0, :c1] - * d = a.zip(b, c) - * d # => [[:a0, :b0, :c0], [:a1, :b1, :c1], [:a2, :b2, nil], [:a3, nil, nil]] - * - * If any enumerable in other_enums is larger than self, - * its trailing elements are ignored: - * - * a = [:a0, :a1, :a2, :a3] - * b = [:b0, :b1, :b2, :b3, :b4] - * c = [:c0, :c1, :c2, :c3, :c4, :c5] - * d = a.zip(b, c) - * d # => [[:a0, :b0, :c0], [:a1, :b1, :c1], [:a2, :b2, :c2], [:a3, :b3, :c3]] - * - * When a block is given, calls the block with each of the sub-arrays - * (formed as above); returns nil: - * - * a = [:a0, :a1, :a2, :a3] - * b = [:b0, :b1, :b2, :b3] - * c = [:c0, :c1, :c2, :c3] - * a.zip(b, c) {|sub_array| p sub_array} # => nil - * - * Output: - * - * [:a0, :b0, :c0] - * [:a1, :b1, :c1] - * [:a2, :b2, :c2] - * [:a3, :b3, :c3] + * enum.zip(arg, ...) -> an_array_of_array + * enum.zip(arg, ...) { |arr| block } -> nil + * + * Takes one element from <i>enum</i> and merges corresponding + * elements from each <i>args</i>. This generates a sequence of + * <em>n</em>-element arrays, where <em>n</em> is one more than the + * count of arguments. The length of the resulting sequence will be + * <code>enum#size</code>. If the size of any argument is less than + * <code>enum#size</code>, <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 ] + * + * a.zip(b) #=> [[4, 7], [5, 8], [6, 9]] + * [1, 2, 3].zip(a, b) #=> [[1, 4, 7], [2, 5, 8], [3, 6, 9]] + * [1, 2].zip(a, b) #=> [[1, 4, 7], [2, 5, 8]] + * a.zip([1, 2], [8]) #=> [[4, 1, 8], [5, 2, nil], [6, nil, nil]] + * + * c = [] + * a.zip(b) { |x, y| c << x + y } #=> nil + * c #=> [11, 13, 15] * */ @@ -3511,26 +2701,26 @@ enum_zip(int argc, VALUE *argv, VALUE obj) argv = RARRAY_PTR(args); for (i=0; i<argc; i++) { - VALUE ary = rb_check_array_type(argv[i]); - if (NIL_P(ary)) { - allary = FALSE; - break; - } - argv[i] = ary; + VALUE ary = rb_check_array_type(argv[i]); + if (NIL_P(ary)) { + allary = FALSE; + break; + } + argv[i] = ary; } if (!allary) { - static const VALUE sym_each = STATIC_ID2SYM(id_each); - CONST_ID(conv, "to_enum"); - for (i=0; i<argc; i++) { - if (!rb_respond_to(argv[i], id_each)) { - rb_raise(rb_eTypeError, "wrong argument type %"PRIsVALUE" (must respond to :each)", - rb_obj_class(argv[i])); + static const VALUE sym_each = STATIC_ID2SYM(id_each); + CONST_ID(conv, "to_enum"); + for (i=0; i<argc; i++) { + if (!rb_respond_to(argv[i], id_each)) { + rb_raise(rb_eTypeError, "wrong argument type %"PRIsVALUE" (must respond to :each)", + rb_obj_class(argv[i])); } - argv[i] = rb_funcallv(argv[i], conv, 1, &sym_each); - } + argv[i] = rb_funcallv(argv[i], conv, 1, &sym_each); + } } if (!rb_block_given_p()) { - result = rb_ary_new(); + result = rb_ary_new(); } /* TODO: use NODE_DOT2 as memo(v, v, -) */ @@ -3551,16 +2741,13 @@ take_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args)) /* * call-seq: - * take(n) -> array - * - * For non-negative integer +n+, returns the first +n+ elements: + * enum.take(n) -> array * - * r = (1..4) - * r.take(2) # => [1, 2] - * r.take(0) # => [] + * Returns first n elements from <i>enum</i>. * - * h = {foo: 0, bar: 1, baz: 2, bat: 3} - * h.take(2) # => [[:foo, 0], [:bar, 1]] + * a = [1, 2, 3, 4, 5, 0] + * a.take(3) #=> [1, 2, 3] + * a.take(30) #=> [1, 2, 3, 4, 5, 0] * */ @@ -3572,7 +2759,7 @@ enum_take(VALUE obj, VALUE n) long len = NUM2LONG(n); if (len < 0) { - rb_raise(rb_eArgError, "attempt to take negative size"); + rb_raise(rb_eArgError, "attempt to take negative size"); } if (len == 0) return rb_ary_new2(0); @@ -3593,20 +2780,16 @@ take_while_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary)) /* * call-seq: - * take_while {|element| ... } -> array - * take_while -> enumerator - * - * Calls the block with successive elements as long as the block - * returns a truthy value; - * returns an array of all elements up to that point: + * enum.take_while { |obj| block } -> array + * enum.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. * - * (1..4).take_while{|i| i < 3 } # => [1, 2] - * h = {foo: 0, bar: 1, baz: 2} - * h.take_while{|element| key, value = *element; value < 2 } - * # => [[:foo, 0], [:bar, 1]] + * If no block is given, an enumerator is returned instead. * - * With no block given, returns an Enumerator. + * a = [1, 2, 3, 4, 5, 0] + * a.take_while { |i| i < 3 } #=> [1, 2] * */ @@ -3626,30 +2809,23 @@ drop_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args)) { struct MEMO *memo = MEMO_CAST(args); if (memo->u3.cnt == 0) { - rb_ary_push(memo->v1, rb_enum_values_pack(argc, argv)); + rb_ary_push(memo->v1, rb_enum_values_pack(argc, argv)); } else { - memo->u3.cnt--; + memo->u3.cnt--; } return Qnil; } /* * call-seq: - * drop(n) -> array + * enum.drop(n) -> array * - * For positive integer +n+, returns an array containing - * all but the first +n+ elements: + * Drops first n elements from <i>enum</i>, and returns rest elements + * in an array. * - * r = (1..4) - * r.drop(3) # => [4] - * r.drop(2) # => [3, 4] - * r.drop(1) # => [2, 3, 4] - * r.drop(0) # => [1, 2, 3, 4] - * r.drop(50) # => [] - * - * h = {foo: 0, bar: 1, baz: 2, bat: 3} - * h.drop(2) # => [[:baz, 2], [:bat, 3]] + * a = [1, 2, 3, 4, 5, 0] + * a.drop(3) #=> [4, 5, 0] * */ @@ -3661,7 +2837,7 @@ enum_drop(VALUE obj, VALUE n) long len = NUM2LONG(n); if (len < 0) { - rb_raise(rb_eArgError, "attempt to drop negative size"); + rb_raise(rb_eArgError, "attempt to drop negative size"); } result = rb_ary_new(); @@ -3678,30 +2854,27 @@ drop_while_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args)) ENUM_WANT_SVALUE(); if (!memo->u3.state && !RTEST(enum_yield(argc, i))) { - memo->u3.state = TRUE; + memo->u3.state = TRUE; } if (memo->u3.state) { - rb_ary_push(memo->v1, i); + rb_ary_push(memo->v1, i); } return Qnil; } /* * call-seq: - * drop_while {|element| ... } -> array - * drop_while -> enumerator - * - * Calls the block with successive elements as long as the block - * returns a truthy value; - * returns an array of all elements after that point: + * enum.drop_while { |obj| block } -> array + * enum.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 + * containing the remaining elements. * - * (1..4).drop_while{|i| i < 3 } # => [3, 4] - * h = {foo: 0, bar: 1, baz: 2} - * a = h.drop_while{|element| key, value = *element; value < 2 } - * a # => [[:baz, 2]] + * If no block is given, an enumerator is returned instead. * - * With no block given, returns an Enumerator. + * a = [1, 2, 3, 4, 5, 0] + * a.drop_while { |i| i < 3 } #=> [3, 4, 5, 0] * */ @@ -3736,14 +2909,14 @@ enum_cycle_size(VALUE self, VALUE args, VALUE eobj) VALUE size; if (args && (RARRAY_LEN(args) > 0)) { - n = RARRAY_AREF(args, 0); - if (!NIL_P(n)) mul = NUM2LONG(n); + n = RARRAY_AREF(args, 0); + if (!NIL_P(n)) mul = NUM2LONG(n); } size = enum_size(self, args, 0); if (NIL_P(size) || FIXNUM_ZERO_P(size)) return size; - if (NIL_P(n)) return DBL2NUM(HUGE_VAL); + if (NIL_P(n)) return DBL2NUM(INFINITY); if (mul <= 0) return INT2FIX(0); n = LONG2FIX(mul); return rb_funcallv(size, '*', 1, &n); @@ -3751,28 +2924,22 @@ enum_cycle_size(VALUE self, VALUE args, VALUE eobj) /* * call-seq: - * cycle(n = nil) {|element| ...} -> nil - * cycle(n = nil) -> enumerator + * enum.cycle(n=nil) { |obj| block } -> nil + * enum.cycle(n=nil) -> an_enumerator * - * When called with positive integer argument +n+ and a block, - * calls the block with each element, then does so again, - * until it has done so +n+ times; returns +nil+: + * Calls <i>block</i> for each element of <i>enum</i> repeatedly _n_ + * times or forever if none or +nil+ is given. If a non-positive + * number is given or the collection is empty, does nothing. Returns + * +nil+ if the loop has finished without getting interrupted. * - * a = [] - * (1..4).cycle(3) {|element| a.push(element) } # => nil - * a # => [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4] - * a = [] - * ('a'..'d').cycle(2) {|element| a.push(element) } - * a # => ["a", "b", "c", "d", "a", "b", "c", "d"] - * a = [] - * {foo: 0, bar: 1, baz: 2}.cycle(2) {|element| a.push(element) } - * a # => [[:foo, 0], [:bar, 1], [:baz, 2], [:foo, 0], [:bar, 1], [:baz, 2]] + * Enumerable#cycle saves elements in an internal array so changes + * to <i>enum</i> after the first pass have no effect. * - * If count is zero or negative, does not call the block. + * If no block is given, an enumerator is returned instead. * - * When called with a block and +n+ is +nil+, cycles forever. - * - * When no block is given, returns an Enumerator. + * 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. * */ @@ -3783,10 +2950,10 @@ enum_cycle(int argc, VALUE *argv, VALUE obj) VALUE nv = Qnil; long n, i, len; - rb_check_arity(argc, 0, 1); + rb_scan_args(argc, argv, "01", &nv); RETURN_SIZED_ENUMERATOR(obj, argc, argv, enum_cycle_size); - if (!argc || NIL_P(nv = argv[0])) { + if (NIL_P(nv)) { n = -1; } else { @@ -3800,7 +2967,7 @@ enum_cycle(int argc, VALUE *argv, VALUE obj) if (len == 0) return Qnil; while (n < 0 || 0 < --n) { for (i=0; i<len; i++) { - enum_yield_array(RARRAY_AREF(ary, i)); + enum_yield_array(RARRAY_AREF(ary, i)); } } return Qnil; @@ -3818,8 +2985,8 @@ chunk_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, _argp)) { struct chunk_arg *argp = MEMO_FOR(struct chunk_arg, _argp); VALUE v, s; - VALUE alone = ID2SYM(id__alone); - VALUE separator = ID2SYM(id__separator); + VALUE alone = ID2SYM(rb_intern("_alone")); + VALUE separator = ID2SYM(rb_intern("_separator")); ENUM_WANT_SVALUE(); @@ -3827,22 +2994,22 @@ chunk_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, _argp)) if (v == alone) { if (!NIL_P(argp->prev_value)) { - s = rb_assoc_new(argp->prev_value, argp->prev_elts); + s = rb_assoc_new(argp->prev_value, argp->prev_elts); rb_funcallv(argp->yielder, id_lshift, 1, &s); argp->prev_value = argp->prev_elts = Qnil; } - v = rb_assoc_new(v, rb_ary_new3(1, i)); + v = rb_assoc_new(v, rb_ary_new3(1, i)); rb_funcallv(argp->yielder, id_lshift, 1, &v); } else if (NIL_P(v) || v == separator) { if (!NIL_P(argp->prev_value)) { - v = rb_assoc_new(argp->prev_value, argp->prev_elts); + v = rb_assoc_new(argp->prev_value, argp->prev_elts); rb_funcallv(argp->yielder, id_lshift, 1, &v); argp->prev_value = argp->prev_elts = Qnil; } } else if (SYMBOL_P(v) && (s = rb_sym2str(v), RSTRING_PTR(s)[0] == '_')) { - rb_raise(rb_eRuntimeError, "symbols beginning with an underscore are reserved"); + rb_raise(rb_eRuntimeError, "symbols beginning with an underscore are reserved"); } else { if (NIL_P(argp->prev_value)) { @@ -3854,7 +3021,7 @@ chunk_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, _argp)) rb_ary_push(argp->prev_elts, i); } else { - s = rb_assoc_new(argp->prev_value, argp->prev_elts); + s = rb_assoc_new(argp->prev_value, argp->prev_elts); rb_funcallv(argp->yielder, id_lshift, 1, &s); argp->prev_value = v; argp->prev_elts = rb_ary_new3(1, i); @@ -3871,8 +3038,8 @@ chunk_i(RB_BLOCK_CALL_FUNC_ARGLIST(yielder, enumerator)) VALUE arg; struct chunk_arg *memo = NEW_MEMO_FOR(struct chunk_arg, arg); - enumerable = rb_ivar_get(enumerator, id_chunk_enumerable); - memo->categorize = rb_ivar_get(enumerator, id_chunk_categorize); + enumerable = rb_ivar_get(enumerator, rb_intern("chunk_enumerable")); + memo->categorize = rb_ivar_get(enumerator, rb_intern("chunk_categorize")); memo->prev_value = Qnil; memo->prev_elts = Qnil; memo->yielder = yielder; @@ -3880,86 +3047,58 @@ chunk_i(RB_BLOCK_CALL_FUNC_ARGLIST(yielder, enumerator)) rb_block_call(enumerable, id_each, 0, 0, chunk_ii, arg); memo = MEMO_FOR(struct chunk_arg, arg); if (!NIL_P(memo->prev_elts)) { - arg = rb_assoc_new(memo->prev_value, memo->prev_elts); - rb_funcallv(memo->yielder, id_lshift, 1, &arg); + arg = rb_assoc_new(memo->prev_value, memo->prev_elts); + rb_funcallv(memo->yielder, id_lshift, 1, &arg); } return Qnil; } /* * call-seq: - * chunk {|array| ... } -> enumerator - * - * Each element in the returned enumerator is a 2-element array consisting of: - * - * - A value returned by the block. - * - An array ("chunk") containing the element for which that value was returned, - * and all following elements for which the block returned the same value: + * enum.chunk { |elt| ... } -> an_enumerator * - * So that: + * Enumerates over the items, chunking them together based on the return + * value of the block. * - * - Each block return value that is different from its predecessor - * begins a new chunk. - * - Each block return value that is the same as its predecessor - * continues the same chunk. + * Consecutive elements which return the same block value are chunked together. * - * Example: + * For example, consecutive even numbers and odd numbers can be + * chunked as follows. * - * e = (0..10).chunk {|i| (i / 3).floor } # => #<Enumerator: ...> - * # The enumerator elements. - * e.next # => [0, [0, 1, 2]] - * e.next # => [1, [3, 4, 5]] - * e.next # => [2, [6, 7, 8]] - * e.next # => [3, [9, 10]] - * - * \Method +chunk+ is especially useful for an enumerable that is already sorted. - * This example counts words for each initial letter in a large array of words: - * - * # Get sorted words from a web page. - * url = 'https://raw.githubusercontent.com/eneko/data-repository/master/data/words.txt' - * words = URI::open(url).readlines - * # Make chunks, one for each letter. - * e = words.chunk {|word| word.upcase[0] } # => #<Enumerator: ...> - * # Display 'A' through 'F'. - * e.each {|c, words| p [c, words.length]; break if c == 'F' } - * - * Output: - * - * ["A", 17096] - * ["B", 11070] - * ["C", 19901] - * ["D", 10896] - * ["E", 8736] - * ["F", 6860] - * - * You can use the special symbol <tt>:_alone</tt> to force an element - * into its own separate chuck: - * - * a = [0, 0, 1, 1] - * e = a.chunk{|i| i.even? ? :_alone : true } - * e.to_a # => [[:_alone, [0]], [:_alone, [0]], [true, [1, 1]]] + * [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5].chunk { |n| + * n.even? + * }.each { |even, ary| + * p [even, ary] + * } + * #=> [false, [3, 1]] + * # [true, [4]] + * # [false, [1, 5, 9]] + * # [true, [2, 6]] + * # [false, [5, 3, 5]] * - * For example, you can put each line that contains a URL into its own chunk: + * This method is especially useful for sorted series of elements. + * The following example counts words for each initial letter. * - * pattern = /http/ - * open(filename) { |f| - * f.chunk { |line| line =~ pattern ? :_alone : true }.each { |key, lines| - * pp lines - * } + * open("/usr/share/dict/words", "r:iso-8859-1") { |f| + * f.chunk { |line| line.ord }.each { |ch, lines| p [ch.chr, lines.length] } * } + * #=> ["\n", 1] + * # ["A", 1327] + * # ["B", 1372] + * # ["C", 1507] + * # ["D", 791] + * # ... * - * You can use the special symbol <tt>:_separator</tt> or +nil+ - * to force an element to be ignored (not included in any chunk): + * The following key values have special meaning: + * - +nil+ and +:_separator+ specifies that the elements should be dropped. + * - +:_alone+ specifies that the element should be chunked by itself. * - * a = [0, 0, -1, 1, 1] - * e = a.chunk{|i| i < 0 ? :_separator : true } - * e.to_a # => [[true, [0, 0]], [true, [1, 1]]] + * Any other symbols that begin with an underscore will raise an error: * - * Note that the separator does end the chunk: + * items.chunk { |item| :_underscore } + * #=> RuntimeError: symbols beginning with an underscore are reserved * - * a = [0, 0, -1, 1, -1, 1] - * e = a.chunk{|i| i < 0 ? :_separator : true } - * e.to_a # => [[true, [0, 0]], [true, [1]], [true, [1]]] + * +nil+ and +:_separator+ can be used to ignore some elements. * * For example, the sequence of hyphens in svn log can be eliminated as follows: * @@ -3989,6 +3128,18 @@ chunk_i(RB_BLOCK_CALL_FUNC_ARGLIST(yielder, enumerator)) * pp lines * } * + * +:_alone+ can be used to force items into their own chunk. + * For example, you can put lines that contain a URL by themselves, + * and chunk the rest of the lines together, like this: + * + * pattern = /http/ + * open(filename) { |f| + * f.chunk { |line| line =~ pattern ? :_alone : true }.each { |key, lines| + * pp lines + * } + * } + * + * If no block is given, an enumerator to `chunk` is returned instead. */ static VALUE enum_chunk(VALUE enumerable) @@ -3998,8 +3149,8 @@ enum_chunk(VALUE enumerable) RETURN_SIZED_ENUMERATOR(enumerable, 0, 0, enum_size); enumerator = rb_obj_alloc(rb_cEnumerator); - rb_ivar_set(enumerator, id_chunk_enumerable, enumerable); - rb_ivar_set(enumerator, id_chunk_categorize, rb_block_proc()); + rb_ivar_set(enumerator, rb_intern("chunk_enumerable"), enumerable); + rb_ivar_set(enumerator, rb_intern("chunk_categorize"), rb_block_proc()); rb_block_call(enumerator, idInitialize, 0, 0, chunk_i, enumerator); return enumerator; } @@ -4046,9 +3197,9 @@ slicebefore_i(RB_BLOCK_CALL_FUNC_ARGLIST(yielder, enumerator)) VALUE arg; struct slicebefore_arg *memo = NEW_MEMO_FOR(struct slicebefore_arg, arg); - enumerable = rb_ivar_get(enumerator, id_slicebefore_enumerable); - memo->sep_pred = rb_attr_get(enumerator, id_slicebefore_sep_pred); - memo->sep_pat = NIL_P(memo->sep_pred) ? rb_ivar_get(enumerator, id_slicebefore_sep_pat) : Qnil; + enumerable = rb_ivar_get(enumerator, rb_intern("slicebefore_enumerable")); + memo->sep_pred = rb_attr_get(enumerator, rb_intern("slicebefore_sep_pred")); + memo->sep_pat = NIL_P(memo->sep_pred) ? rb_ivar_get(enumerator, rb_intern("slicebefore_sep_pat")) : Qnil; memo->prev_elts = Qnil; memo->yielder = yielder; @@ -4061,41 +3212,24 @@ slicebefore_i(RB_BLOCK_CALL_FUNC_ARGLIST(yielder, enumerator)) /* * call-seq: - * slice_before(pattern) -> enumerator - * slice_before {|elt| ... } -> enumerator - * - * With argument +pattern+, returns an enumerator that uses the pattern - * to partition elements into arrays ("slices"). - * An element begins a new slice if <tt>element === pattern</tt> - * (or if it is the first element). - * - * a = %w[foo bar fop for baz fob fog bam foy] - * e = a.slice_before(/ba/) # => #<Enumerator: ...> - * e.each {|array| p array } - * - * Output: - * - * ["foo"] - * ["bar", "fop", "for"] - * ["baz", "fob", "fog"] - * ["bam", "foy"] + * enum.slice_before(pattern) -> an_enumerator + * enum.slice_before { |elt| bool } -> an_enumerator * - * With a block, returns an enumerator that uses the block - * to partition elements into arrays. - * An element begins a new slice if its block return is a truthy value - * (or if it is the first element): - * - * e = (1..20).slice_before {|i| i % 4 == 2 } # => #<Enumerator: ...> - * e.each {|array| p array } - * - * Output: + * Creates an enumerator for each chunked elements. + * The beginnings of chunks are defined by _pattern_ and the block. + + * If <code>_pattern_ === _elt_</code> returns <code>true</code> or the block + * returns <code>true</code> for the element, the element is beginning of a + * chunk. + + * The <code>===</code> and _block_ is called from the first element to the last + * element of _enum_. The result for the first element is ignored. + + * The result enumerator yields the chunked elements as an array. + * So +each+ method can be called as follows: * - * [1] - * [2, 3, 4, 5] - * [6, 7, 8, 9] - * [10, 11, 12, 13] - * [14, 15, 16, 17] - * [18, 19, 20] + * enum.slice_before(pattern).each { |ary| ... } + * enum.slice_before { |elt| bool }.each { |ary| ... } * * Other methods of the Enumerator class and Enumerable module, * such as +to_a+, +map+, etc., are also usable. @@ -4113,6 +3247,7 @@ slicebefore_i(RB_BLOCK_CALL_FUNC_ARGLIST(yielder, enumerator)) * f.slice_before { |line| /\A\S/ === line }.each { |e| pp e } * } * + * * "svn proplist -R" produces multiline output for each file. * They can be chunked as follows: * @@ -4228,15 +3363,15 @@ enum_slice_before(int argc, VALUE *argv, VALUE enumerable) if (argc != 0) rb_error_arity(argc, 0, 0); enumerator = rb_obj_alloc(rb_cEnumerator); - rb_ivar_set(enumerator, id_slicebefore_sep_pred, rb_block_proc()); + rb_ivar_set(enumerator, rb_intern("slicebefore_sep_pred"), rb_block_proc()); } else { VALUE sep_pat; rb_scan_args(argc, argv, "1", &sep_pat); enumerator = rb_obj_alloc(rb_cEnumerator); - rb_ivar_set(enumerator, id_slicebefore_sep_pat, sep_pat); + rb_ivar_set(enumerator, rb_intern("slicebefore_sep_pat"), sep_pat); } - rb_ivar_set(enumerator, id_slicebefore_enumerable, enumerable); + rb_ivar_set(enumerator, rb_intern("slicebefore_enumerable"), enumerable); rb_block_call(enumerator, idInitialize, 0, 0, slicebefore_i, enumerator); return enumerator; } @@ -4292,9 +3427,9 @@ sliceafter_i(RB_BLOCK_CALL_FUNC_ARGLIST(yielder, enumerator)) VALUE arg; struct sliceafter_arg *memo = NEW_MEMO_FOR(struct sliceafter_arg, arg); - enumerable = rb_ivar_get(enumerator, id_sliceafter_enum); - memo->pat = rb_ivar_get(enumerator, id_sliceafter_pat); - memo->pred = rb_attr_get(enumerator, id_sliceafter_pred); + enumerable = rb_ivar_get(enumerator, rb_intern("sliceafter_enum")); + memo->pat = rb_ivar_get(enumerator, rb_intern("sliceafter_pat")); + memo->pred = rb_attr_get(enumerator, rb_intern("sliceafter_pred")); memo->prev_elts = Qnil; memo->yielder = yielder; @@ -4357,9 +3492,9 @@ enum_slice_after(int argc, VALUE *argv, VALUE enumerable) } enumerator = rb_obj_alloc(rb_cEnumerator); - rb_ivar_set(enumerator, id_sliceafter_enum, enumerable); - rb_ivar_set(enumerator, id_sliceafter_pat, pat); - rb_ivar_set(enumerator, id_sliceafter_pred, pred); + rb_ivar_set(enumerator, rb_intern("sliceafter_enum"), enumerable); + rb_ivar_set(enumerator, rb_intern("sliceafter_pat"), pat); + rb_ivar_set(enumerator, rb_intern("sliceafter_pred"), pred); rb_block_call(enumerator, idInitialize, 0, 0, sliceafter_i, enumerator); return enumerator; @@ -4383,15 +3518,15 @@ slicewhen_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, _memo)) ENUM_WANT_SVALUE(); - if (UNDEF_P(memo->prev_elt)) { + if (memo->prev_elt == Qundef) { /* The first element */ memo->prev_elt = i; memo->prev_elts = rb_ary_new3(1, i); } else { - VALUE args[2]; - args[0] = memo->prev_elt; - args[1] = i; + VALUE args[2]; + args[0] = memo->prev_elt; + args[1] = i; split_p = RTEST(rb_funcallv(memo->pred, id_call, 2, args)); UPDATE_MEMO; @@ -4420,14 +3555,14 @@ slicewhen_i(RB_BLOCK_CALL_FUNC_ARGLIST(yielder, enumerator)) VALUE enumerable; VALUE arg; struct slicewhen_arg *memo = - NEW_PARTIAL_MEMO_FOR(struct slicewhen_arg, arg, inverted); + NEW_PARTIAL_MEMO_FOR(struct slicewhen_arg, arg, inverted); - enumerable = rb_ivar_get(enumerator, id_slicewhen_enum); - memo->pred = rb_attr_get(enumerator, id_slicewhen_pred); + enumerable = rb_ivar_get(enumerator, rb_intern("slicewhen_enum")); + memo->pred = rb_attr_get(enumerator, rb_intern("slicewhen_pred")); memo->prev_elt = Qundef; memo->prev_elts = Qnil; memo->yielder = yielder; - memo->inverted = RTEST(rb_attr_get(enumerator, id_slicewhen_inverted)); + memo->inverted = RTEST(rb_attr_get(enumerator, rb_intern("slicewhen_inverted"))); rb_block_call(enumerable, id_each, 0, 0, slicewhen_ii, arg); memo = MEMO_FOR(struct slicewhen_arg, arg); @@ -4443,7 +3578,7 @@ slicewhen_i(RB_BLOCK_CALL_FUNC_ARGLIST(yielder, enumerator)) * Creates an enumerator for each chunked elements. * The beginnings of chunks are defined by the block. * - * This method splits each chunk using adjacent elements, + * This method split each chunk using adjacent elements, * _elt_before_ and _elt_after_, * in the receiver enumerator. * This method split chunks between _elt_before_ and _elt_after_ where @@ -4507,9 +3642,9 @@ enum_slice_when(VALUE enumerable) pred = rb_block_proc(); enumerator = rb_obj_alloc(rb_cEnumerator); - rb_ivar_set(enumerator, id_slicewhen_enum, enumerable); - rb_ivar_set(enumerator, id_slicewhen_pred, pred); - rb_ivar_set(enumerator, id_slicewhen_inverted, Qfalse); + rb_ivar_set(enumerator, rb_intern("slicewhen_enum"), enumerable); + rb_ivar_set(enumerator, rb_intern("slicewhen_pred"), pred); + rb_ivar_set(enumerator, rb_intern("slicewhen_inverted"), Qfalse); rb_block_call(enumerator, idInitialize, 0, 0, slicewhen_i, enumerator); return enumerator; @@ -4522,7 +3657,7 @@ enum_slice_when(VALUE enumerable) * Creates an enumerator for each chunked elements. * The beginnings of chunks are defined by the block. * - * This method splits each chunk using adjacent elements, + * This method split each chunk using adjacent elements, * _elt_before_ and _elt_after_, * in the receiver enumerator. * This method split chunks between _elt_before_ and _elt_after_ where @@ -4573,9 +3708,9 @@ enum_chunk_while(VALUE enumerable) pred = rb_block_proc(); enumerator = rb_obj_alloc(rb_cEnumerator); - rb_ivar_set(enumerator, id_slicewhen_enum, enumerable); - rb_ivar_set(enumerator, id_slicewhen_pred, pred); - rb_ivar_set(enumerator, id_slicewhen_inverted, Qtrue); + rb_ivar_set(enumerator, rb_intern("slicewhen_enum"), enumerable); + rb_ivar_set(enumerator, rb_intern("slicewhen_pred"), pred); + rb_ivar_set(enumerator, rb_intern("slicewhen_inverted"), Qtrue); rb_block_call(enumerator, idInitialize, 0, 0, slicewhen_i, enumerator); return enumerator; @@ -4590,141 +3725,122 @@ struct enum_sum_memo { }; static void -sum_iter_normalize_memo(struct enum_sum_memo *memo) -{ - RUBY_ASSERT(FIXABLE(memo->n)); - memo->v = rb_fix_plus(LONG2FIX(memo->n), memo->v); - memo->n = 0; - - switch (TYPE(memo->r)) { - case T_RATIONAL: memo->v = rb_rational_plus(memo->r, memo->v); break; - case T_UNDEF: break; - default: UNREACHABLE; /* or ...? */ - } - memo->r = Qundef; -} - -static void -sum_iter_fixnum(VALUE i, struct enum_sum_memo *memo) -{ - memo->n += FIX2LONG(i); /* should not overflow long type */ - if (! FIXABLE(memo->n)) { - memo->v = rb_big_plus(LONG2NUM(memo->n), memo->v); - memo->n = 0; - } -} - -static void -sum_iter_bignum(VALUE i, struct enum_sum_memo *memo) -{ - memo->v = rb_big_plus(i, memo->v); -} - -static void -sum_iter_rational(VALUE i, struct enum_sum_memo *memo) +sum_iter(VALUE i, struct enum_sum_memo *memo) { - if (UNDEF_P(memo->r)) { - memo->r = i; - } - else { - memo->r = rb_rational_plus(memo->r, i); - } -} + const int unused = (assert(memo != NULL), 0); -static void -sum_iter_some_value(VALUE i, struct enum_sum_memo *memo) -{ - memo->v = rb_funcallv(memo->v, idPLUS, 1, &i); -} + long n = memo->n; + VALUE v = memo->v; + VALUE r = memo->r; + double f = memo->f; + double c = memo->c; -static void -sum_iter_Kahan_Babuska(VALUE i, struct enum_sum_memo *memo) -{ - /* - * Kahan-Babuska balancing compensated summation algorithm - * See https://link.springer.com/article/10.1007/s00607-005-0139-x - */ - double x; - - switch (TYPE(i)) { - case T_FLOAT: x = RFLOAT_VALUE(i); break; - case T_FIXNUM: x = FIX2LONG(i); break; - case T_BIGNUM: x = rb_big2dbl(i); break; - case T_RATIONAL: x = rb_num2dbl(i); break; - default: - memo->v = DBL2NUM(memo->f); - memo->float_value = 0; - sum_iter_some_value(i, memo); - return; - } + if (memo->block_given) + i = rb_yield(i); - double f = memo->f; + if (memo->float_value) + goto float_value; - if (isnan(f)) { - return; - } - else if (! isfinite(x)) { - if (isinf(x) && isinf(f) && signbit(x) != signbit(f)) { - i = DBL2NUM(f); - x = nan(""); + if (FIXNUM_P(v) || RB_TYPE_P(v, T_BIGNUM) || RB_TYPE_P(v, T_RATIONAL)) { + if (FIXNUM_P(i)) { + n += FIX2LONG(i); /* should not overflow long type */ + if (!FIXABLE(n)) { + v = rb_big_plus(LONG2NUM(n), v); + n = 0; + } + } + else if (RB_TYPE_P(i, T_BIGNUM)) + v = rb_big_plus(i, v); + else if (RB_TYPE_P(i, T_RATIONAL)) { + if (r == Qundef) + r = i; + else + r = rb_rational_plus(r, i); + } + else { + if (n != 0) { + v = rb_fix_plus(LONG2FIX(n), v); + n = 0; + } + if (r != Qundef) { + /* r can be an Integer when mathn is loaded */ + if (FIXNUM_P(r)) + v = rb_fix_plus(r, v); + else if (RB_TYPE_P(r, T_BIGNUM)) + v = rb_big_plus(r, v); + else + v = rb_rational_plus(r, v); + r = Qundef; + } + if (RB_FLOAT_TYPE_P(i)) { + f = NUM2DBL(v); + c = 0.0; + memo->float_value = 1; + goto float_value; + } + else + goto some_value; } - memo->v = i; - memo->f = x; - return; - } - else if (isinf(f)) { - return; } + else if (RB_FLOAT_TYPE_P(v)) { + /* + * Kahan-Babuska balancing compensated summation algorithm + * See http://link.springer.com/article/10.1007/s00607-005-0139-x + */ + double x, t; + + float_value: + if (RB_FLOAT_TYPE_P(i)) + x = RFLOAT_VALUE(i); + else if (FIXNUM_P(i)) + x = FIX2LONG(i); + else if (RB_TYPE_P(i, T_BIGNUM)) + x = rb_big2dbl(i); + else if (RB_TYPE_P(i, T_RATIONAL)) + x = rb_num2dbl(i); + else { + v = DBL2NUM(f); + memo->float_value = 0; + goto some_value; + } - double c = memo->c; - double t = f + x; + if (isnan(f)) return; + if (isnan(x)) { + memo->v = i; + memo->f = x; + return; + } + if (isinf(x)) { + if (isinf(f) && signbit(x) != signbit(f)) { + memo->f = NAN; + memo->v = DBL2NUM(f); + } + else { + memo->f = x; + memo->v = i; + } + return; + } + if (isinf(f)) return; - if (fabs(f) >= fabs(x)) { - c += ((f - t) + x); + t = f + x; + if (fabs(f) >= fabs(x)) + c += ((f - t) + x); + else + c += ((x - t) + f); + f = t; } else { - c += ((x - t) + f); + some_value: + v = rb_funcallv(v, idPLUS, 1, &i); } - f = t; + memo->v = v; + memo->n = n; + memo->r = r; memo->f = f; memo->c = c; -} - -static void -sum_iter(VALUE i, struct enum_sum_memo *memo) -{ - RUBY_ASSERT(memo != NULL); - if (memo->block_given) { - i = rb_yield(i); - } - - if (memo->float_value) { - sum_iter_Kahan_Babuska(i, memo); - } - else switch (TYPE(memo->v)) { - default: sum_iter_some_value(i, memo); return; - case T_FLOAT: - case T_FIXNUM: - case T_BIGNUM: - case T_RATIONAL: - switch (TYPE(i)) { - case T_FIXNUM: sum_iter_fixnum(i, memo); return; - case T_BIGNUM: sum_iter_bignum(i, memo); return; - case T_RATIONAL: sum_iter_rational(i, memo); return; - case T_FLOAT: - sum_iter_normalize_memo(memo); - memo->f = NUM2DBL(memo->v); - memo->c = 0.0; - memo->float_value = 1; - sum_iter_Kahan_Babuska(i, memo); - return; - default: - sum_iter_normalize_memo(memo); - sum_iter_some_value(i, memo); - return; - } - } + (void)unused; } static VALUE @@ -4745,8 +3861,8 @@ hash_sum_i(VALUE key, VALUE value, VALUE arg) static void hash_sum(VALUE hash, struct enum_sum_memo *memo) { - RUBY_ASSERT(RB_TYPE_P(hash, T_HASH)); - RUBY_ASSERT(memo != NULL); + assert(RB_TYPE_P(hash, T_HASH)); + assert(memo != NULL); rb_hash_foreach(hash, hash_sum_i, (VALUE)memo); } @@ -4773,35 +3889,32 @@ int_range_sum(VALUE beg, VALUE end, int excl, VALUE init) } /* - * call-seq: - * sum(initial_value = 0) -> number - * sum(initial_value = 0) {|element| ... } -> object + * call-seq: + * enum.sum(init=0) -> number + * enum.sum(init=0) {|e| expr } -> number * - * With no block given, - * returns the sum of +initial_value+ and the elements: + * Returns the sum of elements in an Enumerable. * - * (1..100).sum # => 5050 - * (1..100).sum(1) # => 5051 - * ('a'..'d').sum('foo') # => "fooabcd" + * If a block is given, the block is applied to each element + * before addition. * - * Generally, the sum is computed using methods <tt>+</tt> and +each+; - * for performance optimizations, those methods may not be used, - * and so any redefinition of those methods may not have effect here. + * If <i>enum</i> is empty, it returns <i>init</i>. * - * One such optimization: When possible, computes using Gauss's summation - * formula <em>n(n+1)/2</em>: + * For example: * - * 100 * (100 + 1) / 2 # => 5050 + * { 1 => 10, 2 => 20 }.sum {|k, v| k * v } #=> 50 + * (1..10).sum #=> 55 + * (1..10).sum {|v| v * 2 } #=> 110 + * [Object.new].each.sum #=> TypeError * - * With a block given, calls the block with each element; - * returns the sum of +initial_value+ and the block return values: + * This method can be used for non-numeric objects by + * explicit <i>init</i> argument. * - * (1..4).sum {|i| i*i } # => 30 - * (1..4).sum(100) {|i| i*i } # => 130 - * h = {a: 0, b: 1, c: 2, d: 3, e: 4, f: 5} - * h.sum {|key, value| value.odd? ? value : 0 } # => 9 - * ('a'..'f').sum('x') {|c| c < 'd' ? c : '' } # => "xabc" + * { 1 => 10, 2 => 20 }.sum([]) #=> [1, 10, 2, 20] + * "a\nb\nc".each_line.lazy.map(&:chomp).sum("") #=> "abc" * + * Enumerable#sum method may not respect method redefinition of "+" + * methods such as Integer#+. */ static VALUE enum_sum(int argc, VALUE* argv, VALUE obj) @@ -4810,8 +3923,11 @@ enum_sum(int argc, VALUE* argv, VALUE obj) VALUE beg, end; int excl; - memo.v = (rb_check_arity(argc, 0, 1) == 0) ? LONG2FIX(0) : argv[0]; + if (rb_scan_args(argc, argv, "01", &memo.v) == 0) + memo.v = LONG2FIX(0); + memo.block_given = rb_block_given_p(); + memo.n = 0; memo.r = Qundef; @@ -4819,15 +3935,11 @@ enum_sum(int argc, VALUE* argv, VALUE obj) memo.f = RFLOAT_VALUE(memo.v); memo.c = 0.0; } - else { - memo.f = 0.0; - memo.c = 0.0; - } if (RTEST(rb_range_values(obj, &beg, &end, &excl))) { if (!memo.block_given && !memo.float_value && - (FIXNUM_P(beg) || RB_BIGNUM_TYPE_P(beg)) && - (FIXNUM_P(end) || RB_BIGNUM_TYPE_P(end))) { + (FIXNUM_P(beg) || RB_TYPE_P(beg, T_BIGNUM)) && + (FIXNUM_P(end) || RB_TYPE_P(end, T_BIGNUM))) { return int_range_sum(beg, end, excl, memo.v); } } @@ -4844,8 +3956,14 @@ enum_sum(int argc, VALUE* argv, VALUE obj) else { if (memo.n != 0) memo.v = rb_fix_plus(LONG2FIX(memo.n), memo.v); - if (!UNDEF_P(memo.r)) { - memo.v = rb_rational_plus(memo.r, memo.v); + if (memo.r != Qundef) { + /* r can be an Integer when mathn is loaded */ + if (FIXNUM_P(memo.r)) + memo.v = rb_fix_plus(memo.r, memo.v); + else if (RB_TYPE_P(memo.r, T_BIGNUM)) + memo.v = rb_big_plus(memo.r, memo.v); + else + memo.v = rb_rational_plus(memo.r, memo.v); } return memo.v; } @@ -4869,23 +3987,12 @@ uniq_iter(RB_BLOCK_CALL_FUNC_ARGLIST(i, hash)) /* * call-seq: - * uniq -> array - * uniq {|element| ... } -> array - * - * With no block, returns a new array containing only unique elements; - * the array has no two elements +e0+ and +e1+ such that <tt>e0.eql?(e1)</tt>: + * enum.uniq -> new_ary + * enum.uniq { |item| ... } -> new_ary * - * %w[a b c c b a a b c].uniq # => ["a", "b", "c"] - * [0, 1, 2, 2, 1, 0, 0, 1, 2].uniq # => [0, 1, 2] - * - * With a block, returns a new array containing elements only for which the block - * returns a unique value: - * - * a = [0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1] - * a.uniq {|i| i.even? ? i : 0 } # => [0, 2, 4] - * a = %w[a b c d e e d c b a a b c d e] - * a.uniq {|c| c < 'c' } # => ["a", "c"] + * Returns a new array by removing duplicate values in +self+. * + * See also Array#uniq. */ static VALUE @@ -4893,7 +4000,7 @@ enum_uniq(VALUE obj) { VALUE hash, ret; rb_block_call_func *const func = - rb_block_given_p() ? uniq_iter : uniq_func; + rb_block_given_p() ? uniq_iter : uniq_func; hash = rb_obj_hide(rb_hash_new()); rb_block_call(obj, id_each, 0, 0, func, hash); @@ -4902,216 +4009,23 @@ enum_uniq(VALUE obj) return ret; } -static VALUE -compact_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary)) -{ - ENUM_WANT_SVALUE(); - - if (!NIL_P(i)) { - rb_ary_push(ary, i); - } - return Qnil; -} - /* - * call-seq: - * compact -> array - * - * Returns an array of all non-+nil+ elements: - * - * a = [nil, 0, nil, 'a', false, nil, false, nil, 'a', nil, 0, nil] - * a.compact # => [0, "a", false, false, "a", 0] - * - */ - -static VALUE -enum_compact(VALUE obj) -{ - VALUE ary; - - ary = rb_ary_new(); - rb_block_call(obj, id_each, 0, 0, compact_i, ary); - - return ary; -} - - -/* - * == What's Here - * - * \Module \Enumerable provides methods that are useful to a collection class for: - * - * - {Querying}[rdoc-ref:Enumerable@Methods+for+Querying] - * - {Fetching}[rdoc-ref:Enumerable@Methods+for+Fetching] - * - {Searching and Filtering}[rdoc-ref:Enumerable@Methods+for+Searching+and+Filtering] - * - {Sorting}[rdoc-ref:Enumerable@Methods+for+Sorting] - * - {Iterating}[rdoc-ref:Enumerable@Methods+for+Iterating] - * - {And more....}[rdoc-ref:Enumerable@Other+Methods] - * - * === Methods for Querying - * - * These methods return information about the \Enumerable other than the elements themselves: - * - * - #member? (aliased as #include?): Returns +true+ if <tt>self == object</tt>, +false+ otherwise. - * - #all?: Returns +true+ if all elements meet a specified criterion; +false+ otherwise. - * - #any?: Returns +true+ if any element meets a specified criterion; +false+ otherwise. - * - #none?: Returns +true+ if no element meets a specified criterion; +false+ otherwise. - * - #one?: Returns +true+ if exactly one element meets a specified criterion; +false+ otherwise. - * - #count: Returns the count of elements, - * based on an argument or block criterion, if given. - * - #tally: Returns a new Hash containing the counts of occurrences of each element. - * - * === Methods for Fetching - * - * These methods return entries from the \Enumerable, without modifying it: - * - * <i>Leading, trailing, or all elements</i>: - * - * - #to_a (aliased as #entries): Returns all elements. - * - #first: Returns the first element or leading elements. - * - #take: Returns a specified number of leading elements. - * - #drop: Returns a specified number of trailing elements. - * - #take_while: Returns leading elements as specified by the given block. - * - #drop_while: Returns trailing elements as specified by the given block. - * - * <i>Minimum and maximum value elements</i>: - * - * - #min: Returns the elements whose values are smallest among the elements, - * as determined by <tt>#<=></tt> or a given block. - * - #max: Returns the elements whose values are largest among the elements, - * as determined by <tt>#<=></tt> or a given block. - * - #minmax: Returns a 2-element Array containing the smallest and largest elements. - * - #min_by: Returns the smallest element, as determined by the given block. - * - #max_by: Returns the largest element, as determined by the given block. - * - #minmax_by: Returns the smallest and largest elements, as determined by the given block. - * - * <i>Groups, slices, and partitions</i>: - * - * - #group_by: Returns a Hash that partitions the elements into groups. - * - #partition: Returns elements partitioned into two new Arrays, as determined by the given block. - * - #slice_after: Returns a new Enumerator whose entries are a partition of +self+, - * based either on a given +object+ or a given block. - * - #slice_before: Returns a new Enumerator whose entries are a partition of +self+, - * based either on a given +object+ or a given block. - * - #slice_when: Returns a new Enumerator whose entries are a partition of +self+ - * based on the given block. - * - #chunk: Returns elements organized into chunks as specified by the given block. - * - #chunk_while: Returns elements organized into chunks as specified by the given block. - * - * === Methods for Searching and Filtering - * - * These methods return elements that meet a specified criterion: - * - * - #find (aliased as #detect): Returns an element selected by the block. - * - #find_all (aliased as #filter, #select): Returns elements selected by the block. - * - #find_index: Returns the index of an element selected by a given object or block. - * - #reject: Returns elements not rejected by the block. - * - #uniq: Returns elements that are not duplicates. - * - * === Methods for Sorting - * - * These methods return elements in sorted order: - * - * - #sort: Returns the elements, sorted by <tt>#<=></tt> or the given block. - * - #sort_by: Returns the elements, sorted by the given block. - * - * === Methods for Iterating - * - * - #each_entry: Calls the block with each successive element - * (slightly different from #each). - * - #each_with_index: Calls the block with each successive element and its index. - * - #each_with_object: Calls the block with each successive element and a given object. - * - #each_slice: Calls the block with successive non-overlapping slices. - * - #each_cons: Calls the block with successive overlapping slices. - * (different from #each_slice). - * - #reverse_each: Calls the block with each successive element, in reverse order. - * - * === Other Methods - * - * - #collect (aliased as #map): Returns objects returned by the block. - * - #filter_map: Returns truthy objects returned by the block. - * - #flat_map (aliased as #collect_concat): Returns flattened objects returned by the block. - * - #grep: Returns elements selected by a given object - * or objects returned by a given block. - * - #grep_v: Returns elements selected by a given object - * or objects returned by a given block. - * - #inject (aliased as #reduce): Returns the object formed by combining all elements. - * - #sum: Returns the sum of the elements, using method <tt>+</tt>. - * - #zip: Combines each element with elements from other enumerables; - * returns the n-tuples or calls the block with each. - * - #cycle: Calls the block with each element, cycling repeatedly. - * - * == Usage - * - * To use module \Enumerable in a collection class: - * - * - Include it: - * - * include Enumerable - * - * - Implement method <tt>#each</tt> - * which must yield successive elements of the collection. - * The method will be called by almost any \Enumerable method. - * - * Example: - * - * class Foo - * include Enumerable - * def each - * yield 1 - * yield 1, 2 - * yield - * end - * end - * Foo.new.each_entry{ |element| p element } - * - * Output: - * - * 1 - * [1, 2] - * nil - * - * == \Enumerable in Ruby Classes - * - * These Ruby core classes include (or extend) \Enumerable: - * - * - ARGF - * - Array - * - Dir - * - Enumerator - * - ENV (extends) - * - Hash - * - IO - * - Range - * - Struct - * - * These Ruby standard library classes include \Enumerable: - * - * - CSV - * - CSV::Table - * - CSV::Row - * - Set - * - * Virtually all methods in \Enumerable call method +#each+ in the including class: - * - * - <tt>Hash#each</tt> yields the next key-value pair as a 2-element Array. - * - <tt>Struct#each</tt> yields the next name-value pair as a 2-element Array. - * - For the other classes above, +#each+ yields the next object from the collection. - * - * == About the Examples - * - * The example code snippets for the \Enumerable methods: - * - * - Always show the use of one or more Array-like classes (often Array itself). - * - Sometimes show the use of a Hash-like class. - * For some methods, though, the usage would not make sense, - * and so it is not shown. Example: #tally would find exactly one of each Hash entry. - * + * The <code>Enumerable</code> mixin provides collection classes with + * several traversal and searching methods, and with the ability to + * sort. The class must provide a method <code>each</code>, which + * yields successive members of the collection. If + * <code>Enumerable#max</code>, <code>#min</code>, or + * <code>#sort</code> is used, the objects in the collection must also + * implement a meaningful <code><=></code> operator, as these methods + * rely on an ordering between members of the collection. */ void Init_Enumerable(void) { +#undef rb_intern +#define rb_intern(str) rb_intern_const(str) + rb_mEnumerable = rb_define_module("Enumerable"); rb_define_method(rb_mEnumerable, "to_a", enum_to_a, -1); @@ -5128,8 +4042,6 @@ Init_Enumerable(void) rb_define_method(rb_mEnumerable, "find_index", enum_find_index, -1); rb_define_method(rb_mEnumerable, "find_all", enum_find_all, 0); rb_define_method(rb_mEnumerable, "select", enum_find_all, 0); - rb_define_method(rb_mEnumerable, "filter", enum_find_all, 0); - rb_define_method(rb_mEnumerable, "filter_map", enum_filter_map, 0); rb_define_method(rb_mEnumerable, "reject", enum_reject, 0); rb_define_method(rb_mEnumerable, "collect", enum_collect, 0); rb_define_method(rb_mEnumerable, "map", enum_collect, 0); @@ -5139,7 +4051,6 @@ Init_Enumerable(void) rb_define_method(rb_mEnumerable, "reduce", enum_inject, -1); rb_define_method(rb_mEnumerable, "partition", enum_partition, 0); rb_define_method(rb_mEnumerable, "group_by", enum_group_by, 0); - rb_define_method(rb_mEnumerable, "tally", enum_tally, -1); rb_define_method(rb_mEnumerable, "first", enum_first, -1); rb_define_method(rb_mEnumerable, "all?", enum_all, -1); rb_define_method(rb_mEnumerable, "any?", enum_any, -1); @@ -5172,20 +4083,7 @@ Init_Enumerable(void) rb_define_method(rb_mEnumerable, "chunk_while", enum_chunk_while, 0); rb_define_method(rb_mEnumerable, "sum", enum_sum, -1); rb_define_method(rb_mEnumerable, "uniq", enum_uniq, 0); - rb_define_method(rb_mEnumerable, "compact", enum_compact, 0); - - id__alone = rb_intern_const("_alone"); - id__separator = rb_intern_const("_separator"); - id_chunk_categorize = rb_intern_const("chunk_categorize"); - id_chunk_enumerable = rb_intern_const("chunk_enumerable"); - id_next = rb_intern_const("next"); - id_sliceafter_enum = rb_intern_const("sliceafter_enum"); - id_sliceafter_pat = rb_intern_const("sliceafter_pat"); - id_sliceafter_pred = rb_intern_const("sliceafter_pred"); - id_slicebefore_enumerable = rb_intern_const("slicebefore_enumerable"); - id_slicebefore_sep_pat = rb_intern_const("slicebefore_sep_pat"); - id_slicebefore_sep_pred = rb_intern_const("slicebefore_sep_pred"); - id_slicewhen_enum = rb_intern_const("slicewhen_enum"); - id_slicewhen_inverted = rb_intern_const("slicewhen_inverted"); - id_slicewhen_pred = rb_intern_const("slicewhen_pred"); + + id_next = rb_intern("next"); + id_div = rb_intern("div"); } |