/********************************************************************** enum.c - $Author$ $Date$ created at: Fri Oct 1 15:15:19 JST 1993 Copyright (C) 1993-2003 Yukihiro Matsumoto **********************************************************************/ #include "ruby.h" #include "node.h" #include "util.h" VALUE rb_mEnumerable; static ID id_each, id_eqq, id_cmp; static VALUE grep_i(VALUE i, VALUE *arg) { if (RTEST(rb_funcall(arg[0], id_eqq, 1, i))) { rb_ary_push(arg[1], i); } return Qnil; } static VALUE grep_iter_i(VALUE i, VALUE *arg) { if (RTEST(rb_funcall(arg[0], id_eqq, 1, i))) { rb_ary_push(arg[1], rb_yield(i)); } return Qnil; } /* * call-seq: * enum.grep(pattern) => array * enum.grep(pattern) {| obj | block } => array * * Returns an array of every element in enum for which * Pattern === element. If the optional block 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] * */ static VALUE enum_grep(VALUE obj, VALUE pat) { VALUE ary = rb_ary_new(); VALUE arg[2]; arg[0] = pat; arg[1] = ary; rb_block_call(obj, id_each, 0, 0, rb_block_given_p() ? grep_iter_i : grep_i, (VALUE)arg); return ary; } static VALUE count_i(VALUE i, VALUE *arg) { if (rb_equal(i, arg[0])) { arg[1]++; } return Qnil; } static VALUE count_iter_i(VALUE i, long *n) { if (RTEST(rb_yield(i))) { (*n)++; } return Qnil; } /* * call-seq: * enum.count(item) => int * enum.count {| obj | block } => int * * Returns the number of items in enum for which equals to item. * If a block is given, counts the number of elements yielding a true value. * * ary = [1, 2, 4, 2] * ary.count(2) # => 2 * ary.count{|x|x%2==0} # => 3 * */ static VALUE enum_count(int argc, VALUE *argv, VALUE obj) { if (argc == 1) { VALUE item, args[2]; if (rb_block_given_p()) { rb_warn("given block not used"); } rb_scan_args(argc, argv, "1", &item); args[0] = item; args[1] = 0; rb_block_call(obj, id_each, 0, 0, count_i, (VALUE)&args); return INT2NUM(args[1]); } else { long n = 0; rb_block_call(obj, id_each, 0, 0, count_iter_i, (VALUE)&n); return INT2NUM(n); } } static VALUE find_i(VALUE i, VALUE *memo) { if (RTEST(rb_yield(i))) { *memo = i; rb_iter_break(); } 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 enum to block. Returns the * first for which block is not false. If no * object matches, calls ifnone and returns its result when it * is specified, or returns nil * * (1..10).detect {|i| i % 5 == 0 and i % 7 == 0 } #=> nil * (1..100).detect {|i| i % 5 == 0 and i % 7 == 0 } #=> 35 * */ static VALUE enum_find(int argc, VALUE *argv, VALUE obj) { VALUE memo = Qundef; VALUE if_none; rb_scan_args(argc, argv, "01", &if_none); RETURN_ENUMERATOR(obj, argc, argv); rb_block_call(obj, id_each, 0, 0, find_i, (VALUE)&memo); if (memo != Qundef) { return memo; } if (!NIL_P(if_none)) { return rb_funcall(if_none, rb_intern("call"), 0, 0); } return Qnil; } static VALUE find_index_i(VALUE i, VALUE *memo) { if (RTEST(rb_yield(i))) { memo[0] = UINT2NUM(memo[1]); rb_iter_break(); } memo[1]++; return Qnil; } /* * call-seq: * enum.find_index(ifnone = nil) {| obj | block } => int * * Passes each entry in enum to block. Returns the * index for the first for which block is not false. * If no object matches, returns nil * * (1..10).find_index {|i| i % 5 == 0 and i % 7 == 0 } #=> nil * (1..100).find_index {|i| i % 5 == 0 and i % 7 == 0 } #=> 35 * */ static VALUE enum_find_index(VALUE obj) { VALUE memo[2]; RETURN_ENUMERATOR(obj, 0, 0); memo[0] = Qundef; memo[1] = 0; rb_block_call(obj, id_each, 0, 0, find_index_i, (VALUE)memo); if (memo[0] != Qundef) { return memo[0]; } return Qnil; } static VALUE find_all_i(VALUE i, VALUE ary) { if (RTEST(rb_yield(i))) { rb_ary_push(ary, i); } return Qnil; } /* * call-seq: * enum.find_all {| obj | block } => array * enum.select {| obj | block } => array * * Returns an array containing all elements of enum for which * block is not false (see also * Enumerable#reject). * * (1..10).find_all {|i| i % 3 == 0 } #=> [3, 6, 9] * */ static VALUE enum_find_all(VALUE obj) { VALUE ary; RETURN_ENUMERATOR(obj, 0, 0); ary = rb_ary_new(); rb_block_call(obj, id_each, 0, 0, find_all_i, ary); return ary; } static VALUE reject_i(VALUE i, VALUE ary) { if (!RTEST(rb_yield(i))) { rb_ary_push(ary, i); } return Qnil; } /* * call-seq: * enum.reject {| obj | block } => array * * Returns an array for all elements of enum for which * block is false (see also Enumerable#find_all). * * (1..10).reject {|i| i % 3 == 0 } #=> [1, 2, 4, 5, 7, 8, 10] * */ static VALUE enum_reject(VALUE obj) { VALUE ary; RETURN_ENUMERATOR(obj, 0, 0); ary = rb_ary_new(); rb_block_call(obj, id_each, 0, 0, reject_i, ary); return ary; } static VALUE collect_i(VALUE i, VALUE ary) { rb_ary_push(ary, rb_yield(i)); return Qnil; } static VALUE collect_all(VALUE i, VALUE ary) { rb_ary_push(ary, i); return Qnil; } /* * call-seq: * enum.collect {| obj | block } => array * enum.map {| obj | block } => array * * Returns a new array with the results of running block once * for every element in enum. * * (1..4).collect {|i| i*i } #=> [1, 4, 9, 16] * (1..4).collect { "cat" } #=> ["cat", "cat", "cat", "cat"] * */ static VALUE enum_collect(VALUE obj) { VALUE ary; RETURN_ENUMERATOR(obj, 0, 0); ary = rb_ary_new(); rb_block_call(obj, id_each, 0, 0, collect_i, ary); return ary; } /* * call-seq: * enum.to_a => array * enum.entries => array * * Returns an array containing the items in enum. * * (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]] */ static VALUE enum_to_a(VALUE obj) { VALUE ary = rb_ary_new(); rb_block_call(obj, id_each, 0, 0, collect_all, ary); return ary; } static VALUE inject_i(VALUE i, VALUE *memo) { if (*memo == Qundef) { *memo = i; } else { *memo = rb_yield_values(2, *memo, i); } return Qnil; } /* * call-seq: * enum.inject(initial) {| memo, obj | block } => obj * enum.inject {| memo, obj | block } => obj * * Combines the elements of enum by applying the block to an * accumulator value (memo) and each element in turn. At each * step, memo is set to the value returned by the block. The * first form lets you supply an initial value for memo. 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 * */ static VALUE enum_inject(int argc, VALUE *argv, VALUE obj) { VALUE memo = Qundef; if (rb_scan_args(argc, argv, "01", &memo) == 0) memo = Qundef; rb_block_call(obj, id_each, 0, 0, inject_i, (VALUE)&memo); if (memo == Qundef) return Qnil; return memo; } static VALUE partition_i(VALUE i, VALUE *ary) { if (RTEST(rb_yield(i))) { rb_ary_push(ary[0], i); } else { rb_ary_push(ary[1], i); } return Qnil; } /* * call-seq: * enum.partition {| obj | block } => [ true_array, false_array ] * * Returns two arrays, the first containing the elements of * enum 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]] * */ static VALUE enum_partition(VALUE obj) { VALUE ary[2]; RETURN_ENUMERATOR(obj, 0, 0); ary[0] = rb_ary_new(); ary[1] = rb_ary_new(); rb_block_call(obj, id_each, 0, 0, partition_i, (VALUE)ary); return rb_assoc_new(ary[0], ary[1]); } static VALUE group_by_i(VALUE i, VALUE hash) { VALUE group = rb_yield(i); VALUE values; values = rb_hash_aref(hash, group); if (NIL_P(values)) { values = rb_ary_new3(1, i); rb_hash_aset(hash, group, values); } else { rb_ary_push(values, i); } return Qnil; } /* * call-seq: * enum.group_by {| obj | block } => a_hash * * Returns a hash, which keys are evaluated result from the * block, and values are arrays of elements in enum * corresponding to the key. * * (1..6).group_by {|i| i%3} #=> {0=>[3, 6], 1=>[1, 4], 2=>[2, 5]} * */ static VALUE enum_group_by(VALUE obj) { VALUE hash; RETURN_ENUMERATOR(obj, 0, 0); hash = rb_hash_new(); rb_block_call(obj, id_each, 0, 0, group_by_i, hash); return hash; } static VALUE first_i(VALUE i, VALUE *ary) { if (NIL_P(ary[0])) { ary[1] = i; rb_iter_break(); } else { long n = NUM2LONG(ary[0]); if (n <= 0) { rb_iter_break(); } rb_ary_push(ary[1], i); n--; ary[0] = INT2NUM(n); } return Qnil; } /* * call-seq: * enum.first -> obj or nil * enum.first(n) -> an_array * * Returns the first element, or the first +n+ elements, of the enumerable. * If the enumerable is empty, the first form returns nil, and the * second form returns an empty array. * */ static VALUE enum_first(int argc, VALUE *argv, VALUE obj) { VALUE n, ary[2]; rb_scan_args(argc, argv, "01", &n); if (NIL_P(n)) { ary[0] = ary[1] = Qnil; } else { ary[0] = n; ary[1] = rb_ary_new2(NUM2LONG(n)); } rb_block_call(obj, id_each, 0, 0, first_i, (VALUE)ary); return ary[1]; } /* * call-seq: * enum.sort => array * enum.sort {| a, b | block } => array * * Returns an array containing the items in enum sorted, * either according to their own <=> method, or by using * the results of the supplied block. The block should return -1, 0, or * +1 depending on the comparison between a and b. As of * Ruby 1.8, the method Enumerable#sort_by 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] */ static VALUE enum_sort(VALUE obj) { return rb_ary_sort(enum_to_a(obj)); } static VALUE sort_by_i(VALUE i, VALUE ary) { VALUE v; NODE *memo; v = rb_yield(i); if (RBASIC(ary)->klass) { rb_raise(rb_eRuntimeError, "sort_by reentered"); } memo = rb_node_newnode(NODE_MEMO, v, i, 0); rb_ary_push(ary, (VALUE)memo); return Qnil; } static int sort_by_cmp(const void *ap, const void *bp, void *data) { VALUE a = (*(NODE *const *)ap)->u1.value; VALUE b = (*(NODE *const *)bp)->u1.value; return rb_cmpint(rb_funcall(a, id_cmp, 1, b), a, b); } /* * call-seq: * enum.sort_by {| obj | block } => array * * Sorts enum using a set of keys generated by mapping the * values in enum through the given block. * * %w{ apple pear fig }.sort_by {|word| word.length} #=> ["fig", "pear", "apple"] * * The current implementation of sort_by generates an * array of tuples containing the original collection element and the * mapped value. This makes sort_by fairly expensive when * the keysets are simple * * require 'benchmark' * include Benchmark * * a = (1..100000).map {rand(100000)} * * bm(10) do |b| * b.report("Sort") { a.sort } * b.report("Sort by") { a.sort_by {|a| a} } * end * * produces: * * 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 sort method. * * files = Dir["*"] * sorted = files.sort {|a,b| File.new(a).mtime <=> File.new(b).mtime} * sorted #=> ["mon", "tues", "wed", "thurs"] * * This sort is inefficient: it generates two new File * objects during every comparison. A slightly better technique is to * use the Kernel#test method to generate the modification * times directly. * * files = Dir["*"] * sorted = files.sort { |a,b| * test(?M, a) <=> test(?M, b) * } * sorted #=> ["mon", "tues", "wed", "thurs"] * * This still generates many unnecessary Time objects. A * more efficient technique is to cache the sort keys (modification * times in this case) before the sort. Perl users often call this * approach a Schwartzian Transform, after Randal Schwartz. We * construct a temporary array, where each element is an array * containing our sort key along with the filename. We sort this array, * and then extract the filename from the result. * * sorted = Dir["*"].collect { |f| * [test(?M, f), f] * }.sort.collect { |f| f[1] } * sorted #=> ["mon", "tues", "wed", "thurs"] * * This is exactly what sort_by does internally. * * sorted = Dir["*"].sort_by {|f| test(?M, f)} * sorted #=> ["mon", "tues", "wed", "thurs"] */ static VALUE enum_sort_by(VALUE obj) { VALUE ary; long i; RETURN_ENUMERATOR(obj, 0, 0); if (TYPE(obj) == T_ARRAY) { ary = rb_ary_new2(RARRAY_LEN(obj)); } else { ary = rb_ary_new(); } RBASIC(ary)->klass = 0; rb_block_call(obj, id_each, 0, 0, sort_by_i, ary); if (RARRAY_LEN(ary) > 1) { ruby_qsort(RARRAY_PTR(ary), RARRAY_LEN(ary), sizeof(VALUE), sort_by_cmp, 0); } if (RBASIC(ary)->klass) { rb_raise(rb_eRuntimeError, "sort_by reentered"); } for (i=0; iu2.value; } RBASIC(ary)->klass = rb_cArray; return ary; } static VALUE all_iter_i(VALUE i, VALUE *memo) { if (!RTEST(rb_yield(i))) { *memo = Qfalse; rb_iter_break(); } return Qnil; } static VALUE all_i(VALUE i, VALUE *memo) { if (!RTEST(i)) { *memo = Qfalse; 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 true if the block never returns * false or nil. If the block is not given, * Ruby adds an implicit block of {|obj| obj} (that is * all? will return true only if none of the * collection members are false or nil.) * * %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 * */ static VALUE enum_all(VALUE obj) { VALUE result = Qtrue; rb_block_call(obj, id_each, 0, 0, rb_block_given_p() ? all_iter_i : all_i, (VALUE)&result); return result; } static VALUE any_iter_i(VALUE i, VALUE *memo) { if (RTEST(rb_yield(i))) { *memo = Qtrue; rb_iter_break(); } return Qnil; } static VALUE any_i(VALUE i, VALUE *memo) { if (RTEST(i)) { *memo = Qtrue; rb_iter_break(); } return Qnil; } /* * call-seq: * enum.any? [{|obj| block } ] => true or false * * Passes each element of the collection to the given block. The method * returns true if the block ever returns a value other * than false or nil. If the block is not * given, Ruby adds an implicit block of {|obj| obj} (that * is any? will return true if at least one * of the collection members is not false or * nil. * * %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 * */ static VALUE enum_any(VALUE obj) { VALUE result = Qfalse; rb_block_call(obj, id_each, 0, 0, rb_block_given_p() ? any_iter_i : any_i, (VALUE)&result); return result; } static VALUE one_iter_i(VALUE i, VALUE *memo) { if (RTEST(rb_yield(i))) { if (*memo == Qundef) { *memo = Qtrue; } else if (*memo == Qtrue) { *memo = Qfalse; } } return Qnil; } static VALUE one_i(VALUE i, VALUE *memo) { if (RTEST(i)) { if (*memo == Qundef) { *memo = Qtrue; } else if (*memo == Qtrue) { *memo = Qfalse; } } return Qnil; } /* * call-seq: * enum.one? [{|obj| block }] => true or false * * Passes each element of the collection to the given block. The method * returns true if the block returns true * exactly once. If the block is not given, one? will return * true only if exactly one of the collection members are * true. * * %w{ant bear cat}.one? {|word| word.length == 4} #=> true * %w{ant bear cat}.one? {|word| word.length >= 4} #=> false * [ nil, true, 99 ].one? #=> true * */ static VALUE enum_one(VALUE obj) { VALUE result = Qundef; rb_block_call(obj, id_each, 0, 0, rb_block_given_p() ? one_iter_i : one_i, (VALUE)&result); if (result == Qundef) return Qfalse; return result; } static VALUE none_iter_i(VALUE i, VALUE *memo) { if (RTEST(rb_yield(i))) { *memo = Qfalse; rb_iter_break(); } return Qnil; } static VALUE none_i(VALUE i, VALUE *memo) { if (RTEST(i)) { *memo = Qfalse; rb_iter_break(); } return Qnil; } /* * call-seq: * enum.none? [{|obj| block }] => true or false * * Passes each element of the collection to the given block. The method * returns true if the block never returns true * for all elements. If the block is not given, one? will return * true only if any of the collection members is true. * * %w{ant bear cat}.one? {|word| word.length == 4} #=> true * %w{ant bear cat}.one? {|word| word.length >= 4} #=> false * [ nil, true, 99 ].one? #=> true * */ static VALUE enum_none(VALUE obj) { VALUE result = Qtrue; rb_block_call(obj, id_each, 0, 0, rb_block_given_p() ? none_iter_i : none_i, (VALUE)&result); return result; } static VALUE min_i(VALUE i, VALUE *memo) { VALUE cmp; if (*memo == Qundef) { *memo = i; } else { cmp = rb_funcall(i, id_cmp, 1, *memo); if (rb_cmpint(cmp, i, *memo) < 0) { *memo = i; } } return Qnil; } static VALUE min_ii(VALUE i, VALUE *memo) { VALUE cmp; if (*memo == Qundef) { *memo = i; } else { cmp = rb_yield_values(2, i, *memo); if (rb_cmpint(cmp, i, *memo) < 0) { *memo = i; } } return Qnil; } /* * call-seq: * enum.min => obj * enum.min {| a,b | block } => obj * * Returns the object in enum with the minimum value. The * first form assumes all objects implement Comparable; * the second uses the block to return a <=> b. * * a = %w(albatross dog horse) * a.min #=> "albatross" * a.min {|a,b| a.length <=> b.length } #=> "dog" */ static VALUE enum_min(VALUE obj) { VALUE result = Qundef; rb_block_call(obj, id_each, 0, 0, rb_block_given_p() ? min_ii : min_i, (VALUE)&result); if (result == Qundef) return Qnil; return result; } static VALUE max_i(VALUE i, VALUE *memo) { VALUE cmp; if (*memo == Qundef) { *memo = i; } else { cmp = rb_funcall(i, id_cmp, 1, *memo); if (rb_cmpint(cmp, i, *memo) > 0) { *memo = i; } } return Qnil; } static VALUE max_ii(VALUE i, VALUE *memo) { VALUE cmp; if (*memo == Qundef) { *memo = i; } else { cmp = rb_yield_values(2, i, *memo); if (rb_cmpint(cmp, i, *memo) > 0) { *memo = i; } } 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 Comparable; * the second uses the block to return a <=> b. * * a = %w(albatross dog horse) * a.max #=> "horse" * a.max {|a,b| a.length <=> b.length } #=> "albatross" */ static VALUE enum_max(VALUE obj) { VALUE result = Qundef; rb_block_call(obj, id_each, 0, 0, rb_block_given_p() ? max_ii : max_i, (VALUE)&result); if (result == Qundef) return Qnil; return result; } static VALUE min_by_i(VALUE i, VALUE *memo) { VALUE v; v = rb_yield(i); if (memo[0] == Qundef) { memo[0] = v; memo[1] = i; } else if (rb_cmpint(rb_funcall(v, id_cmp, 1, memo[0]), v, memo[0]) < 0) { memo[0] = v; memo[1] = i; } return Qnil; } /* * call-seq: * enum.min_by {| obj| block } => obj * * Returns the object in enum that gives the minimum * value from the given block. * * a = %w(albatross dog horse) * a.min_by {|x| x.length } #=> "dog" */ static VALUE enum_min_by(VALUE obj) { VALUE memo[2]; RETURN_ENUMERATOR(obj, 0, 0); memo[0] = Qundef; memo[1] = Qnil; rb_block_call(obj, id_each, 0, 0, min_by_i, (VALUE)memo); return memo[1]; } static VALUE max_by_i(VALUE i, VALUE *memo) { VALUE v; v = rb_yield(i); if (memo[0] == Qundef) { memo[0] = v; memo[1] = i; } else if (rb_cmpint(rb_funcall(v, id_cmp, 1, memo[0]), v, memo[0]) > 0) { memo[0] = v; memo[1] = i; } return Qnil; } /* * call-seq: * enum.max_by {| obj| block } => obj * * Returns the object in enum that gives the maximum * value from the given block. * * a = %w(albatross dog horse) * a.max_by {|x| x.length } #=> "albatross" */ static VALUE enum_max_by(VALUE obj) { VALUE memo[2]; RETURN_ENUMERATOR(obj, 0, 0); memo[0] = Qundef; memo[1] = Qnil; rb_block_call(obj, id_each, 0, 0, max_by_i, (VALUE)memo); return memo[1]; } static VALUE member_i(VALUE item, VALUE *memo) { if (rb_equal(item, memo[0])) { memo[1] = Qtrue; rb_iter_break(); } return Qnil; } /* * call-seq: * enum.include?(obj) => true or false * enum.member?(obj) => true or false * * Returns true if any member of enum equals * obj. Equality is tested using ==. * * IO.constants.include? "SEEK_SET" #=> true * IO.constants.include? "SEEK_NO_FURTHER" #=> false * */ static VALUE enum_member(VALUE obj, VALUE val) { VALUE memo[2]; memo[0] = val; memo[1] = Qfalse; rb_block_call(obj, id_each, 0, 0, member_i, (VALUE)memo); return memo[1]; } static VALUE each_with_index_i(VALUE val, VALUE *memo) { rb_yield_values(2, val, INT2FIX(*memo)); ++*memo; return Qnil; } /* * call-seq: * enum.each_with_index {|obj, i| block } -> enum * * Calls block with two arguments, the item and its index, for * each item in enum. * * hash = Hash.new * %w(cat dog wombat).each_with_index {|item, index| * hash[item] = index * } * hash #=> {"cat"=>0, "wombat"=>2, "dog"=>1} * */ static VALUE enum_each_with_index(VALUE obj) { VALUE memo = 0; RETURN_ENUMERATOR(obj, 0, 0); rb_block_call(obj, id_each, 0, 0, each_with_index_i, (VALUE)&memo); return obj; } static VALUE zip_i(VALUE val, VALUE *memo) { VALUE result = memo[0]; VALUE args = memo[1]; int idx = memo[2]++; VALUE tmp; int i; tmp = rb_ary_new2(RARRAY_LEN(args) + 1); rb_ary_store(tmp, 0, val); for (i=0; i array * enum.zip(arg, ...) {|arr| block } => nil * * Converts any arguments to arrays, then merges elements of * enum with corresponding elements from each argument. This * generates a sequence of enum#size n-element * arrays, where n is one more that the count of arguments. If * the size of any argument is less than enum#size, * nil 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]] * */ static VALUE enum_zip(int argc, VALUE *argv, VALUE obj) { int i; VALUE result; VALUE memo[3]; for (i=0; iEnumerable mixin provides collection classes with * several traversal and searching methods, and with the ability to * sort. The class must provide a method each, which * yields successive members of the collection. If * Enumerable#max, #min, or * #sort is used, the objects in the collection must also * implement a meaningful <=> operator, as these methods * rely on an ordering between members of the collection. */ void 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,"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, 0); 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,"group_by", enum_group_by, 0); rb_define_method(rb_mEnumerable,"first", enum_first, -1); rb_define_method(rb_mEnumerable,"all?", enum_all, 0); rb_define_method(rb_mEnumerable,"any?", enum_any, 0); rb_define_method(rb_mEnumerable,"one?", enum_one, 0); rb_define_method(rb_mEnumerable,"none?", enum_none, 0); rb_define_method(rb_mEnumerable,"min", enum_min, 0); rb_define_method(rb_mEnumerable,"max", enum_max, 0); rb_define_method(rb_mEnumerable,"min_by", enum_min_by, 0); rb_define_method(rb_mEnumerable,"max_by", enum_max_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, 0); rb_define_method(rb_mEnumerable, "zip", enum_zip, -1); id_eqq = rb_intern("==="); id_each = rb_intern("each"); id_cmp = rb_intern("<=>"); }