diff options
Diffstat (limited to 'enum.c')
| -rw-r--r-- | enum.c | 5453 |
1 files changed, 4894 insertions, 559 deletions
@@ -3,943 +3,5278 @@ enum.c - $Author$ - $Date$ created at: Fri Oct 1 15:15:19 JST 1993 - Copyright (C) 1993-2003 Yukihiro Matsumoto + Copyright (C) 1993-2007 Yukihiro Matsumoto **********************************************************************/ -#include "ruby.h" -#include "node.h" -#include "util.h" +#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 "symbol.h" VALUE rb_mEnumerable; -static ID id_each, id_eqq, id_cmp; + +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 +#define id_each idEach +#define id_eqq idEqq +#define id_cmp idCmp +#define id_lshift idLTLT +#define id_call idCall +#define id_size idSize VALUE -rb_each(obj) - VALUE obj; +rb_enum_values_pack(int argc, const VALUE *argv) +{ + if (argc == 0) return Qnil; + if (argc == 1) return argv[0]; + return rb_ary_new4(argc, argv); +} + +#define ENUM_WANT_SVALUE() do { \ + i = rb_enum_values_pack(argc, argv); \ +} while (0) + +static VALUE +enum_yield(int argc, VALUE ary) +{ + if (argc > 1) + return rb_yield_force_blockarg(ary); + if (argc == 1) + return rb_yield(ary); + return rb_yield_values2(0, 0); +} + +static VALUE +enum_yield_array(VALUE ary) { - return rb_funcall(obj, id_each, 0, 0); + long len = RARRAY_LEN(ary); + + if (len > 1) + return rb_yield_force_blockarg(ary); + if (len == 1) + return rb_yield(RARRAY_AREF(ary, 0)); + return rb_yield_values2(0, 0); +} + +static VALUE +grep_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args)) +{ + struct MEMO *memo = MEMO_CAST(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_i(i, arg) - VALUE i, *arg; +grep_regexp_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args)) { - if (RTEST(rb_funcall(arg[0], id_eqq, 1, i))) { - rb_ary_push(arg[1], i); + 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); } return Qnil; } static VALUE -grep_iter_i(i, arg) - VALUE i, *arg; +grep_iter_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args)) { - if (RTEST(rb_funcall(arg[0], id_eqq, 1, i))) { - rb_ary_push(arg[1], rb_yield(i)); + struct MEMO *memo = MEMO_CAST(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)); } return Qnil; } +static VALUE +enum_grep0(VALUE obj, VALUE pat, VALUE test) +{ + VALUE ary = rb_ary_new(); + struct MEMO *memo = rb_imemo_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: - * enum.grep(pattern) => array - * enum.grep(pattern) {| obj | block } => array - * - * 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. - * - * (1..100).grep 38..44 #=> [38, 39, 40, 41, 42, 43, 44] - * c = IO.constants - * c.grep(/SEEK/) #=> ["SEEK_END", "SEEK_SET", "SEEK_CUR"] - * res = c.grep(/SEEK/) {|v| IO.const_get(v) } - * res #=> [2, 0, 1] - * + * 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] + * + * With a block given, + * calls the block with each matching element and returns an array containing each + * object returned by the block: + * + * a = ['foo', 'bar', 'car', 'moo'] + * a.grep(/ar/) {|element| element.upcase } # => ["BAR", "CAR"] + * + * Related: #grep_v. */ static VALUE -enum_grep(obj, pat) - VALUE obj, pat; +enum_grep(VALUE obj, VALUE pat) { - VALUE ary = rb_ary_new(); - VALUE arg[2]; + return enum_grep0(obj, pat, Qtrue); +} - arg[0] = pat; - arg[1] = 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"] + * + * With a block given, + * calls the block with each non-matching element and returns an array containing each + * object returned by the block: + * + * a = ['foo', 'bar', 'car', 'moo'] + * a.grep_v(/ar/) {|element| element.upcase } # => ["FOO", "MOO"] + * + * Related: #grep. + */ - rb_iterate(rb_each, obj, rb_block_given_p() ? grep_iter_i : grep_i, (VALUE)arg); - - return ary; +static VALUE +enum_grep_v(VALUE obj, VALUE pat) +{ + return enum_grep0(obj, pat, Qfalse); +} + +#define COUNT_BIGNUM IMEMO_FL_USER0 +#define MEMO_V3_SET(m, v) RB_OBJ_WRITE((m), &(m)->u3.value, (v)) + +static void +imemo_count_up(struct MEMO *memo) +{ + if (memo->flags & COUNT_BIGNUM) { + 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; + } } static VALUE -find_i(i, memo) - VALUE i; - NODE *memo; +imemo_count_value(struct MEMO *memo) +{ + if (memo->flags & COUNT_BIGNUM) { + return memo->u3.value; + } + else { + return ULONG2NUM(memo->u3.cnt); + } +} + +static VALUE +count_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memop)) +{ + struct MEMO *memo = MEMO_CAST(memop); + + ENUM_WANT_SVALUE(); + + if (rb_equal(i, memo->v1)) { + imemo_count_up(memo); + } + return Qnil; +} + +static VALUE +count_iter_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memop)) { - if (RTEST(rb_yield(i))) { - memo->u2.value = Qtrue; - memo->u1.value = i; - rb_iter_break(); + struct MEMO *memo = MEMO_CAST(memop); + + if (RTEST(rb_yield_values2(argc, argv))) { + imemo_count_up(memo); } return Qnil; } +static VALUE +count_all_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memop)) +{ + struct MEMO *memo = MEMO_CAST(memop); + + imemo_count_up(memo); + return Qnil; +} + /* - * call-seq: - * enum.detect(ifnone = nil) {| obj | block } => obj or nil - * enum.find(ifnone = nil) {| obj | block } => obj or nil - * - * Passes each entry in <i>enum</i> to <em>block</em>. Returns the - * first for which <em>block</em> is not <code>false</code>. If no - * object matches, calls <i>ifnone</i> and returns its result when it - * is specified, or returns <code>nil</code> - * - * (1..10).detect {|i| i % 5 == 0 and i % 7 == 0 } #=> nil - * (1..100).detect {|i| i % 5 == 0 and i % 7 == 0 } #=> 35 - * + * 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 + * + * With a block given, calls the block with each element + * and returns the number of elements for which the block returns a truthy value: + * + * [0, 1, 2, 3].count {|element| element < 2} # => 2 + * {foo: 0, bar: 1, baz: 2}.count {|key, value| value < 2} # => 2 + * */ static VALUE -enum_find(argc, argv, obj) - int argc; - VALUE* argv; - VALUE obj; +enum_count(int argc, VALUE *argv, VALUE obj) +{ + VALUE item = Qnil; + struct MEMO *memo; + rb_block_call_func *func; + + if (argc == 0) { + 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"); + } + func = count_i; + } + + memo = rb_imemo_memo_new(item, 0, 0); + rb_block_call(obj, id_each, 0, 0, func, (VALUE)memo); + 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); + } + 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: + * + * (0..9).find {|element| element > 2} # => 3 + * + * If no such element is found, calls +if_none_proc+ and returns its return value. + * + * (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') } # => [] + * + * With no block given, returns an Enumerator. + * + */ +static VALUE +enum_find(int argc, VALUE *argv, VALUE obj) { - NODE *memo = rb_node_newnode(NODE_MEMO, Qnil, Qfalse, 0); + struct MEMO *memo; VALUE if_none; - rb_scan_args(argc, argv, "01", &if_none); - rb_iterate(rb_each, obj, find_i, (VALUE)memo); - if (memo->u2.value) { - VALUE result = memo->u1.value; - rb_gc_force_recycle((VALUE)memo); - return result; + if_none = rb_check_arity(argc, 0, 1) ? argv[0] : Qnil; + RETURN_ENUMERATOR(obj, argc, argv); + memo = rb_imemo_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); + if (memo->u3.cnt) { + return memo->v1; } - rb_gc_force_recycle((VALUE)memo); if (!NIL_P(if_none)) { - return rb_funcall(if_none, rb_intern("call"), 0, 0); + return rb_funcallv(if_none, id_call, 0, 0); + } + return Qnil; +} + +static VALUE +find_index_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memop)) +{ + struct MEMO *memo = MEMO_CAST(memop); + + ENUM_WANT_SVALUE(); + + if (rb_equal(i, memo->v2)) { + MEMO_V1_SET(memo, imemo_count_value(memo)); + rb_iter_break(); } + imemo_count_up(memo); return Qnil; } static VALUE -find_all_i(i, ary) - VALUE i, ary; +find_index_iter_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memop)) { - if (RTEST(rb_yield(i))) { - rb_ary_push(ary, i); + struct MEMO *memo = MEMO_CAST(memop); + + if (RTEST(rb_yield_values2(argc, argv))) { + MEMO_V1_SET(memo, imemo_count_value(memo)); + rb_iter_break(); } + imemo_count_up(memo); return Qnil; } /* - * call-seq: - * enum.find_all {| obj | block } => array - * enum.select {| obj | block } => array - * - * Returns an array containing all elements of <i>enum</i> for which - * <em>block</em> is not <code>false</code> (see also - * <code>Enumerable#reject</code>). - * - * (1..10).find_all {|i| i % 3 == 0 } #=> [3, 6, 9] - * + * 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 + * + * With a block given, calls the block with successive elements; + * returns the first element for which the block returns a truthy value: + * + * ['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 + * + * With no argument and no block given, returns an Enumerator. + * */ static VALUE -enum_find_all(obj) - VALUE obj; +enum_find_index(int argc, VALUE *argv, VALUE obj) { - VALUE ary = rb_ary_new(); - - rb_iterate(rb_each, obj, find_all_i, ary); + struct MEMO *memo; /* [return value, current index, ] */ + VALUE condition_value = Qnil; + rb_block_call_func *func; + + if (argc == 0) { + RETURN_ENUMERATOR(obj, 0, 0); + 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"); + } + func = find_index_i; + } + + memo = rb_imemo_memo_new(Qnil, condition_value, 0); + rb_block_call(obj, id_each, 0, 0, func, (VALUE)memo); + return memo->v1; +} + +static VALUE +find_all_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary)) +{ + ENUM_WANT_SVALUE(); + + if (RTEST(enum_yield(argc, i))) { + rb_ary_push(ary, i); + } + return Qnil; +} + +static VALUE +enum_size(VALUE self, VALUE args, VALUE eobj) +{ + return rb_check_funcall_default(self, id_size, 0, 0, Qnil); +} + +static long +limit_by_enum_size(VALUE obj, long n) +{ + unsigned long limit; + VALUE size = rb_check_funcall(obj, id_size, 0, 0); + if (!FIXNUM_P(size)) return n; + limit = FIX2ULONG(size); + return ((unsigned long)n > limit) ? (long)limit : n; +} + +static int +enum_size_over_p(VALUE obj, long n) +{ + VALUE size = rb_check_funcall(obj, id_size, 0, 0); + if (!FIXNUM_P(size)) return 0; + return ((unsigned long)n > FIX2ULONG(size)); +} + +/* + * call-seq: + * select {|element| ... } -> array + * select -> enumerator + * + * Returns an array containing elements selected by the block. + * + * With a block given, calls the block with successive elements; + * returns an array of those elements for which the block returns a truthy value: + * + * (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. + * + * Related: #reject. + */ +static VALUE +enum_find_all(VALUE obj) +{ + VALUE ary; + + RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size); + + ary = rb_ary_new(); + rb_block_call(obj, id_each, 0, 0, find_all_i, ary); return ary; } static VALUE -reject_i(i, ary) - VALUE i, ary; +filter_map_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary)) { - if (!RTEST(rb_yield(i))) { - rb_ary_push(ary, i); + i = rb_yield_values2(argc, argv); + + if (RTEST(i)) { + rb_ary_push(ary, i); } + return Qnil; } /* - * call-seq: - * enum.reject {| obj | block } => array - * - * Returns an array for all elements of <i>enum</i> for which - * <em>block</em> is false (see also <code>Enumerable#find_all</code>). - * - * (1..10).reject {|i| i % 3 == 0 } #=> [1, 2, 4, 5, 7, 8, 10] - * + * 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 -enum_reject(obj) - VALUE obj; +reject_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary)) { - VALUE ary = rb_ary_new(); - - rb_iterate(rb_each, obj, reject_i, ary); + ENUM_WANT_SVALUE(); + + if (!RTEST(enum_yield(argc, i))) { + rb_ary_push(ary, i); + } + return Qnil; +} + +/* + * call-seq: + * reject {|element| ... } -> array + * reject -> enumerator + * + * Returns an array of objects rejected by the block. + * + * With a block given, calls the block with successive elements; + * returns an array of those elements for which the block returns +nil+ or +false+: + * + * (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} + * + * When no block given, returns an Enumerator. + * + * Related: #select. + */ + +static VALUE +enum_reject(VALUE obj) +{ + VALUE ary; + + RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size); + + ary = rb_ary_new(); + rb_block_call(obj, id_each, 0, 0, reject_i, ary); return ary; } static VALUE -collect_i(i, ary) - VALUE i, ary; +collect_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary)) { - rb_ary_push(ary, rb_yield(i)); + rb_ary_push(ary, rb_yield_values2(argc, argv)); return Qnil; } static VALUE -collect_all(i, ary) - VALUE i, ary; +collect_all(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary)) { - rb_ary_push(ary, i); + rb_ary_push(ary, rb_enum_values_pack(argc, argv)); return Qnil; } /* - * call-seq: - * enum.collect {| obj | block } => array - * enum.map {| obj | block } => array - * - * Returns a new array with the results of running <em>block</em> once - * for every element in <i>enum</i>. - * - * (1..4).collect {|i| i*i } #=> [1, 4, 9, 16] - * (1..4).collect { "cat" } #=> ["cat", "cat", "cat", "cat"] - * + * call-seq: + * map {|element| ... } -> array + * map -> enumerator + * + * Returns an array of objects returned by the block. + * + * With a block given, calls the block with successive elements; + * returns an array of the objects returned by the block: + * + * (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] + * + * With no block given, returns an Enumerator. + * */ +static VALUE +enum_collect(VALUE obj) +{ + VALUE ary; + int min_argc, max_argc; + + RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size); + + ary = rb_ary_new(); + min_argc = rb_block_min_max_arity(&max_argc); + rb_lambda_call(obj, id_each, 0, 0, collect_i, min_argc, max_argc, ary); + + return ary; +} static VALUE -enum_collect(obj) - VALUE obj; +flat_map_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary)) { - VALUE ary = rb_ary_new(); + VALUE tmp; - rb_iterate(rb_each, obj, rb_block_given_p() ? collect_i : collect_all, ary); + i = rb_yield_values2(argc, argv); + tmp = rb_check_array_type(i); + + if (NIL_P(tmp)) { + rb_ary_push(ary, i); + } + else { + 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. + * + * With a block given, calls the block with successive elements; + * returns a flattened array of objects returned by the block: + * + * [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] + * + * With no block given, returns an Enumerator. + * + * Alias: #collect_concat. + */ +static VALUE +enum_flat_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, flat_map_i, ary); return ary; } /* * call-seq: - * enum.to_a => array - * enum.entries => array - * - * Returns an array containing the items in <i>enum</i>. - * - * (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]] + * to_a(*args) -> array + * + * Returns an array containing the items in +self+: + * + * (0..4).to_a # => [0, 1, 2, 3, 4] + * */ static VALUE -enum_to_a(obj) - VALUE obj; +enum_to_a(int argc, VALUE *argv, VALUE obj) { VALUE ary = rb_ary_new(); - rb_iterate(rb_each, obj, collect_all, ary); + rb_block_call_kw(obj, id_each, argc, argv, collect_all, ary, RB_PASS_CALLED_KEYWORDS); return ary; } static VALUE -inject_i(i, memo) - VALUE i; - NODE *memo; +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)) +{ + ENUM_WANT_SVALUE(); + return rb_hash_set_pair(hash, i); +} + +static VALUE +enum_to_h_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, hash)) { - if (memo->u2.value) { - memo->u2.value = Qfalse; - memo->u1.value = i; + return rb_hash_set_pair(hash, rb_yield_values2(argc, argv)); +} + +/* + * 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} + * + * 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: + * + * (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. + */ + +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); +} + +static VALUE +inject_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, p)) +{ + struct MEMO *memo = MEMO_CAST(p); + + ENUM_WANT_SVALUE(); + + if (UNDEF_P(memo->v1)) { + MEMO_V1_SET(memo, i); + } + else { + MEMO_V1_SET(memo, rb_yield_values(2, memo->v1, i)); + } + return Qnil; +} + +static VALUE +inject_op_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, p)) +{ + struct MEMO *memo = MEMO_CAST(p); + VALUE name; + + ENUM_WANT_SVALUE(); + + if (UNDEF_P(memo->v1)) { + 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)); } else { - memo->u1.value = rb_yield_values(2, memo->u1.value, i); + VALUE args[2]; + args[0] = name; + args[1] = i; + MEMO_V1_SET(memo, rb_f_send(numberof(args), args, memo->v1)); } return Qnil; } +static VALUE +ary_inject_op(VALUE ary, VALUE init, VALUE op) +{ + ID id; + VALUE v, e; + long i, n; + + if (RARRAY_LEN(ary) == 0) + return UNDEF_P(init) ? Qnil : init; + + if (UNDEF_P(init)) { + v = RARRAY_AREF(ary, 0); + i = 1; + if (RARRAY_LEN(ary) == 1) + return v; + } + else { + v = init; + i = 0; + } + + 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)) { + 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); + n = 0; + } + } + else if (RB_BIGNUM_TYPE_P(e)) + v = rb_big_plus(e, v); + else + goto not_integer; + } + if (n != 0) + v = rb_fix_plus(LONG2FIX(n), v); + return v; + + not_integer: + if (n != 0) + v = rb_fix_plus(LONG2FIX(n), v); + } + } + for (; i < RARRAY_LEN(ary); i++) { + VALUE arg = RARRAY_AREF(ary, i); + v = rb_funcallv_public(v, id, 1, &arg); + } + return v; +} + /* * call-seq: - * enum.inject(initial) {| memo, obj | block } => obj - * enum.inject {| memo, obj | block } => obj - * - * Combines the elements of <i>enum</i> by applying the block to an - * accumulator value (<i>memo</i>) and each element in turn. At each - * step, <i>memo</i> is set to the value returned by the block. The - * first form lets you supply an initial value for <i>memo</i>. The - * second form uses the first element of the collection as a the - * initial value (and skips that element while iterating). - * - * # Sum some numbers - * (5..10).inject {|sum, n| sum + n } #=> 45 - * # Multiply some numbers - * (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" - * - * # find the length of the longest word - * longest = %w{ cat sheep bear }.inject(0) do |memo,word| - * memo >= word.length ? memo : word.length - * end - * longest #=> 5 - * + * 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]] + * + * */ +static VALUE +enum_inject(int argc, VALUE *argv, VALUE obj) +{ + struct MEMO *memo; + 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) { + case 0: + 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; + 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 (iter == inject_op_i && + SYMBOL_P(op) && + RB_TYPE_P(obj, T_ARRAY) && + rb_method_basic_definition_p(CLASS_OF(obj), id_each)) { + return ary_inject_op(obj, init, op); + } + + memo = rb_imemo_memo_new(init, Qnil, op); + rb_block_call(obj, id_each, 0, 0, iter, (VALUE)memo); + if (UNDEF_P(memo->v1)) return Qnil; + return memo->v1; +} static VALUE -enum_inject(argc, argv, obj) - int argc; - VALUE *argv, obj; +partition_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, arys)) { - NODE *memo; - VALUE n; + struct MEMO *memo = MEMO_CAST(arys); + VALUE ary; + ENUM_WANT_SVALUE(); - if (rb_scan_args(argc, argv, "01", &n) == 1) { - memo = rb_node_newnode(NODE_MEMO, n, Qfalse, 0); + if (RTEST(enum_yield(argc, i))) { + ary = memo->v1; } else { - memo = rb_node_newnode(NODE_MEMO, Qnil, Qtrue, 0); + ary = memo->v2; } - rb_iterate(rb_each, obj, inject_i, (VALUE)memo); - n = memo->u1.value; - rb_gc_force_recycle((VALUE)memo); - return n; + rb_ary_push(ary, i); + return Qnil; } +/* + * call-seq: + * partition {|element| ... } -> [true_array, false_array] + * partition -> enumerator + * + * With a block given, returns an array of two arrays: + * + * - The first having those elements for which the block returns a truthy value. + * - The other having all other elements. + * + * 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. + * + */ + +static VALUE +enum_partition(VALUE obj) +{ + struct MEMO *memo; + + RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size); + + memo = rb_imemo_memo_new(rb_ary_new(), rb_ary_new(), 0); + rb_block_call(obj, id_each, 0, 0, partition_i, (VALUE)memo); + + return rb_assoc_new(memo->v1, memo->v2); +} + +static VALUE +group_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, hash)) +{ + VALUE group; + VALUE values; + + ENUM_WANT_SVALUE(); + + 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); + } + else { + rb_ary_push(values, i); + } + return Qnil; +} + +/* + * call-seq: + * group_by {|element| ... } -> hash + * group_by -> enumerator + * + * With a block given returns a hash: + * + * - Each key is a return value from the block. + * - Each value is an array of those elements for which the block returned that key. + * + * Examples: + * + * 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. + * + */ + static VALUE -partition_i(i, ary) - VALUE i, *ary; +enum_group_by(VALUE obj) { - if (RTEST(rb_yield(i))) { - rb_ary_push(ary[0], i); + RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size); + + return enum_hashify(obj, 0, 0, group_by_i); +} + +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 { - rb_ary_push(ary[1], i); + Check_Type(tally, T_BIGNUM); + tally = rb_big_plus(tally, INT2FIX(1)); + RB_OBJ_WRITTEN(hash, Qundef, tally); + } + *value = (st_data_t)tally; + return ST_CONTINUE; +} + +static VALUE +rb_enum_tally_up(VALUE hash, VALUE group) +{ + if (!rb_hash_stlike_update(hash, group, tally_up, (st_data_t)hash)) { + RB_OBJ_WRITTEN(hash, Qundef, group); } + 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: - * enum.partition {| obj | block } => [ true_array, false_array ] - * - * Returns two arrays, the first containing the elements of - * <i>enum</i> for which the block evaluates to true, the second - * containing the rest. - * - * (1..6).partition {|i| (i&1).zero?} #=> [[2, 4, 6], [1, 3, 5]] - * + * 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_partition(obj) - VALUE obj; +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)) { - VALUE ary[2]; + struct MEMO *memo = MEMO_CAST(params); + ENUM_WANT_SVALUE(); - ary[0] = rb_ary_new(); - ary[1] = rb_ary_new(); - rb_iterate(rb_each, obj, partition_i, (VALUE)ary); + MEMO_V1_SET(memo, i); + rb_iter_break(); - return rb_assoc_new(ary[0], ary[1]); + UNREACHABLE_RETURN(Qnil); } +static VALUE enum_take(VALUE obj, VALUE n); + /* * call-seq: - * enum.sort => array - * enum.sort {| a, b | block } => array - * - * Returns an array containing the items in <i>enum</i> sorted, - * either according to their own <code><=></code> method, or by using - * the results of the supplied block. The block should return -1, 0, or - * +1 depending on the comparison between <i>a</i> and <i>b</i>. As of - * Ruby 1.8, the method <code>Enumerable#sort_by</code> implements a - * built-in Schwartzian Transform, useful when key computation or - * comparison is expensive.. - * - * %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] + * first -> element or nil + * first(n) -> array + * + * Returns the first element or elements. + * + * With no argument, returns the first element, or +nil+ if there is none: + * + * (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) # => [] + * */ static VALUE -enum_sort(obj) - VALUE obj; +enum_first(int argc, VALUE *argv, VALUE obj) { - return rb_ary_sort(enum_to_a(obj)); + struct MEMO *memo; + rb_check_arity(argc, 0, 1); + if (argc > 0) { + return enum_take(obj, argv[0]); + } + else { + memo = rb_imemo_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>: + * + * %w[b c a d].sort # => ["a", "b", "c", "d"] + * {foo: 0, bar: 1, baz: 2}.sort # => [[:bar, 1], [:baz, 2], [:foo, 0]] + * + * With a block given, comparisons in the block determine the ordering. + * 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>. + * + * Examples: + * + * 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]] + * + * See also #sort_by. It implements a Schwartzian transform + * which is useful when key computation or comparison is expensive. + */ + static VALUE -sort_by_i(i, ary) - VALUE i, ary; +enum_sort(VALUE obj) { - VALUE v, e; + return rb_ary_sort_bang(enum_to_a(0, 0, 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; +}; - v = rb_yield(i); - e = rb_assoc_new(v, i); - rb_ary_push(ary, e); +static VALUE +sort_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, _data)) +{ + struct sort_by_data *data = (struct sort_by_data *)&MEMO_CAST(_data)->v1; + VALUE ary = data->ary; + VALUE v; + + ENUM_WANT_SVALUE(); + + v = enum_yield(argc, i); + + if (RBASIC(ary)->klass) { + rb_raise(rb_eRuntimeError, "sort_by reentered"); + } + if (RARRAY_LEN(data->buf) != SORT_BY_BUFSIZE*2) { + 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; + } return Qnil; } static int -sort_by_cmp(a, b) - VALUE *a, *b; +sort_by_cmp(const void *ap, const void *bp, void *data) +{ + VALUE a; + VALUE b; + VALUE ary = (VALUE)data; + + if (RBASIC(ary)->klass) { + 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) { - VALUE retval; + size_t n = ptr_end - ptr_begin; + size_t d = CHAR_BIT * sizeof(n) - nlz_intptr(n) - 1; + bool sorted_flag = true; - retval = rb_funcall(RARRAY(*a)->ptr[0], id_cmp, 1, RARRAY(*b)->ptr[0]); - return rb_cmpint(retval, *a, *b); + 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); } +#undef uless + + /* * call-seq: - * enum.sort_by {| obj | block } => array - * - * Sorts <i>enum</i> using a set of keys generated by mapping the - * values in <i>enum</i> through the given block. - * - * %w{ apple pear fig }.sort_by {|word| word.length} - #=> ["fig", "pear", "apple"] - * - * 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 - * + * sort_by {|element| ... } -> array + * sort_by -> 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. + * + * Examples: + * + * 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]] + * + * With no block given, returns an Enumerator. + * + * 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. + * * require 'benchmark' - * include Benchmark - * - * a = (1..100000).map {rand(100000)} - * - * bm(10) do |b| + * + * a = (1..100000).map { rand(100000) } + * + * Benchmark.bm(10) do |b| * b.report("Sort") { a.sort } - * b.report("Sort by") { a.sort_by {|a| a} } + * b.report("Sort by") { a.sort_by { |a| a } } * end - * + * * <em>produces:</em> - * + * * user system total real * Sort 0.180000 0.000000 0.180000 ( 0.175469) * Sort by 1.980000 0.040000 2.020000 ( 2.013586) - * + * * 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 <code>sort</code> method. - * + * using the basic #sort method. + * * files = Dir["*"] - * sorted = files.sort {|a,b| File.new(a).mtime <=> File.new(b).mtime} + * 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 <code>File</code> + * + * This sort is inefficient: it generates two new File * objects during every comparison. A slightly better technique is to - * use the <code>Kernel#test</code> method to generate the modification + * use the Kernel#test method to generate the modification * times directly. - * + * * files = Dir["*"] - * sorted = files.sort { |a,b| + * sorted = files.sort { |a, b| * test(?M, a) <=> test(?M, b) * } * sorted #=> ["mon", "tues", "wed", "thurs"] - * - * 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. - * + * + * 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. + * * sorted = Dir["*"].collect { |f| * [test(?M, f), f] * }.sort.collect { |f| f[1] } * sorted #=> ["mon", "tues", "wed", "thurs"] - * - * This is exactly what <code>sort_by</code> does internally. - * - * sorted = Dir["*"].sort_by {|f| test(?M, f)} + * + * This is exactly what #sort_by 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 -enum_sort_by(obj) - VALUE obj; +enum_sort_by(VALUE obj) { - VALUE ary; + VALUE ary, buf; + struct MEMO *memo; long i; + struct sort_by_data *data; + + RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size); - if (TYPE(obj) == T_ARRAY) { - ary = rb_ary_new2(RARRAY(obj)->len); + if (RB_TYPE_P(obj, T_ARRAY) && RARRAY_LEN(obj) <= LONG_MAX/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); + rb_ary_store(buf, SORT_BY_BUFSIZE*2-1, Qnil); + memo = rb_imemo_memo_new(0, 0, 0); + 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); + } + 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)); + } } - rb_iterate(rb_each, obj, sort_by_i, ary); - if (RARRAY(ary)->len > 1) { - qsort(RARRAY(ary)->ptr, RARRAY(ary)->len, sizeof(VALUE), sort_by_cmp); + if (RBASIC(ary)->klass) { + rb_raise(rb_eRuntimeError, "sort_by reentered"); } - for (i=0; i<RARRAY(ary)->len; i++) { - VALUE e = RARRAY(ary)->ptr[i]; - RARRAY(ary)->ptr[i] = RARRAY(e)->ptr[1]; + for (i=1; i<RARRAY_LEN(ary); i+=2) { + RARRAY_ASET(ary, i/2, RARRAY_AREF(ary, i)); } + rb_ary_resize(ary, RARRAY_LEN(ary)/2); + RBASIC_SET_CLASS_RAW(ary, rb_cArray); + return ary; } -static VALUE -all_iter_i(i, memo) - VALUE i; - NODE *memo; +#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), rb_imemo_memo_new((v1), (argc ? *argv : 0), 0)) + +#define DEFINE_ENUMFUNCS(name) \ +static VALUE enum_##name##_func(VALUE result, struct MEMO *memo); \ +\ +static VALUE \ +name##_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memo)) \ +{ \ + return enum_##name##_func(rb_enum_values_pack(argc, argv), MEMO_CAST(memo)); \ +} \ +\ +static VALUE \ +name##_iter_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memo)) \ +{ \ + return enum_##name##_func(rb_yield_values2(argc, argv), MEMO_CAST(memo)); \ +} \ +\ +static VALUE \ +name##_eqq(RB_BLOCK_CALL_FUNC_ARGLIST(i, memo)) \ +{ \ + ENUM_WANT_SVALUE(); \ + return enum_##name##_func(rb_funcallv(MEMO_CAST(memo)->v2, id_eqq, 1, &i), MEMO_CAST(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(rb_yield(i))) { - memo->u1.value = Qfalse; - rb_iter_break(); + if (!RTEST(result)) { + 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?. + * + */ + static VALUE -all_i(i, memo) - VALUE i; - NODE *memo; +enum_all(int argc, VALUE *argv, VALUE obj) { - if (!RTEST(i)) { - memo->u1.value = Qfalse; - rb_iter_break(); + struct MEMO *memo = MEMO_ENUM_NEW(Qtrue); + WARN_UNUSED_BLOCK(argc); + ENUM_BLOCK_CALL(all); + return memo->v1; +} + +DEFINE_ENUMFUNCS(any) +{ + if (RTEST(result)) { + MEMO_V1_SET(memo, Qtrue); + rb_iter_break(); } return Qnil; } /* * call-seq: - * enum.all? [{|obj| block } ] => 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> (that is - * <code>all?</code> will return <code>true</code> only if none of the - * collection members are <code>false</code> or <code>nil</code>.) - * - * %w{ ant bear cat}.all? {|word| word.length >= 3} #=> true - * %w{ ant bear cat}.all? {|word| word.length >= 4} #=> false - * [ nil, true, 99 ].all? #=> false - * + * 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?. */ static VALUE -enum_all(obj) - VALUE obj; +enum_any(int argc, VALUE *argv, VALUE obj) +{ + struct MEMO *memo = MEMO_ENUM_NEW(Qfalse); + WARN_UNUSED_BLOCK(argc); + ENUM_BLOCK_CALL(any); + 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(); + } + } + 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 */ +}; + +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" : ""); + } + return val; +} + +static int +nmin_cmp(const void *ap, const void *bp, void *_data) +{ + 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); +#undef rb_cmpint +} + +static int +nmin_block_cmp(const void *ap, const void *bp, void *_data) +{ + struct nmin_data *data = (struct nmin_data *)_data; + VALUE a = *(const VALUE *)ap, b = *(const VALUE *)bp; + VALUE cmp = rb_yield_values(2, a, b); + cmpint_reenter_check(data, cmp); + return rb_cmpint(cmp, a, b); +} + +static void +nmin_filter(struct nmin_data *data) +{ + long n; + VALUE *beg; + int eltsize; + long numelts; + + long left, right; + long store_index; + + long i, j; + + if (data->curlen <= data->n) + return; + + n = data->n; + beg = RARRAY_PTR(data->buf); + eltsize = data->by ? 2 : 1; + numelts = data->curlen; + + left = 0; + right = numelts-1; + +#define GETPTR(i) (beg+(i)*eltsize) + +#define SWAP(i, j) do { \ + VALUE tmp[2]; \ + memcpy(tmp, GETPTR(i), sizeof(VALUE)*eltsize); \ + memcpy(GETPTR(i), GETPTR(j), sizeof(VALUE)*eltsize); \ + memcpy(GETPTR(j), tmp, sizeof(VALUE)*eltsize); \ +} 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; + } + } +#undef GETPTR +#undef SWAP + + data->limit = RARRAY_AREF(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)) +{ + struct nmin_data *data = (struct nmin_data *)_data; + VALUE cmpv; + + ENUM_WANT_SVALUE(); + + if (data->by) + cmpv = enum_yield(argc, i); + else + cmpv = i; + + if (!UNDEF_P(data->limit)) { + int c = data->cmpfunc(&cmpv, &data->limit, data); + if (data->rev) + c = -c; + if (c >= 0) + return Qnil; + } + + if (data->by) + rb_ary_push(data->buf, cmpv); + rb_ary_push(data->buf, i); + + data->curlen++; + + if (data->curlen == data->bufmax) { + nmin_filter(data); + } + + return Qnil; +} + +VALUE +rb_nmin_run(VALUE obj, VALUE num, int by, int rev, int ary) { VALUE result; - NODE *memo = rb_node_newnode(NODE_MEMO, Qnil, 0, 0); + struct nmin_data data; - memo->u1.value = Qtrue; - rb_iterate(rb_each, obj, rb_block_given_p() ? all_iter_i : all_i, (VALUE)memo); - result = memo->u1.value; - rb_gc_force_recycle((VALUE)memo); + data.n = NUM2LONG(num); + if (data.n < 0) + rb_raise(rb_eArgError, "negative size (%ld)", data.n); + if (data.n == 0) + return rb_ary_new2(0); + if (LONG_MAX/4/(by ? 2 : 1) < data.n) + 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.limit = Qundef; + data.cmpfunc = by ? nmin_cmp : + rb_block_given_p() ? nmin_block_cmp : + nmin_cmp; + data.rev = rev; + data.by = by; + 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); + } + } + else { + 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); + } + else { + RARRAY_PTR_USE(result, ptr, { + ruby_qsort(ptr, RARRAY_LEN(result), sizeof(VALUE), + data.cmpfunc, (void *)&data); + }); + } + if (rev) { + rb_ary_reverse(result); + } + RBASIC_SET_CLASS(result, rb_cArray); return result; + } +/* + * 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?. + * + */ static VALUE -any_iter_i(i, memo) - VALUE i; - NODE *memo; +enum_one(int argc, VALUE *argv, VALUE obj) { - if (RTEST(rb_yield(i))) { - memo->u1.value = Qtrue; - rb_iter_break(); + struct MEMO *memo = MEMO_ENUM_NEW(Qundef); + VALUE result; + + WARN_UNUSED_BLOCK(argc); + ENUM_BLOCK_CALL(one); + result = memo->v1; + if (UNDEF_P(result)) return Qfalse; + return result; +} + +DEFINE_ENUMFUNCS(none) +{ + if (RTEST(result)) { + 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?. + * + */ +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); + return memo->v1; +} + +struct min_t { + VALUE min; +}; + static VALUE -any_i(i, memo) - VALUE i; - NODE *memo; +min_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args)) { - if (RTEST(i)) { - memo->u1.value = Qtrue; - rb_iter_break(); + struct min_t *memo = MEMO_FOR(struct min_t, args); + + ENUM_WANT_SVALUE(); + + if (UNDEF_P(memo->min)) { + memo->min = i; + } + else { + if (OPTIMIZED_CMP(i, memo->min) < 0) { + memo->min = i; + } } return Qnil; } +static VALUE +min_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, args)) +{ + VALUE cmp; + struct min_t *memo = MEMO_FOR(struct min_t, args); + + ENUM_WANT_SVALUE(); + + if (UNDEF_P(memo->min)) { + memo->min = i; + } + else { + cmp = rb_yield_values(2, i, memo->min); + if (rb_cmpint(cmp, i, memo->min) < 0) { + memo->min = i; + } + } + return Qnil; +} + + /* * call-seq: - * enum.any? [{|obj| block } ] => 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 - * that <code>false</code> or <code>nil</code>. If the block is not - * given, Ruby adds an implicit block of <code>{|obj| obj}</code> (that - * is <code>any?</code> will return <code>true</code> if at least one - * of the collection members is not <code>false</code> or - * <code>nil</code>. - * - * %w{ ant bear cat}.any? {|word| word.length >= 3} #=> true - * %w{ ant bear cat}.any? {|word| word.length >= 4} #=> true - * [ nil, true, 99 ].any? #=> true - * + * 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. + * */ static VALUE -enum_any(obj) - VALUE obj; +enum_min(int argc, VALUE *argv, VALUE obj) { + VALUE memo; + struct min_t *m = NEW_MEMO_FOR(struct min_t, memo); VALUE result; - NODE *memo = rb_node_newnode(NODE_MEMO, Qnil, 0, 0); + VALUE num; - memo->u1.value = Qfalse; - rb_iterate(rb_each, obj, rb_block_given_p() ? any_iter_i : any_i, (VALUE)memo); - result = memo->u1.value; - rb_gc_force_recycle((VALUE)memo); + if (rb_check_arity(argc, 0, 1) && !NIL_P(num = argv[0])) + return rb_nmin_run(obj, num, 0, 0, 0); + + m->min = Qundef; + if (rb_block_given_p()) { + rb_block_call(obj, id_each, 0, 0, min_ii, memo); + } + else { + rb_block_call(obj, id_each, 0, 0, min_i, memo); + } + result = m->min; + if (UNDEF_P(result)) return Qnil; return result; } +struct max_t { + VALUE max; +}; + static VALUE -min_i(i, memo) - VALUE i; - NODE *memo; +max_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args)) { - VALUE cmp; + struct max_t *memo = MEMO_FOR(struct max_t, args); + + ENUM_WANT_SVALUE(); - if (NIL_P(memo->u1.value)) { - memo->u1.value = i; + if (UNDEF_P(memo->max)) { + memo->max = i; } else { - cmp = rb_funcall(i, id_cmp, 1, memo->u1.value); - if (rb_cmpint(cmp, i, memo->u1.value) < 0) { - memo->u1.value = i; - } + if (OPTIMIZED_CMP(i, memo->max) > 0) { + memo->max = i; + } } return Qnil; } static VALUE -min_ii(i, memo) - VALUE i; - NODE *memo; +max_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, args)) { + struct max_t *memo = MEMO_FOR(struct max_t, args); VALUE cmp; - if (NIL_P(memo->u1.value)) { - memo->u1.value = i; + ENUM_WANT_SVALUE(); + + if (UNDEF_P(memo->max)) { + memo->max = i; } else { - cmp = rb_yield_values(2, i, memo->u1.value); - if (rb_cmpint(cmp, i, memo->u1.value) < 0) { - memo->u1.value = i; - } + cmp = rb_yield_values(2, i, memo->max); + if (rb_cmpint(cmp, i, memo->max) > 0) { + memo->max = i; + } } return Qnil; } - /* * call-seq: - * enum.min => obj - * enum.min {| a,b | block } => obj - * - * Returns the object in <i>enum</i> 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" + * 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. + * */ static VALUE -enum_min(obj) - VALUE obj; +enum_max(int argc, VALUE *argv, VALUE obj) { + VALUE memo; + struct max_t *m = NEW_MEMO_FOR(struct max_t, memo); VALUE result; - NODE *memo = rb_node_newnode(NODE_MEMO, Qnil, 0, 0); + VALUE num; + + if (rb_check_arity(argc, 0, 1) && !NIL_P(num = argv[0])) + return rb_nmin_run(obj, num, 0, 1, 0); - rb_iterate(rb_each, obj, rb_block_given_p() ? min_ii : min_i, (VALUE)memo); - result = memo->u1.value; - rb_gc_force_recycle((VALUE)memo); + m->max = Qundef; + if (rb_block_given_p()) { + 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); + } + result = m->max; + if (UNDEF_P(result)) return Qnil; return result; } +struct minmax_t { + VALUE min; + VALUE max; + VALUE last; +}; + +static void +minmax_i_update(VALUE i, VALUE j, struct minmax_t *memo) +{ + int n; + + if (UNDEF_P(memo->min)) { + 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; + } + } +} + +static VALUE +minmax_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, _memo)) +{ + struct minmax_t *memo = MEMO_FOR(struct minmax_t, _memo); + int n; + VALUE j; + + ENUM_WANT_SVALUE(); + + if (UNDEF_P(memo->last)) { + memo->last = i; + return Qnil; + } + j = memo->last; + memo->last = Qundef; + + n = OPTIMIZED_CMP(j, i); + if (n == 0) + i = j; + else if (n < 0) { + VALUE tmp; + tmp = i; + i = j; + j = tmp; + } + + minmax_i_update(i, j, memo); + + return Qnil; +} + +static void +minmax_ii_update(VALUE i, VALUE j, struct minmax_t *memo) +{ + int n; + + if (UNDEF_P(memo->min)) { + 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; + } + } +} + +static VALUE +minmax_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, _memo)) +{ + struct minmax_t *memo = MEMO_FOR(struct minmax_t, _memo); + int n; + VALUE j; + + ENUM_WANT_SVALUE(); + + if (UNDEF_P(memo->last)) { + memo->last = i; + return Qnil; + } + j = memo->last; + memo->last = Qundef; + + n = rb_cmpint(rb_yield_values(2, j, i), j, i); + if (n == 0) + i = j; + else if (n < 0) { + VALUE tmp; + tmp = i; + i = j; + j = tmp; + } + + minmax_ii_update(i, j, memo); + + return Qnil; +} + /* * call-seq: - * enum.max => obj - * enum.max {| a,b | block } => obj - * - * Returns the object in <i>enum</i> 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" + * 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] + * + * 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. + * */ static VALUE -max_i(i, memo) - VALUE i; - NODE *memo; +enum_minmax(VALUE obj) { - VALUE cmp; + VALUE memo; + struct minmax_t *m = NEW_MEMO_FOR(struct minmax_t, memo); - if (NIL_P(memo->u1.value)) { - memo->u1.value = i; + m->min = Qundef; + m->last = Qundef; + 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); } else { - cmp = rb_funcall(i, id_cmp, 1, memo->u1.value); - if (rb_cmpint(cmp, i, memo->u1.value) > 0) { - memo->u1.value = i; - } + rb_block_call(obj, id_each, 0, 0, minmax_i, memo); + if (!UNDEF_P(m->last)) + minmax_i_update(m->last, m->last, m); + } + if (!UNDEF_P(m->min)) { + return rb_assoc_new(m->min, m->max); + } + return rb_assoc_new(Qnil, Qnil); +} + +static VALUE +min_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args)) +{ + 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); + } + else if (OPTIMIZED_CMP(v, memo->v1) < 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 + * + * With a block given and positive integer argument +n+ given, + * returns an array containing the +n+ elements + * for which the block returns minimum values: + * + * (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 } + * # => [] + * + * Returns an Enumerator if no block is given. + * + * Related: #min, #minmax, #max_by. + * + */ + static VALUE -max_ii(i, memo) - VALUE i; - NODE *memo; +enum_min_by(int argc, VALUE *argv, VALUE obj) { - VALUE cmp; + struct MEMO *memo; + VALUE num; + + rb_check_arity(argc, 0, 1); + + RETURN_SIZED_ENUMERATOR(obj, argc, argv, enum_size); + + if (argc && !NIL_P(num = argv[0])) + return rb_nmin_run(obj, num, 1, 0, 0); + + memo = rb_imemo_memo_new(Qundef, Qnil, 0); + rb_block_call(obj, id_each, 0, 0, min_by_i, (VALUE)memo); + return memo->v2; +} + +static VALUE +max_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args)) +{ + 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); + } + else if (OPTIMIZED_CMP(v, memo->v1) > 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. + * + */ + +static VALUE +enum_max_by(int argc, VALUE *argv, VALUE obj) +{ + struct MEMO *memo; + VALUE num; + + rb_check_arity(argc, 0, 1); + + RETURN_SIZED_ENUMERATOR(obj, argc, argv, enum_size); + + if (argc && !NIL_P(num = argv[0])) + return rb_nmin_run(obj, num, 1, 1, 0); + + memo = rb_imemo_memo_new(Qundef, Qnil, 0); + rb_block_call(obj, id_each, 0, 0, max_by_i, (VALUE)memo); + return memo->v2; +} - if (NIL_P(memo->u1.value)) { - memo->u1.value = i; +struct minmax_by_t { + VALUE min_bv; + VALUE max_bv; + VALUE min; + VALUE max; + VALUE last_bv; + VALUE last; +}; + +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; } else { - cmp = rb_yield_values(2, i, memo->u1.value); - if (rb_cmpint(cmp, i, memo->u1.value) > 0) { - memo->u1.value = i; - } + 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; + } + } +} + +static VALUE +minmax_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, _memo)) +{ + struct minmax_by_t *memo = MEMO_FOR(struct minmax_by_t, _memo); + VALUE vi, vj, j; + int n; + + ENUM_WANT_SVALUE(); + + vi = enum_yield(argc, i); + + if (UNDEF_P(memo->last_bv)) { + memo->last_bv = vi; + memo->last = i; + return Qnil; + } + vj = memo->last_bv; + j = memo->last; + memo->last_bv = Qundef; + + n = OPTIMIZED_CMP(vj, vi); + if (n == 0) { + i = j; + vi = vj; } + else if (n < 0) { + VALUE tmp; + tmp = i; + i = j; + j = tmp; + tmp = vi; + vi = vj; + vj = tmp; + } + + minmax_by_i_update(vi, vj, i, j, memo); + return Qnil; } /* * call-seq: - * enum.max => obj - * enum.max {|a,b| block } => obj - * - * 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" - */ + * 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: + * + * (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 an Enumerator if no block is given. + * + * Related: #max_by, #minmax, #min_by. + * + */ static VALUE -enum_max(obj) - VALUE obj; +enum_minmax_by(VALUE obj) { - VALUE result; - NODE *memo = rb_node_newnode(NODE_MEMO, Qnil, 0, 0); + VALUE memo; + struct minmax_by_t *m = NEW_MEMO_FOR(struct minmax_by_t, memo); - rb_iterate(rb_each, obj, rb_block_given_p() ? max_ii : max_i, (VALUE)memo); - result = memo->u1.value; - rb_gc_force_recycle((VALUE)memo); - return result; + RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size); + + m->min_bv = Qundef; + m->max_bv = Qundef; + m->min = Qnil; + m->max = Qnil; + 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)) + 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); } static VALUE -member_i(item, memo) - VALUE item; - NODE *memo; +member_i(RB_BLOCK_CALL_FUNC_ARGLIST(iter, args)) { - if (rb_equal(item, memo->u1.value)) { - memo->u2.value = Qtrue; - rb_iter_break(); + 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(); } return Qnil; } /* * call-seq: - * enum.include?(obj) => true or false - * enum.member?(obj) => true or false - * - * Returns <code>true</code> if any member of <i>enum</i> equals - * <i>obj</i>. Equality is tested using <code>==</code>. - * - * IO.constants.include? "SEEK_SET" #=> true - * IO.constants.include? "SEEK_NO_FURTHER" #=> false - * + * include?(object) -> true or false + * + * Returns whether for any element <tt>object == element</tt>: + * + * (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 + * */ static VALUE -enum_member(obj, val) - VALUE obj, val; +enum_member(VALUE obj, VALUE val) { - VALUE result; - NODE *memo = rb_node_newnode(NODE_MEMO, val, Qfalse, 0); + struct MEMO *memo = rb_imemo_memo_new(val, Qfalse, 0); - rb_iterate(rb_each, obj, member_i, (VALUE)memo); - result = memo->u2.value; - rb_gc_force_recycle((VALUE)memo); - return result; + rb_block_call(obj, id_each, 0, 0, member_i, (VALUE)memo); + return memo->v2; +} + +static VALUE +each_with_index_i(RB_BLOCK_CALL_FUNC_ARGLIST(_, index)) +{ + struct vm_ifunc *ifunc = rb_current_ifunc(); + ifunc->data = (const void *)rb_int_succ(index); + + return rb_yield_values(2, rb_enum_values_pack(argc, argv), index); +} + +/* + * 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} + * + * 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} + * + * 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]]] + * + * With no block given, returns an Enumerator. + * + */ + +static VALUE +enum_each_with_index(int argc, VALUE *argv, VALUE obj) +{ + RETURN_SIZED_ENUMERATOR(obj, argc, argv, enum_size); + + rb_block_call(obj, id_each, argc, argv, each_with_index_i, INT2FIX(0)); + return obj; +} + + +/* + * call-seq: + * reverse_each(*args) {|element| ... } -> self + * reverse_each(*args) -> enumerator + * + * With a block given, calls the block with each element, + * but in reverse order; returns +self+: + * + * a = [] + * (1..4).reverse_each {|element| a.push(-element) } # => 1..4 + * a # => [-4, -3, -2, -1] + * + * a = [] + * %w[a b c d].reverse_each {|element| a.push(element) } + * # => ["a", "b", "c", "d"] + * a # => ["d", "c", "b", "a"] + * + * 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. + * + */ + +static VALUE +enum_reverse_each(int argc, VALUE *argv, VALUE obj) +{ + VALUE ary; + long len; + + 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; + } + } + + return obj; } + static VALUE -each_with_index_i(val, memo) - VALUE val; - NODE *memo; +each_val_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, p)) { - rb_yield_values(2, val, INT2FIX(memo->u3.cnt)); - memo->u3.cnt++; + ENUM_WANT_SVALUE(); + enum_yield(argc, i); return Qnil; } /* * call-seq: - * enum.each_with_index {|obj, i| block } -> nil - * - * Calls <em>block</em> with two arguments, the item and its index, for - * each item in <i>enum</i>. - * - * hash = Hash.new - * %w(cat dog wombat).each_with_index {|item, index| - * hash[item] = index - * } - * hash #=> {"cat"=>0, "wombat"=>2, "dog"=>1} - * + * 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: + * + * 1 + * [1, 2] + * nil + * + * With no block given, returns an Enumerator. + * */ static VALUE -enum_each_with_index(obj) - VALUE obj; +enum_each_entry(int argc, VALUE *argv, VALUE obj) +{ + RETURN_SIZED_ENUMERATOR(obj, argc, argv, enum_size); + rb_block_call(obj, id_each, argc, argv, each_val_i, 0); + return obj; +} + +static VALUE +add_int(VALUE x, long n) +{ + const VALUE y = LONG2NUM(n); + if (RB_INTEGER_TYPE_P(x)) return rb_int_plus(x, y); + return rb_funcallv(x, '+', 1, &y); +} + +static VALUE +div_int(VALUE x, long n) +{ + const VALUE y = LONG2NUM(n); + if (RB_INTEGER_TYPE_P(x)) return rb_int_idiv(x, y); + return rb_funcallv(x, id_div, 1, &y); +} + +#define dont_recycle_block_arg(arity) ((arity) == 1 || (arity) < 0) + +static VALUE +each_slice_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, m)) +{ + struct MEMO *memo = MEMO_CAST(m); + VALUE ary = memo->v1; + VALUE v = Qnil; + long size = memo->u3.cnt; + ENUM_WANT_SVALUE(); + + rb_ary_push(ary, i); + + if (RARRAY_LEN(ary) == size) { + v = rb_yield(ary); + + if (memo->v2) { + MEMO_V1_SET(memo, rb_ary_new2(size)); + } + else { + rb_ary_clear(ary); + } + } + + return v; +} + +static VALUE +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; + } + + n = add_int(size, slice_size-1); + return div_int(n, slice_size); +} + +/* + * call-seq: + * each_slice(n) { ... } -> self + * each_slice(n) -> enumerator + * + * Calls the block with each successive disjoint +n+-tuple of elements; + * returns +self+: + * + * a = [] + * (1..10).each_slice(3) {|tuple| a.push(tuple) } + * a # => [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]] + * + * 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. + * + */ +static VALUE +enum_each_slice(VALUE obj, VALUE n) { - NODE *memo = rb_node_newnode(NODE_MEMO, 0, 0, 0); + long size = NUM2LONG(n); + VALUE ary; + struct MEMO *memo; + int arity; + + if (size <= 0) rb_raise(rb_eArgError, "invalid slice size"); + RETURN_SIZED_ENUMERATOR(obj, 1, &n, enum_each_slice_size); + size = limit_by_enum_size(obj, size); + ary = rb_ary_new2(size); + arity = rb_block_arity(); + memo = rb_imemo_memo_new(ary, dont_recycle_block_arg(arity), size); + rb_block_call(obj, id_each, 0, 0, each_slice_i, (VALUE)memo); + ary = memo->v1; + if (RARRAY_LEN(ary) > 0) rb_yield(ary); - rb_iterate(rb_each, obj, each_with_index_i, (VALUE)memo); - rb_gc_force_recycle((VALUE)memo); return obj; } static VALUE -zip_i(val, memo) - VALUE val; - NODE *memo; +each_cons_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args)) +{ + struct MEMO *memo = MEMO_CAST(args); + VALUE ary = memo->v1; + VALUE v = Qnil; + long size = memo->u3.cnt; + ENUM_WANT_SVALUE(); + + if (RARRAY_LEN(ary) == size) { + 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); + } + return v; +} + +static VALUE +enum_each_cons_size(VALUE obj, VALUE args, VALUE eobj) +{ + 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; + + n = add_int(size, 1 - cons_size); + return (OPTIMIZED_CMP(n, zero) == -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. + * + */ +static VALUE +enum_each_cons(VALUE obj, VALUE n) { - VALUE result = memo->u1.value; - VALUE args = memo->u2.value; - int idx = memo->u3.cnt++; + long size = NUM2LONG(n); + struct MEMO *memo; + int arity; + + 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; + memo = rb_imemo_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; +} + +static VALUE +each_with_object_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memo)) +{ + ENUM_WANT_SVALUE(); + return rb_yield_values(2, i, memo); +} + +/* + * call-seq: + * each_with_object(object) { |(*args), memo_object| ... } -> object + * each_with_object(object) -> enumerator + * + * Calls the block once for each element, passing both the element + * and the given object: + * + * (1..4).each_with_object([]) {|i, a| a.push(i**2) } + * # => [1, 4, 9, 16] + * + * {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. + * + */ +static VALUE +enum_each_with_object(VALUE obj, VALUE memo) +{ + RETURN_SIZED_ENUMERATOR(obj, 1, &memo, enum_size); + + rb_block_call(obj, id_each, 0, 0, each_with_object_i, memo); + + return memo; +} + +static VALUE +zip_ary(RB_BLOCK_CALL_FUNC_ARGLIST(val, memoval)) +{ + struct MEMO *memo = (struct MEMO *)memoval; + VALUE result = memo->v1; + VALUE args = memo->v2; + long n = memo->u3.cnt++; VALUE tmp; int i; - tmp = rb_ary_new2(RARRAY(args)->len + 1); - rb_ary_store(tmp, 0, val); - for (i=0; i<RARRAY(args)->len; i++) { - rb_ary_push(tmp, rb_ary_entry(RARRAY(args)->ptr[i], idx)); + 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); + + if (RARRAY_LEN(e) <= n) { + rb_ary_push(tmp, Qnil); + } + else { + rb_ary_push(tmp, RARRAY_AREF(e, n)); + } } - if (rb_block_given_p()) { - rb_yield(tmp); + if (NIL_P(result)) { + enum_yield_array(tmp); + } + else { + rb_ary_push(result, tmp); + } + + RB_GC_GUARD(args); + + return Qnil; +} + +static VALUE +call_next(VALUE w) +{ + VALUE *v = (VALUE *)w; + return v[0] = rb_funcallv(v[1], id_next, 0, 0); +} + +static VALUE +call_stop(VALUE w, VALUE _) +{ + VALUE *v = (VALUE *)w; + return v[0] = Qundef; +} + +static VALUE +zip_i(RB_BLOCK_CALL_FUNC_ARGLIST(val, memoval)) +{ + struct MEMO *memo = (struct MEMO *)memoval; + VALUE result = memo->v1; + VALUE args = memo->v2; + VALUE tmp; + int i; + + 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(result)) { + enum_yield_array(tmp); } else { - rb_ary_push(result, tmp); + rb_ary_push(result, tmp); } + + RB_GC_GUARD(args); + return Qnil; } /* * call-seq: - * enum.zip(arg, ...) => array - * enum.zip(arg, ...) {|arr| block } => nil - * - * Converts any arguments to arrays, then merges elements of - * <i>enum</i> with corresponding elements from each argument. This - * generates a sequence of <code>enum#size</code> <em>n</em>-element - * arrays, where <em>n</em> is one more that the count of arguments. If - * the size of any arguemnt is less than <code>enum#size</code>, - * <code>nil</code> values are supplied. If a block given, it is - * invoked for each output array, otherwise an array of arrays is - * returned. - * - * a = [ 4, 5, 6 ] - * b = [ 7, 8, 9 ] - * - * (1..3).zip(a, b) #=> [[1, 4, 7], [2, 5, 8], [3, 6, 9]] - * "cat\ndog".zip([1]) #=> [["cat\n", 1], ["dog", nil]] - * (1..3).zip #=> [[1], [2], [3]] - * + * 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] + * */ static VALUE -enum_zip(argc, argv, obj) - int argc; - VALUE *argv; - VALUE obj; +enum_zip(int argc, VALUE *argv, VALUE obj) { int i; - VALUE result; - NODE *memo; + ID conv; + struct MEMO *memo; + VALUE result = Qnil; + VALUE args = rb_ary_new4(argc, argv); + int allary = TRUE; + argv = RARRAY_PTR(args); for (i=0; i<argc; i++) { - argv[i] = rb_convert_type(argv[i], T_ARRAY, "Array", "to_a"); + 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])); + } + argv[i] = rb_funcallv(argv[i], conv, 1, &sym_each); + } + } + if (!rb_block_given_p()) { + result = rb_ary_new(); + } + + /* TODO: use NODE_DOT2 as memo(v, v, -) */ + memo = rb_imemo_memo_new(result, args, 0); + rb_block_call(obj, id_each, 0, 0, allary ? zip_ary : zip_i, (VALUE)memo); + + return result; +} + +static VALUE +take_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args)) +{ + struct MEMO *memo = MEMO_CAST(args); + rb_ary_push(memo->v1, rb_enum_values_pack(argc, argv)); + if (--memo->u3.cnt == 0) rb_iter_break(); + return Qnil; +} + +/* + * call-seq: + * take(n) -> array + * + * For non-negative integer +n+, returns the first +n+ elements: + * + * r = (1..4) + * r.take(2) # => [1, 2] + * r.take(0) # => [] + * + * h = {foo: 0, bar: 1, baz: 2, bat: 3} + * h.take(2) # => [[:foo, 0], [:bar, 1]] + * + */ + +static VALUE +enum_take(VALUE obj, VALUE n) +{ + struct MEMO *memo; + VALUE result; + long len = NUM2LONG(n); + + if (len < 0) { + rb_raise(rb_eArgError, "attempt to take negative size"); } - result = rb_block_given_p() ? Qnil : rb_ary_new(); - memo = rb_node_newnode(NODE_MEMO, result, rb_ary_new4(argc, argv), 0); - rb_iterate(rb_each, obj, zip_i, (VALUE)memo); + if (len == 0) return rb_ary_new2(0); + result = rb_ary_new2(len); + memo = rb_imemo_memo_new(result, 0, len); + rb_block_call(obj, id_each, 0, 0, take_i, (VALUE)memo); return result; } + +static VALUE +take_while_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary)) +{ + if (!RTEST(rb_yield_values2(argc, argv))) rb_iter_break(); + rb_ary_push(ary, rb_enum_values_pack(argc, argv)); + return Qnil; +} + +/* + * 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: + * + * + * (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]] + * + * With no block given, returns an Enumerator. + * + */ + +static VALUE +enum_take_while(VALUE obj) +{ + VALUE ary; + + RETURN_ENUMERATOR(obj, 0, 0); + ary = rb_ary_new(); + rb_block_call(obj, id_each, 0, 0, take_while_i, ary); + return ary; +} + +static VALUE +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)); + } + else { + memo->u3.cnt--; + } + return Qnil; +} + +/* + * call-seq: + * drop(n) -> array + * + * For positive integer +n+, returns an array containing + * all but the first +n+ elements: + * + * 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]] + * + */ + +static VALUE +enum_drop(VALUE obj, VALUE n) +{ + VALUE result; + struct MEMO *memo; + long len = NUM2LONG(n); + + if (len < 0) { + rb_raise(rb_eArgError, "attempt to drop negative size"); + } + + result = rb_ary_new(); + memo = rb_imemo_memo_new(result, 0, len); + rb_block_call(obj, id_each, 0, 0, drop_i, (VALUE)memo); + return result; +} + + +static VALUE +drop_while_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args)) +{ + struct MEMO *memo = MEMO_CAST(args); + ENUM_WANT_SVALUE(); + + if (!memo->u3.state && !RTEST(enum_yield(argc, i))) { + memo->u3.state = TRUE; + } + if (memo->u3.state) { + 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: + * + * + * (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]] + * + * With no block given, returns an Enumerator. + * + * e = (1..4).drop_while + * p e #=> #<Enumerator: 1..4:drop_while> + * i = e.next; p i; e.feed(i < 3) #=> 1 + * i = e.next; p i; e.feed(i < 3) #=> 2 + * i = e.next; p i; e.feed(i < 3) #=> 3 + * begin + * e.next + * rescue StopIteration + * p $!.result #=> [3, 4] + * end + * + */ + +static VALUE +enum_drop_while(VALUE obj) +{ + VALUE result; + struct MEMO *memo; + + RETURN_ENUMERATOR(obj, 0, 0); + result = rb_ary_new(); + memo = rb_imemo_memo_new(result, 0, FALSE); + rb_block_call(obj, id_each, 0, 0, drop_while_i, (VALUE)memo); + return result; +} + +static VALUE +cycle_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary)) +{ + ENUM_WANT_SVALUE(); + + rb_ary_push(ary, argc > 1 ? i : rb_ary_new_from_values(argc, argv)); + enum_yield(argc, i); + return Qnil; +} + +static VALUE +enum_cycle_size(VALUE self, VALUE args, VALUE eobj) +{ + long mul = 0; + VALUE n = Qnil; + VALUE size; + + if (args && (RARRAY_LEN(args) > 0)) { + 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 (mul <= 0) return INT2FIX(0); + n = LONG2FIX(mul); + return rb_funcallv(size, '*', 1, &n); +} + +/* + * call-seq: + * cycle(n = nil) {|element| ...} -> nil + * cycle(n = nil) -> 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+: + * + * 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]] + * + * If count is zero or negative, does not call the block. + * + * When called with a block and +n+ is +nil+, cycles forever. + * + * When no block is given, returns an Enumerator. + * + */ + +static VALUE +enum_cycle(int argc, VALUE *argv, VALUE obj) +{ + VALUE ary; + VALUE nv = Qnil; + long n, i, len; + + rb_check_arity(argc, 0, 1); + + RETURN_SIZED_ENUMERATOR(obj, argc, argv, enum_cycle_size); + if (!argc || NIL_P(nv = argv[0])) { + n = -1; + } + else { + n = NUM2LONG(nv); + if (n <= 0) return Qnil; + } + ary = rb_ary_new(); + RBASIC_CLEAR_CLASS(ary); + rb_block_call(obj, id_each, 0, 0, cycle_i, ary); + len = RARRAY_LEN(ary); + if (len == 0) return Qnil; + while (n < 0 || 0 < --n) { + for (i=0; i<len; i++) { + enum_yield_array(RARRAY_AREF(ary, i)); + } + } + return Qnil; +} + +struct chunk_arg { + VALUE categorize; + VALUE prev_value; + VALUE prev_elts; + VALUE yielder; +}; + +static VALUE +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); + + ENUM_WANT_SVALUE(); + + v = rb_funcallv(argp->categorize, id_call, 1, &i); + + if (v == alone) { + if (!NIL_P(argp->prev_value)) { + 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)); + 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); + 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"); + } + else { + if (NIL_P(argp->prev_value)) { + argp->prev_value = v; + argp->prev_elts = rb_ary_new3(1, i); + } + else { + if (rb_equal(argp->prev_value, v)) { + rb_ary_push(argp->prev_elts, i); + } + else { + 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); + } + } + } + return Qnil; +} + +static VALUE +chunk_i(RB_BLOCK_CALL_FUNC_ARGLIST(yielder, enumerator)) +{ + VALUE enumerable; + 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); + memo->prev_value = Qnil; + memo->prev_elts = Qnil; + memo->yielder = yielder; + + 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); + } + 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: + * + * So that: + * + * - 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. + * + * Example: + * + * 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 chunk: + * + * a = [0, 0, 1, 1] + * e = a.chunk{|i| i.even? ? :_alone : true } + * e.to_a # => [[:_alone, [0]], [:_alone, [0]], [true, [1, 1]]] + * + * For example, you can put each line that contains a URL into its own chunk: + * + * pattern = /http/ + * open(filename) { |f| + * f.chunk { |line| line =~ pattern ? :_alone : true }.each { |key, lines| + * pp lines + * } + * } + * + * You can use the special symbol <tt>:_separator</tt> or +nil+ + * to force an element to be ignored (not included in any chunk): + * + * a = [0, 0, -1, 1, 1] + * e = a.chunk{|i| i < 0 ? :_separator : true } + * e.to_a # => [[true, [0, 0]], [true, [1, 1]]] + * + * Note that the separator does end the chunk: + * + * 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]]] + * + * For example, the sequence of hyphens in svn log can be eliminated as follows: + * + * sep = "-"*72 + "\n" + * IO.popen("svn log README") { |f| + * f.chunk { |line| + * line != sep || nil + * }.each { |_, lines| + * pp lines + * } + * } + * #=> ["r20018 | knu | 2008-10-29 13:20:42 +0900 (Wed, 29 Oct 2008) | 2 lines\n", + * # "\n", + * # "* README, README.ja: Update the portability section.\n", + * # "\n"] + * # ["r16725 | knu | 2008-05-31 23:34:23 +0900 (Sat, 31 May 2008) | 2 lines\n", + * # "\n", + * # "* README, README.ja: Add a note about default C flags.\n", + * # "\n"] + * # ... + * + * Paragraphs separated by empty lines can be parsed as follows: + * + * File.foreach("README").chunk { |line| + * /\A\s*\z/ !~ line || nil + * }.each { |_, lines| + * pp lines + * } + * + */ +static VALUE +enum_chunk(VALUE enumerable) +{ + VALUE enumerator; + + 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_block_call(enumerator, idInitialize, 0, 0, chunk_i, enumerator); + return enumerator; +} + + +struct slicebefore_arg { + VALUE sep_pred; + VALUE sep_pat; + VALUE prev_elts; + VALUE yielder; +}; + +static VALUE +slicebefore_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, _argp)) +{ + struct slicebefore_arg *argp = MEMO_FOR(struct slicebefore_arg, _argp); + VALUE header_p; + + ENUM_WANT_SVALUE(); + + if (!NIL_P(argp->sep_pat)) + header_p = rb_funcallv(argp->sep_pat, id_eqq, 1, &i); + else + header_p = rb_funcallv(argp->sep_pred, id_call, 1, &i); + if (RTEST(header_p)) { + if (!NIL_P(argp->prev_elts)) + rb_funcallv(argp->yielder, id_lshift, 1, &argp->prev_elts); + argp->prev_elts = rb_ary_new3(1, i); + } + else { + if (NIL_P(argp->prev_elts)) + argp->prev_elts = rb_ary_new3(1, i); + else + rb_ary_push(argp->prev_elts, i); + } + + return Qnil; +} + +static VALUE +slicebefore_i(RB_BLOCK_CALL_FUNC_ARGLIST(yielder, enumerator)) +{ + VALUE enumerable; + 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; + memo->prev_elts = Qnil; + memo->yielder = yielder; + + rb_block_call(enumerable, id_each, 0, 0, slicebefore_ii, arg); + memo = MEMO_FOR(struct slicebefore_arg, arg); + if (!NIL_P(memo->prev_elts)) + rb_funcallv(memo->yielder, id_lshift, 1, &memo->prev_elts); + return Qnil; +} + +/* + * 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"] + * + * 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: + * + * [1] + * [2, 3, 4, 5] + * [6, 7, 8, 9] + * [10, 11, 12, 13] + * [14, 15, 16, 17] + * [18, 19, 20] + * + * Other methods of the Enumerator class and Enumerable module, + * such as +to_a+, +map+, etc., are also usable. + * + * For example, iteration over ChangeLog entries can be implemented as + * follows: + * + * # iterate over ChangeLog entries. + * open("ChangeLog") { |f| + * f.slice_before(/\A\S/).each { |e| pp e } + * } + * + * # same as above. block is used instead of pattern argument. + * open("ChangeLog") { |f| + * 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: + * + * IO.popen([{"LC_ALL"=>"C"}, "svn", "proplist", "-R"]) { |f| + * f.lines.slice_before(/\AProp/).each { |lines| p lines } + * } + * #=> ["Properties on '.':\n", " svn:ignore\n", " svk:merge\n"] + * # ["Properties on 'goruby.c':\n", " svn:eol-style\n"] + * # ["Properties on 'complex.c':\n", " svn:mime-type\n", " svn:eol-style\n"] + * # ["Properties on 'regparse.c':\n", " svn:eol-style\n"] + * # ... + * + * If the block needs to maintain state over multiple elements, + * local variables can be used. + * For example, three or more consecutive increasing numbers can be squashed + * as follows (see +chunk_while+ for a better way): + * + * a = [0, 2, 3, 4, 6, 7, 9] + * prev = a[0] + * p a.slice_before { |e| + * prev, prev2 = e, prev + * prev2 + 1 != e + * }.map { |es| + * es.length <= 2 ? es.join(",") : "#{es.first}-#{es.last}" + * }.join(",") + * #=> "0,2-4,6,7,9" + * + * However local variables should be used carefully + * if the result enumerator is enumerated twice or more. + * The local variables should be initialized for each enumeration. + * Enumerator.new can be used to do it. + * + * # Word wrapping. This assumes all characters have same width. + * def wordwrap(words, maxwidth) + * Enumerator.new {|y| + * # cols is initialized in Enumerator.new. + * cols = 0 + * words.slice_before { |w| + * cols += 1 if cols != 0 + * cols += w.length + * if maxwidth < cols + * cols = w.length + * true + * else + * false + * end + * }.each {|ws| y.yield ws } + * } + * end + * text = (1..20).to_a.join(" ") + * enum = wordwrap(text.split(/\s+/), 10) + * puts "-"*10 + * enum.each { |ws| puts ws.join(" ") } # first enumeration. + * puts "-"*10 + * enum.each { |ws| puts ws.join(" ") } # second enumeration generates same result as the first. + * puts "-"*10 + * #=> ---------- + * # 1 2 3 4 5 + * # 6 7 8 9 10 + * # 11 12 13 + * # 14 15 16 + * # 17 18 19 + * # 20 + * # ---------- + * # 1 2 3 4 5 + * # 6 7 8 9 10 + * # 11 12 13 + * # 14 15 16 + * # 17 18 19 + * # 20 + * # ---------- + * + * mbox contains series of mails which start with Unix From line. + * So each mail can be extracted by slice before Unix From line. + * + * # parse mbox + * open("mbox") { |f| + * f.slice_before { |line| + * line.start_with? "From " + * }.each { |mail| + * unix_from = mail.shift + * i = mail.index("\n") + * header = mail[0...i] + * body = mail[(i+1)..-1] + * body.pop if body.last == "\n" + * fields = header.slice_before { |line| !" \t".include?(line[0]) }.to_a + * p unix_from + * pp fields + * pp body + * } + * } + * + * # split mails in mbox (slice before Unix From line after an empty line) + * open("mbox") { |f| + * emp = true + * f.slice_before { |line| + * prevemp = emp + * emp = line == "\n" + * prevemp && line.start_with?("From ") + * }.each { |mail| + * mail.pop if mail.last == "\n" + * pp mail + * } + * } + * + */ +static VALUE +enum_slice_before(int argc, VALUE *argv, VALUE enumerable) +{ + VALUE enumerator; + + if (rb_block_given_p()) { + 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()); + } + 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, id_slicebefore_enumerable, enumerable); + rb_block_call(enumerator, idInitialize, 0, 0, slicebefore_i, enumerator); + return enumerator; +} + + +struct sliceafter_arg { + VALUE pat; + VALUE pred; + VALUE prev_elts; + VALUE yielder; +}; + +static VALUE +sliceafter_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, _memo)) +{ +#define UPDATE_MEMO ((void)(memo = MEMO_FOR(struct sliceafter_arg, _memo))) + struct sliceafter_arg *memo; + int split_p; + UPDATE_MEMO; + + ENUM_WANT_SVALUE(); + + if (NIL_P(memo->prev_elts)) { + memo->prev_elts = rb_ary_new3(1, i); + } + else { + rb_ary_push(memo->prev_elts, i); + } + + if (NIL_P(memo->pred)) { + split_p = RTEST(rb_funcallv(memo->pat, id_eqq, 1, &i)); + UPDATE_MEMO; + } + else { + split_p = RTEST(rb_funcallv(memo->pred, id_call, 1, &i)); + UPDATE_MEMO; + } + + if (split_p) { + rb_funcallv(memo->yielder, id_lshift, 1, &memo->prev_elts); + UPDATE_MEMO; + memo->prev_elts = Qnil; + } + + return Qnil; +#undef UPDATE_MEMO +} + +static VALUE +sliceafter_i(RB_BLOCK_CALL_FUNC_ARGLIST(yielder, enumerator)) +{ + VALUE enumerable; + 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); + memo->prev_elts = Qnil; + memo->yielder = yielder; + + rb_block_call(enumerable, id_each, 0, 0, sliceafter_ii, arg); + memo = MEMO_FOR(struct sliceafter_arg, arg); + if (!NIL_P(memo->prev_elts)) + rb_funcallv(memo->yielder, id_lshift, 1, &memo->prev_elts); + return Qnil; +} + +/* + * call-seq: + * enum.slice_after(pattern) -> an_enumerator + * enum.slice_after { |elt| bool } -> an_enumerator + * + * Creates an enumerator for each chunked elements. + * The ends 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 end of a + * chunk. + * + * The <code>===</code> and _block_ is called from the first element to the last + * element of _enum_. + * + * The result enumerator yields the chunked elements as an array. + * So +each+ method can be called as follows: + * + * enum.slice_after(pattern).each { |ary| ... } + * enum.slice_after { |elt| bool }.each { |ary| ... } + * + * Other methods of the Enumerator class and Enumerable module, + * such as +map+, etc., are also usable. + * + * For example, continuation lines (lines end with backslash) can be + * concatenated as follows: + * + * lines = ["foo\n", "bar\\\n", "baz\n", "\n", "qux\n"] + * e = lines.slice_after(/(?<!\\)\n\z/) + * p e.to_a + * #=> [["foo\n"], ["bar\\\n", "baz\n"], ["\n"], ["qux\n"]] + * p e.map {|ll| ll[0...-1].map {|l| l.sub(/\\\n\z/, "") }.join + ll.last } + * #=>["foo\n", "barbaz\n", "\n", "qux\n"] + * + */ + +static VALUE +enum_slice_after(int argc, VALUE *argv, VALUE enumerable) +{ + VALUE enumerator; + VALUE pat = Qnil, pred = Qnil; + + if (rb_block_given_p()) { + if (0 < argc) + rb_raise(rb_eArgError, "both pattern and block are given"); + pred = rb_block_proc(); + } + else { + rb_scan_args(argc, argv, "1", &pat); + } + + 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_block_call(enumerator, idInitialize, 0, 0, sliceafter_i, enumerator); + return enumerator; +} + +struct slicewhen_arg { + VALUE pred; + VALUE prev_elt; + VALUE prev_elts; + VALUE yielder; + int inverted; /* 0 for slice_when and 1 for chunk_while. */ +}; + +static VALUE +slicewhen_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, _memo)) +{ +#define UPDATE_MEMO ((void)(memo = MEMO_FOR(struct slicewhen_arg, _memo))) + struct slicewhen_arg *memo; + int split_p; + UPDATE_MEMO; + + ENUM_WANT_SVALUE(); + + if (UNDEF_P(memo->prev_elt)) { + /* 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; + split_p = RTEST(rb_funcallv(memo->pred, id_call, 2, args)); + UPDATE_MEMO; + + if (memo->inverted) + split_p = !split_p; + + if (split_p) { + rb_funcallv(memo->yielder, id_lshift, 1, &memo->prev_elts); + UPDATE_MEMO; + memo->prev_elts = rb_ary_new3(1, i); + } + else { + rb_ary_push(memo->prev_elts, i); + } + + memo->prev_elt = i; + } + + return Qnil; +#undef UPDATE_MEMO +} + +static VALUE +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); + + enumerable = rb_ivar_get(enumerator, id_slicewhen_enum); + memo->pred = rb_attr_get(enumerator, id_slicewhen_pred); + memo->prev_elt = Qundef; + memo->prev_elts = Qnil; + memo->yielder = yielder; + memo->inverted = RTEST(rb_attr_get(enumerator, id_slicewhen_inverted)); + + rb_block_call(enumerable, id_each, 0, 0, slicewhen_ii, arg); + memo = MEMO_FOR(struct slicewhen_arg, arg); + if (!NIL_P(memo->prev_elts)) + rb_funcallv(memo->yielder, id_lshift, 1, &memo->prev_elts); + return Qnil; +} + /* - * 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. + * call-seq: + * enum.slice_when {|elt_before, elt_after| bool } -> an_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, + * _elt_before_ and _elt_after_, + * in the receiver enumerator. + * This method split chunks between _elt_before_ and _elt_after_ where + * the block returns <code>true</code>. + * + * The block is called the length of the receiver enumerator minus one. + * + * The result enumerator yields the chunked elements as an array. + * So +each+ method can be called as follows: + * + * enum.slice_when { |elt_before, elt_after| bool }.each { |ary| ... } + * + * Other methods of the Enumerator class and Enumerable module, + * such as +to_a+, +map+, etc., are also usable. + * + * For example, one-by-one increasing subsequence can be chunked as follows: + * + * a = [1,2,4,9,10,11,12,15,16,19,20,21] + * b = a.slice_when {|i, j| i+1 != j } + * p b.to_a #=> [[1, 2], [4], [9, 10, 11, 12], [15, 16], [19, 20, 21]] + * c = b.map {|a| a.length < 3 ? a : "#{a.first}-#{a.last}" } + * p c #=> [[1, 2], [4], "9-12", [15, 16], "19-21"] + * d = c.join(",") + * p d #=> "1,2,4,9-12,15,16,19-21" + * + * Near elements (threshold: 6) in sorted array can be chunked as follows: + * + * a = [3, 11, 14, 25, 28, 29, 29, 41, 55, 57] + * p a.slice_when {|i, j| 6 < j - i }.to_a + * #=> [[3], [11, 14], [25, 28, 29, 29], [41], [55, 57]] + * + * Increasing (non-decreasing) subsequence can be chunked as follows: + * + * a = [0, 9, 2, 2, 3, 2, 7, 5, 9, 5] + * p a.slice_when {|i, j| i > j }.to_a + * #=> [[0, 9], [2, 2, 3], [2, 7], [5, 9], [5]] + * + * Adjacent evens and odds can be chunked as follows: + * (Enumerable#chunk is another way to do it.) + * + * a = [7, 5, 9, 2, 0, 7, 9, 4, 2, 0] + * p a.slice_when {|i, j| i.even? != j.even? }.to_a + * #=> [[7, 5, 9], [2, 0], [7, 9], [4, 2, 0]] + * + * Paragraphs (non-empty lines with trailing empty lines) can be chunked as follows: + * (See Enumerable#chunk to ignore empty lines.) + * + * lines = ["foo\n", "bar\n", "\n", "baz\n", "qux\n"] + * p lines.slice_when {|l1, l2| /\A\s*\z/ =~ l1 && /\S/ =~ l2 }.to_a + * #=> [["foo\n", "bar\n", "\n"], ["baz\n", "qux\n"]] + * + * Enumerable#chunk_while does the same, except splitting when the block + * returns <code>false</code> instead of <code>true</code>. + */ +static VALUE +enum_slice_when(VALUE enumerable) +{ + VALUE enumerator; + VALUE pred; + + 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_block_call(enumerator, idInitialize, 0, 0, slicewhen_i, enumerator); + return enumerator; +} + +/* + * call-seq: + * enum.chunk_while {|elt_before, elt_after| bool } -> an_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, + * _elt_before_ and _elt_after_, + * in the receiver enumerator. + * This method split chunks between _elt_before_ and _elt_after_ where + * the block returns <code>false</code>. + * + * The block is called the length of the receiver enumerator minus one. + * + * The result enumerator yields the chunked elements as an array. + * So +each+ method can be called as follows: + * + * enum.chunk_while { |elt_before, elt_after| bool }.each { |ary| ... } + * + * Other methods of the Enumerator class and Enumerable module, + * such as +to_a+, +map+, etc., are also usable. + * + * For example, one-by-one increasing subsequence can be chunked as follows: + * + * a = [1,2,4,9,10,11,12,15,16,19,20,21] + * b = a.chunk_while {|i, j| i+1 == j } + * p b.to_a #=> [[1, 2], [4], [9, 10, 11, 12], [15, 16], [19, 20, 21]] + * c = b.map {|a| a.length < 3 ? a : "#{a.first}-#{a.last}" } + * p c #=> [[1, 2], [4], "9-12", [15, 16], "19-21"] + * d = c.join(",") + * p d #=> "1,2,4,9-12,15,16,19-21" + * + * Increasing (non-decreasing) subsequence can be chunked as follows: + * + * a = [0, 9, 2, 2, 3, 2, 7, 5, 9, 5] + * p a.chunk_while {|i, j| i <= j }.to_a + * #=> [[0, 9], [2, 2, 3], [2, 7], [5, 9], [5]] + * + * Adjacent evens and odds can be chunked as follows: + * (Enumerable#chunk is another way to do it.) + * + * a = [7, 5, 9, 2, 0, 7, 9, 4, 2, 0] + * p a.chunk_while {|i, j| i.even? == j.even? }.to_a + * #=> [[7, 5, 9], [2, 0], [7, 9], [4, 2, 0]] + * + * Enumerable#slice_when does the same, except splitting when the block + * returns <code>true</code> instead of <code>false</code>. + */ +static VALUE +enum_chunk_while(VALUE enumerable) +{ + VALUE enumerator; + VALUE pred; + + 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_block_call(enumerator, idInitialize, 0, 0, slicewhen_i, enumerator); + return enumerator; +} + +struct enum_sum_memo { + VALUE v, r; + long n; + double f, c; + int block_given; + int float_value; +}; + +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) +{ + if (UNDEF_P(memo->r)) { + memo->r = i; + } + else { + memo->r = rb_rational_plus(memo->r, i); + } +} + +static void +sum_iter_some_value(VALUE i, struct enum_sum_memo *memo) +{ + memo->v = rb_funcallv(memo->v, idPLUS, 1, &i); +} + +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; + } + + double f = memo->f; + + if (isnan(f)) { + return; + } + else if (! isfinite(x)) { + if (isinf(x) && isinf(f) && signbit(x) != signbit(f)) { + i = DBL2NUM(f); + x = nan(""); + } + memo->v = i; + memo->f = x; + return; + } + else if (isinf(f)) { + return; + } + + double c = memo->c; + double t = f + x; + + if (fabs(f) >= fabs(x)) { + c += ((f - t) + x); + } + else { + c += ((x - t) + f); + } + f = t; + + 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; + } + } +} + +static VALUE +enum_sum_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args)) +{ + ENUM_WANT_SVALUE(); + sum_iter(i, (struct enum_sum_memo *) args); + return Qnil; +} + +static int +hash_sum_i(VALUE key, VALUE value, VALUE arg) +{ + sum_iter(rb_assoc_new(key, value), (struct enum_sum_memo *) arg); + return ST_CONTINUE; +} + +static void +hash_sum(VALUE hash, struct enum_sum_memo *memo) +{ + RUBY_ASSERT(RB_TYPE_P(hash, T_HASH)); + RUBY_ASSERT(memo != NULL); + + rb_hash_foreach(hash, hash_sum_i, (VALUE)memo); +} + +static VALUE +int_range_sum(VALUE beg, VALUE end, int excl, VALUE init) +{ + if (excl) { + if (FIXNUM_P(end)) + end = LONG2FIX(FIX2LONG(end) - 1); + else + end = rb_big_minus(end, LONG2FIX(1)); + } + + if (rb_int_ge(end, beg)) { + VALUE a; + a = rb_int_plus(rb_int_minus(end, beg), LONG2FIX(1)); + a = rb_int_mul(a, rb_int_plus(end, beg)); + a = rb_int_idiv(a, LONG2FIX(2)); + return rb_int_plus(init, a); + } + + return init; +} + +/* + * call-seq: + * sum(initial_value = 0) -> number + * sum(initial_value = 0) {|element| ... } -> object + * + * With no block given, + * returns the sum of +initial_value+ and the elements: + * + * (1..100).sum # => 5050 + * (1..100).sum(1) # => 5051 + * ('a'..'d').sum('foo') # => "fooabcd" + * + * 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. + * + * One such optimization: When possible, computes using Gauss's summation + * formula <em>n(n+1)/2</em>: + * + * 100 * (100 + 1) / 2 # => 5050 + * + * With a block given, calls the block with each element; + * returns the sum of +initial_value+ and the block return values: + * + * (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" + * + */ +static VALUE +enum_sum(int argc, VALUE* argv, VALUE obj) +{ + struct enum_sum_memo memo; + VALUE beg, end; + int excl; + + memo.v = (rb_check_arity(argc, 0, 1) == 0) ? LONG2FIX(0) : argv[0]; + memo.block_given = rb_block_given_p(); + memo.n = 0; + memo.r = Qundef; + + if ((memo.float_value = RB_FLOAT_TYPE_P(memo.v))) { + 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))) { + return int_range_sum(beg, end, excl, memo.v); + } + } + + if (RB_TYPE_P(obj, T_HASH) && + rb_method_basic_definition_p(CLASS_OF(obj), id_each)) + hash_sum(obj, &memo); + else + rb_block_call(obj, id_each, 0, 0, enum_sum_i, (VALUE)&memo); + + if (memo.float_value) { + return DBL2NUM(memo.f + memo.c); + } + 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); + } + return memo.v; + } +} + +static VALUE +uniq_func(RB_BLOCK_CALL_FUNC_ARGLIST(i, hash)) +{ + ENUM_WANT_SVALUE(); + rb_hash_add_new_element(hash, i, i); + return Qnil; +} + +static VALUE +uniq_iter(RB_BLOCK_CALL_FUNC_ARGLIST(i, hash)) +{ + ENUM_WANT_SVALUE(); + rb_hash_add_new_element(hash, rb_yield_values2(argc, argv), i); + return Qnil; +} + +/* + * 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>: + * + * %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"] + * + */ + +static VALUE +enum_uniq(VALUE obj) +{ + VALUE hash, ret; + rb_block_call_func *const 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); + ret = rb_hash_values(hash); + rb_hash_clear(hash); + 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 not 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. + * + * == Extended Methods + * + * A Enumerable class may define extended methods. This section describes the standard + * behavior of extension methods for reference purposes. + * + * === #size + * + * \Enumerator has a #size method. + * It uses the size function argument passed to +Enumerator.new+. + * + * e = Enumerator.new(-> { 3 }) {|y| p y; y.yield :a; y.yield :b; y.yield :c; :z } + * p e.size #=> 3 + * p e.next #=> :a + * p e.next #=> :b + * p e.next #=> :c + * begin + * e.next + * rescue StopIteration + * p $!.result #=> :z + * end + * + * The result of the size function should represent the number of iterations + * (i.e., the number of times Enumerator::Yielder#yield is called). + * In the above example, the block calls #yield three times, and + * the size function, +-> { 3 }+, returns 3 accordingly. + * The result of the size function can be an integer, +Float::INFINITY+, + * or +nil+. + * An integer means the exact number of times #yield will be called, + * as shown above. + * +Float::INFINITY+ indicates an infinite number of #yield calls. + * +nil+ means the number of #yield calls is difficult or impossible to + * determine. + * + * Many iteration methods return an \Enumerator object with an + * appropriate size function if no block is given. + * + * Examples: + * + * ["a", "b", "c"].each.size #=> 3 + * {a: "x", b: "y", c: "z"}.each.size #=> 3 + * (0..20).to_a.permutation.size #=> 51090942171709440000 + * loop.size #=> Float::INFINITY + * (1..100).drop_while.size #=> nil # size depends on the block's behavior + * STDIN.each.size #=> nil # cannot be computed without consuming input + * File.open("/etc/resolv.conf").each.size #=> nil # cannot be computed without reading the file + * + * The behavior of #size for Range-based enumerators depends on the #begin element: + * + * - If the #begin element is an Integer, the #size method returns an Integer or +Float::INFINITY+. + * - If the #begin element is an object with a #succ method (other than Integer), #size returns +nil+. + * (Computing the size would require repeatedly calling #succ, which may be too slow.) + * - If the #begin element does not have a #succ method, #size raises a TypeError. + * + * Examples: + * + * (10..42).each.size #=> 33 + * (10..42.9).each.size #=> 33 (the #end element may be a non-integer numeric) + * (10..).each.size #=> Float::INFINITY + * ("a".."z").each.size #=> nil + * ("a"..).each.size #=> nil + * (1.0..9.0).each.size # raises TypeError (Float does not have #succ) + * (..10).each.size # raises TypeError (beginless range has nil as its #begin) + * + * The \Enumerable module itself does not define a #size method. + * A class that includes \Enumerable may define its own #size method. + * It is recommended that such a #size method be consistent with + * Enumerator#size. + * + * Array and Hash implement #size and return values consistent with + * Enumerator#size. + * IO and Dir do not define #size, which is also consistent because the + * corresponding enumerator's size function returns +nil+. + * + * However, it is not strictly required for a class's #size method to match Enumerator#size. + * For example, File#size returns the number of bytes in the file, not the number of lines. + * */ void -Init_Enumerable() +Init_Enumerable(void) { rb_mEnumerable = rb_define_module("Enumerable"); - rb_define_method(rb_mEnumerable,"to_a", enum_to_a, 0); - rb_define_method(rb_mEnumerable,"entries", enum_to_a, 0); - - rb_define_method(rb_mEnumerable,"sort", enum_sort, 0); - rb_define_method(rb_mEnumerable,"sort_by", enum_sort_by, 0); - rb_define_method(rb_mEnumerable,"grep", enum_grep, 1); - rb_define_method(rb_mEnumerable,"find", enum_find, -1); - rb_define_method(rb_mEnumerable,"detect", enum_find, -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,"reject", enum_reject, 0); - rb_define_method(rb_mEnumerable,"collect", enum_collect, 0); - rb_define_method(rb_mEnumerable,"map", enum_collect, 0); - rb_define_method(rb_mEnumerable,"inject", enum_inject, -1); - rb_define_method(rb_mEnumerable,"partition", enum_partition, 0); - rb_define_method(rb_mEnumerable,"all?", enum_all, 0); - rb_define_method(rb_mEnumerable,"any?", enum_any, 0); - rb_define_method(rb_mEnumerable,"min", enum_min, 0); - rb_define_method(rb_mEnumerable,"max", enum_max, 0); - rb_define_method(rb_mEnumerable,"member?", enum_member, 1); - rb_define_method(rb_mEnumerable,"include?", enum_member, 1); - rb_define_method(rb_mEnumerable,"each_with_index", enum_each_with_index, 0); + rb_define_method(rb_mEnumerable, "to_a", enum_to_a, -1); + rb_define_method(rb_mEnumerable, "entries", enum_to_a, -1); + rb_define_method(rb_mEnumerable, "to_h", enum_to_h, -1); + + rb_define_method(rb_mEnumerable, "sort", enum_sort, 0); + rb_define_method(rb_mEnumerable, "sort_by", enum_sort_by, 0); + rb_define_method(rb_mEnumerable, "grep", enum_grep, 1); + rb_define_method(rb_mEnumerable, "grep_v", enum_grep_v, 1); + rb_define_method(rb_mEnumerable, "count", enum_count, -1); + rb_define_method(rb_mEnumerable, "find", enum_find, -1); + rb_define_method(rb_mEnumerable, "detect", enum_find, -1); + 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); + rb_define_method(rb_mEnumerable, "flat_map", enum_flat_map, 0); + rb_define_method(rb_mEnumerable, "collect_concat", enum_flat_map, 0); + rb_define_method(rb_mEnumerable, "inject", enum_inject, -1); + 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); + rb_define_method(rb_mEnumerable, "one?", enum_one, -1); + rb_define_method(rb_mEnumerable, "none?", enum_none, -1); + rb_define_method(rb_mEnumerable, "min", enum_min, -1); + rb_define_method(rb_mEnumerable, "max", enum_max, -1); + rb_define_method(rb_mEnumerable, "minmax", enum_minmax, 0); + rb_define_method(rb_mEnumerable, "min_by", enum_min_by, -1); + rb_define_method(rb_mEnumerable, "max_by", enum_max_by, -1); + rb_define_method(rb_mEnumerable, "minmax_by", enum_minmax_by, 0); + rb_define_method(rb_mEnumerable, "member?", enum_member, 1); + rb_define_method(rb_mEnumerable, "include?", enum_member, 1); + rb_define_method(rb_mEnumerable, "each_with_index", enum_each_with_index, -1); + rb_define_method(rb_mEnumerable, "reverse_each", enum_reverse_each, -1); + rb_define_method(rb_mEnumerable, "each_entry", enum_each_entry, -1); + rb_define_method(rb_mEnumerable, "each_slice", enum_each_slice, 1); + rb_define_method(rb_mEnumerable, "each_cons", enum_each_cons, 1); + rb_define_method(rb_mEnumerable, "each_with_object", enum_each_with_object, 1); rb_define_method(rb_mEnumerable, "zip", enum_zip, -1); + rb_define_method(rb_mEnumerable, "take", enum_take, 1); + rb_define_method(rb_mEnumerable, "take_while", enum_take_while, 0); + rb_define_method(rb_mEnumerable, "drop", enum_drop, 1); + rb_define_method(rb_mEnumerable, "drop_while", enum_drop_while, 0); + rb_define_method(rb_mEnumerable, "cycle", enum_cycle, -1); + rb_define_method(rb_mEnumerable, "chunk", enum_chunk, 0); + rb_define_method(rb_mEnumerable, "slice_before", enum_slice_before, -1); + rb_define_method(rb_mEnumerable, "slice_after", enum_slice_after, -1); + rb_define_method(rb_mEnumerable, "slice_when", enum_slice_when, 0); + 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_eqq = rb_intern("==="); - id_each = rb_intern("each"); - id_cmp = rb_intern("<=>"); + 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"); } - |