diff options
Diffstat (limited to 'enum.c')
| -rw-r--r-- | enum.c | 334 |
1 files changed, 334 insertions, 0 deletions
@@ -44,6 +44,24 @@ grep_iter_i(i, arg) return Qnil; } +/* + * 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] + * + */ + static VALUE enum_grep(obj, pat) VALUE obj, pat; @@ -72,6 +90,20 @@ find_i(i, memo) return Qnil; } +/* + * call-seq: + * enum.detect {| obj | block } => obj or nil + * enum.find {| 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>. Returns + * <code>nil</code> if no object matches. + * + * (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(argc, argv, obj) int argc; @@ -105,6 +137,19 @@ find_all_i(i, ary) 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] + * + */ + static VALUE enum_find_all(obj) VALUE obj; @@ -126,6 +171,17 @@ reject_i(i, ary) 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] + * + */ + static VALUE enum_reject(obj) VALUE obj; @@ -155,6 +211,19 @@ collect_all(i, ary) 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"] + * + */ + static VALUE enum_collect(obj) VALUE obj; @@ -166,6 +235,16 @@ enum_collect(obj) 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]] + */ static VALUE enum_to_a(obj) VALUE obj; @@ -192,6 +271,37 @@ inject_i(i, memo) return Qnil; } +/* + * 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 + * + */ + static VALUE enum_inject(argc, argv, obj) int argc; @@ -225,6 +335,18 @@ partition_i(i, ary) 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]] + * + */ + static VALUE enum_partition(obj) VALUE obj; @@ -238,6 +360,23 @@ enum_partition(obj) return rb_assoc_new(ary[0], ary[1]); } +/* + * 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] + */ + static VALUE enum_sort(obj) VALUE obj; @@ -267,6 +406,75 @@ sort_by_cmp(a, b) return rb_cmpint(retval, *a, *b); } +/* + * 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 + * + * 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 + * + * <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. + * + * 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 <code>File</code> + * objects during every comparison. A slightly better technique is to + * use the <code>Kernel#test</code> 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 <code>Time</code> objects. A + * more efficient technique is to cache the sort keys (modification + * times in this case) before the sort. Perl users often call this + * approach a Schwartzian Transform, after Randal Schwartz. We + * construct a temporary array, where each element is an array + * containing our sort key along with the filename. We sort this array, + * and then extract the filename from the result. + * + * sorted = Dir["*"].collect { |f| + * [test(?M, f), f] + * }.sort.collect { |f| f[1] } + * sorted #=> ["mon", "tues", "wed", "thurs"] + * + * This is exactly what <code>sort_by</code> does internally. + * + * sorted = Dir["*"].sort_by {|f| test(?M, f)} + * sorted #=> ["mon", "tues", "wed", "thurs"] + */ + static VALUE enum_sort_by(obj) VALUE obj; @@ -315,6 +523,23 @@ all_i(i, memo) 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 + * + */ + static VALUE enum_all(obj) VALUE obj; @@ -353,6 +578,24 @@ any_i(i, memo) 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 + * + */ + static VALUE enum_any(obj) VALUE obj; @@ -405,6 +648,21 @@ min_ii(i, memo) 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.max {|a,b| a.length <=> b.length } #=> "dog" + */ + static VALUE enum_min(obj) VALUE obj; @@ -418,6 +676,20 @@ enum_min(obj) return result; } +/* + * 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" + */ + static VALUE max_i(i, memo) VALUE i; @@ -481,6 +753,19 @@ member_i(item, memo) 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 + * + */ + static VALUE enum_member(obj, val) VALUE obj, val; @@ -504,6 +789,21 @@ each_with_index_i(val, memo) 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} + * + */ + static VALUE enum_each_with_index(obj) VALUE obj; @@ -540,6 +840,29 @@ zip_i(val, memo) 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]] + * + */ + static VALUE enum_zip(argc, argv, obj) int argc; @@ -560,6 +883,17 @@ enum_zip(argc, argv, obj) return result; } +/* + * The <code>Enumerable</code> mixin provides collection classes with + * several traversal and searching methods, and with the ability to + * sort. The class must provide a method <code>each</code>, which + * yields successive members of the collection. If + * <code>Enumerable#max</code>, <code>#min</code>, or + * <code>#sort</code> is used, the objects in the collection must also + * implement a meaningful <code><=></code> operator, as these methods + * rely on an ordering between members of the collection. + */ + void Init_Enumerable() { |