1
/**********************************************************************
6
$Date: 2007-02-13 08:01:19 +0900 (Tue, 13 Feb 2007) $
7
created at: Fri Oct 1 15:15:19 JST 1993
9
Copyright (C) 1993-2003 Yukihiro Matsumoto
11
**********************************************************************/
18
static ID id_each, id_eqq, id_cmp;
24
return rb_funcall(obj, id_each, 0, 0);
31
if (RTEST(rb_funcall(arg[0], id_eqq, 1, i))) {
32
rb_ary_push(arg[1], i);
41
if (RTEST(rb_funcall(arg[0], id_eqq, 1, i))) {
42
rb_ary_push(arg[1], rb_yield(i));
49
* enum.grep(pattern) => array
50
* enum.grep(pattern) {| obj | block } => array
52
* Returns an array of every element in <i>enum</i> for which
53
* <code>Pattern === element</code>. If the optional <em>block</em> is
54
* supplied, each matching element is passed to it, and the block's
55
* result is stored in the output array.
57
* (1..100).grep 38..44 #=> [38, 39, 40, 41, 42, 43, 44]
59
* c.grep(/SEEK/) #=> ["SEEK_END", "SEEK_SET", "SEEK_CUR"]
60
* res = c.grep(/SEEK/) {|v| IO.const_get(v) }
69
VALUE ary = rb_ary_new();
75
rb_iterate(rb_each, obj, rb_block_given_p() ? grep_iter_i : grep_i, (VALUE)arg);
85
if (RTEST(rb_yield(i))) {
94
* enum.detect(ifnone = nil) {| obj | block } => obj or nil
95
* enum.find(ifnone = nil) {| obj | block } => obj or nil
97
* Passes each entry in <i>enum</i> to <em>block</em>. Returns the
98
* first for which <em>block</em> is not <code>false</code>. If no
99
* object matches, calls <i>ifnone</i> and returns its result when it
100
* is specified, or returns <code>nil</code>
102
* (1..10).detect {|i| i % 5 == 0 and i % 7 == 0 } #=> nil
103
* (1..100).detect {|i| i % 5 == 0 and i % 7 == 0 } #=> 35
108
enum_find(argc, argv, obj)
116
rb_scan_args(argc, argv, "01", &if_none);
117
rb_iterate(rb_each, obj, find_i, (VALUE)&memo);
118
if (memo != Qundef) {
121
if (!NIL_P(if_none)) {
122
return rb_funcall(if_none, rb_intern("call"), 0, 0);
131
if (RTEST(rb_yield(i))) {
139
* enum.find_all {| obj | block } => array
140
* enum.select {| obj | block } => array
142
* Returns an array containing all elements of <i>enum</i> for which
143
* <em>block</em> is not <code>false</code> (see also
144
* <code>Enumerable#reject</code>).
146
* (1..10).find_all {|i| i % 3 == 0 } #=> [3, 6, 9]
154
VALUE ary = rb_ary_new();
156
rb_iterate(rb_each, obj, find_all_i, ary);
165
if (!RTEST(rb_yield(i))) {
173
* enum.reject {| obj | block } => array
175
* Returns an array for all elements of <i>enum</i> for which
176
* <em>block</em> is false (see also <code>Enumerable#find_all</code>).
178
* (1..10).reject {|i| i % 3 == 0 } #=> [1, 2, 4, 5, 7, 8, 10]
186
VALUE ary = rb_ary_new();
188
rb_iterate(rb_each, obj, reject_i, ary);
197
rb_ary_push(ary, rb_yield(i));
213
* enum.collect {| obj | block } => array
214
* enum.map {| obj | block } => array
216
* Returns a new array with the results of running <em>block</em> once
217
* for every element in <i>enum</i>.
219
* (1..4).collect {|i| i*i } #=> [1, 4, 9, 16]
220
* (1..4).collect { "cat" } #=> ["cat", "cat", "cat", "cat"]
228
VALUE ary = rb_ary_new();
230
rb_iterate(rb_each, obj, rb_block_given_p() ? collect_i : collect_all, ary);
238
* enum.entries => array
240
* Returns an array containing the items in <i>enum</i>.
242
* (1..7).to_a #=> [1, 2, 3, 4, 5, 6, 7]
243
* { 'a'=>1, 'b'=>2, 'c'=>3 }.to_a #=> [["a", 1], ["b", 2], ["c", 3]]
249
VALUE ary = rb_ary_new();
251
rb_iterate(rb_each, obj, collect_all, ary);
261
if (*memo == Qundef) {
265
*memo = rb_yield_values(2, *memo, i);
272
* enum.inject(initial) {| memo, obj | block } => obj
273
* enum.inject {| memo, obj | block } => obj
275
* Combines the elements of <i>enum</i> by applying the block to an
276
* accumulator value (<i>memo</i>) and each element in turn. At each
277
* step, <i>memo</i> is set to the value returned by the block. The
278
* first form lets you supply an initial value for <i>memo</i>. The
279
* second form uses the first element of the collection as a the
280
* initial value (and skips that element while iterating).
283
* (5..10).inject {|sum, n| sum + n } #=> 45
284
* # Multiply some numbers
285
* (5..10).inject(1) {|product, n| product * n } #=> 151200
287
* # find the longest word
288
* longest = %w{ cat sheep bear }.inject do |memo,word|
289
* memo.length > word.length ? memo : word
291
* longest #=> "sheep"
293
* # find the length of the longest word
294
* longest = %w{ cat sheep bear }.inject(0) do |memo,word|
295
* memo >= word.length ? memo : word.length
302
enum_inject(argc, argv, obj)
308
if (rb_scan_args(argc, argv, "01", &memo) == 0)
310
rb_iterate(rb_each, obj, inject_i, (VALUE)&memo);
311
if (memo == Qundef) return Qnil;
319
if (RTEST(rb_yield(i))) {
320
rb_ary_push(ary[0], i);
323
rb_ary_push(ary[1], i);
330
* enum.partition {| obj | block } => [ true_array, false_array ]
332
* Returns two arrays, the first containing the elements of
333
* <i>enum</i> for which the block evaluates to true, the second
334
* containing the rest.
336
* (1..6).partition {|i| (i&1).zero?} #=> [[2, 4, 6], [1, 3, 5]]
346
ary[0] = rb_ary_new();
347
ary[1] = rb_ary_new();
348
rb_iterate(rb_each, obj, partition_i, (VALUE)ary);
350
return rb_assoc_new(ary[0], ary[1]);
356
* enum.sort {| a, b | block } => array
358
* Returns an array containing the items in <i>enum</i> sorted,
359
* either according to their own <code><=></code> method, or by using
360
* the results of the supplied block. The block should return -1, 0, or
361
* +1 depending on the comparison between <i>a</i> and <i>b</i>. As of
362
* Ruby 1.8, the method <code>Enumerable#sort_by</code> implements a
363
* built-in Schwartzian Transform, useful when key computation or
364
* comparison is expensive..
366
* %w(rhea kea flea).sort #=> ["flea", "kea", "rhea"]
367
* (1..10).sort {|a,b| b <=> a} #=> [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
374
return rb_ary_sort(enum_to_a(obj));
385
if (RBASIC(ary)->klass) {
386
rb_raise(rb_eRuntimeError, "sort_by reentered");
388
memo = rb_node_newnode(NODE_MEMO, v, i, 0);
389
rb_ary_push(ary, (VALUE)memo);
397
VALUE a = aa[0]->u1.value;
398
VALUE b = bb[0]->u1.value;
400
return rb_cmpint(rb_funcall(a, id_cmp, 1, b), a, b);
405
* enum.sort_by {| obj | block } => array
407
* Sorts <i>enum</i> using a set of keys generated by mapping the
408
* values in <i>enum</i> through the given block.
410
* %w{ apple pear fig }.sort_by {|word| word.length}
411
#=> ["fig", "pear", "apple"]
413
* The current implementation of <code>sort_by</code> generates an
414
* array of tuples containing the original collection element and the
415
* mapped value. This makes <code>sort_by</code> fairly expensive when
416
* the keysets are simple
418
* require 'benchmark'
421
* a = (1..100000).map {rand(100000)}
424
* b.report("Sort") { a.sort }
425
* b.report("Sort by") { a.sort_by {|a| a} }
430
* user system total real
431
* Sort 0.180000 0.000000 0.180000 ( 0.175469)
432
* Sort by 1.980000 0.040000 2.020000 ( 2.013586)
434
* However, consider the case where comparing the keys is a non-trivial
435
* operation. The following code sorts some files on modification time
436
* using the basic <code>sort</code> method.
439
* sorted = files.sort {|a,b| File.new(a).mtime <=> File.new(b).mtime}
440
* sorted #=> ["mon", "tues", "wed", "thurs"]
442
* This sort is inefficient: it generates two new <code>File</code>
443
* objects during every comparison. A slightly better technique is to
444
* use the <code>Kernel#test</code> method to generate the modification
448
* sorted = files.sort { |a,b|
449
* test(?M, a) <=> test(?M, b)
451
* sorted #=> ["mon", "tues", "wed", "thurs"]
453
* This still generates many unnecessary <code>Time</code> objects. A
454
* more efficient technique is to cache the sort keys (modification
455
* times in this case) before the sort. Perl users often call this
456
* approach a Schwartzian Transform, after Randal Schwartz. We
457
* construct a temporary array, where each element is an array
458
* containing our sort key along with the filename. We sort this array,
459
* and then extract the filename from the result.
461
* sorted = Dir["*"].collect { |f|
463
* }.sort.collect { |f| f[1] }
464
* sorted #=> ["mon", "tues", "wed", "thurs"]
466
* This is exactly what <code>sort_by</code> does internally.
468
* sorted = Dir["*"].sort_by {|f| test(?M, f)}
469
* sorted #=> ["mon", "tues", "wed", "thurs"]
479
if (TYPE(obj) == T_ARRAY) {
480
ary = rb_ary_new2(RARRAY(obj)->len);
485
RBASIC(ary)->klass = 0;
486
rb_iterate(rb_each, obj, sort_by_i, ary);
487
if (RARRAY(ary)->len > 1) {
488
qsort(RARRAY(ary)->ptr, RARRAY(ary)->len, sizeof(VALUE), sort_by_cmp, 0);
490
if (RBASIC(ary)->klass) {
491
rb_raise(rb_eRuntimeError, "sort_by reentered");
493
for (i=0; i<RARRAY(ary)->len; i++) {
494
RARRAY(ary)->ptr[i] = RNODE(RARRAY(ary)->ptr[i])->u2.value;
496
RBASIC(ary)->klass = rb_cArray;
505
if (!RTEST(rb_yield(i))) {
526
* enum.all? [{|obj| block } ] => true or false
528
* Passes each element of the collection to the given block. The method
529
* returns <code>true</code> if the block never returns
530
* <code>false</code> or <code>nil</code>. If the block is not given,
531
* Ruby adds an implicit block of <code>{|obj| obj}</code> (that is
532
* <code>all?</code> will return <code>true</code> only if none of the
533
* collection members are <code>false</code> or <code>nil</code>.)
535
* %w{ ant bear cat}.all? {|word| word.length >= 3} #=> true
536
* %w{ ant bear cat}.all? {|word| word.length >= 4} #=> false
537
* [ nil, true, 99 ].all? #=> false
545
VALUE result = Qtrue;
547
rb_iterate(rb_each, obj, rb_block_given_p() ? all_iter_i : all_i, (VALUE)&result);
556
if (RTEST(rb_yield(i))) {
577
* enum.any? [{|obj| block } ] => true or false
579
* Passes each element of the collection to the given block. The method
580
* returns <code>true</code> if the block ever returns a value other
581
* than <code>false</code> or <code>nil</code>. If the block is not
582
* given, Ruby adds an implicit block of <code>{|obj| obj}</code> (that
583
* is <code>any?</code> will return <code>true</code> if at least one
584
* of the collection members is not <code>false</code> or
587
* %w{ ant bear cat}.any? {|word| word.length >= 3} #=> true
588
* %w{ ant bear cat}.any? {|word| word.length >= 4} #=> true
589
* [ nil, true, 99 ].any? #=> true
597
VALUE result = Qfalse;
599
rb_iterate(rb_each, obj, rb_block_given_p() ? any_iter_i : any_i, (VALUE)&result);
610
if (*memo == Qundef) {
614
cmp = rb_funcall(i, id_cmp, 1, *memo);
615
if (rb_cmpint(cmp, i, *memo) < 0) {
629
if (*memo == Qundef) {
633
cmp = rb_yield_values(2, i, *memo);
634
if (rb_cmpint(cmp, i, *memo) < 0) {
645
* enum.min {| a,b | block } => obj
647
* Returns the object in <i>enum</i> with the minimum value. The
648
* first form assumes all objects implement <code>Comparable</code>;
649
* the second uses the block to return <em>a <=> b</em>.
651
* a = %w(albatross dog horse)
652
* a.min #=> "albatross"
653
* a.min {|a,b| a.length <=> b.length } #=> "dog"
660
VALUE result = Qundef;
662
rb_iterate(rb_each, obj, rb_block_given_p() ? min_ii : min_i, (VALUE)&result);
663
if (result == Qundef) return Qnil;
670
* enum.max {| a,b | block } => obj
672
* Returns the object in <i>enum</i> with the maximum value. The
673
* first form assumes all objects implement <code>Comparable</code>;
674
* the second uses the block to return <em>a <=> b</em>.
676
* a = %w(albatross dog horse)
678
* a.max {|a,b| a.length <=> b.length } #=> "albatross"
688
if (*memo == Qundef) {
692
cmp = rb_funcall(i, id_cmp, 1, *memo);
693
if (rb_cmpint(cmp, i, *memo) > 0) {
707
if (*memo == Qundef) {
711
cmp = rb_yield_values(2, i, *memo);
712
if (rb_cmpint(cmp, i, *memo) > 0) {
722
* enum.max {|a,b| block } => obj
724
* Returns the object in _enum_ with the maximum value. The
725
* first form assumes all objects implement <code>Comparable</code>;
726
* the second uses the block to return <em>a <=> b</em>.
728
* a = %w(albatross dog horse)
730
* a.max {|a,b| a.length <=> b.length } #=> "albatross"
737
VALUE result = Qundef;
739
rb_iterate(rb_each, obj, rb_block_given_p() ? max_ii : max_i, (VALUE)&result);
740
if (result == Qundef) return Qnil;
749
if (rb_equal(item, memo[0])) {
758
* enum.include?(obj) => true or false
759
* enum.member?(obj) => true or false
761
* Returns <code>true</code> if any member of <i>enum</i> equals
762
* <i>obj</i>. Equality is tested using <code>==</code>.
764
* IO.constants.include? "SEEK_SET" #=> true
765
* IO.constants.include? "SEEK_NO_FURTHER" #=> false
770
enum_member(obj, val)
777
rb_iterate(rb_each, obj, member_i, (VALUE)memo);
782
each_with_index_i(val, memo)
786
rb_yield_values(2, val, INT2FIX(*memo));
793
* enum.each_with_index {|obj, i| block } -> enum
795
* Calls <em>block</em> with two arguments, the item and its index, for
796
* each item in <i>enum</i>.
799
* %w(cat dog wombat).each_with_index {|item, index|
802
* hash #=> {"cat"=>0, "wombat"=>2, "dog"=>1}
807
enum_each_with_index(obj)
813
rb_iterate(rb_each, obj, each_with_index_i, (VALUE)&memo);
822
VALUE result = memo[0];
823
VALUE args = memo[1];
828
tmp = rb_ary_new2(RARRAY(args)->len + 1);
829
rb_ary_store(tmp, 0, val);
830
for (i=0; i<RARRAY(args)->len; i++) {
831
rb_ary_push(tmp, rb_ary_entry(RARRAY(args)->ptr[i], idx));
833
if (rb_block_given_p()) {
837
rb_ary_push(result, tmp);
844
* enum.zip(arg, ...) => array
845
* enum.zip(arg, ...) {|arr| block } => nil
847
* Converts any arguments to arrays, then merges elements of
848
* <i>enum</i> with corresponding elements from each argument. This
849
* generates a sequence of <code>enum#size</code> <em>n</em>-element
850
* arrays, where <em>n</em> is one more that the count of arguments. If
851
* the size of any argument is less than <code>enum#size</code>,
852
* <code>nil</code> values are supplied. If a block given, it is
853
* invoked for each output array, otherwise an array of arrays is
859
* (1..3).zip(a, b) #=> [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
860
* "cat\ndog".zip([1]) #=> [["cat\n", 1], ["dog", nil]]
861
* (1..3).zip #=> [[1], [2], [3]]
866
enum_zip(argc, argv, obj)
875
for (i=0; i<argc; i++) {
876
argv[i] = rb_convert_type(argv[i], T_ARRAY, "Array", "to_a");
878
result = rb_block_given_p() ? Qnil : rb_ary_new();
880
memo[1] = rb_ary_new4(argc, argv);
882
rb_iterate(rb_each, obj, zip_i, (VALUE)memo);
888
* The <code>Enumerable</code> mixin provides collection classes with
889
* several traversal and searching methods, and with the ability to
890
* sort. The class must provide a method <code>each</code>, which
891
* yields successive members of the collection. If
892
* <code>Enumerable#max</code>, <code>#min</code>, or
893
* <code>#sort</code> is used, the objects in the collection must also
894
* implement a meaningful <code><=></code> operator, as these methods
895
* rely on an ordering between members of the collection.
901
rb_mEnumerable = rb_define_module("Enumerable");
903
rb_define_method(rb_mEnumerable,"to_a", enum_to_a, 0);
904
rb_define_method(rb_mEnumerable,"entries", enum_to_a, 0);
906
rb_define_method(rb_mEnumerable,"sort", enum_sort, 0);
907
rb_define_method(rb_mEnumerable,"sort_by", enum_sort_by, 0);
908
rb_define_method(rb_mEnumerable,"grep", enum_grep, 1);
909
rb_define_method(rb_mEnumerable,"find", enum_find, -1);
910
rb_define_method(rb_mEnumerable,"detect", enum_find, -1);
911
rb_define_method(rb_mEnumerable,"find_all", enum_find_all, 0);
912
rb_define_method(rb_mEnumerable,"select", enum_find_all, 0);
913
rb_define_method(rb_mEnumerable,"reject", enum_reject, 0);
914
rb_define_method(rb_mEnumerable,"collect", enum_collect, 0);
915
rb_define_method(rb_mEnumerable,"map", enum_collect, 0);
916
rb_define_method(rb_mEnumerable,"inject", enum_inject, -1);
917
rb_define_method(rb_mEnumerable,"partition", enum_partition, 0);
918
rb_define_method(rb_mEnumerable,"all?", enum_all, 0);
919
rb_define_method(rb_mEnumerable,"any?", enum_any, 0);
920
rb_define_method(rb_mEnumerable,"min", enum_min, 0);
921
rb_define_method(rb_mEnumerable,"max", enum_max, 0);
922
rb_define_method(rb_mEnumerable,"member?", enum_member, 1);
923
rb_define_method(rb_mEnumerable,"include?", enum_member, 1);
924
rb_define_method(rb_mEnumerable,"each_with_index", enum_each_with_index, 0);
925
rb_define_method(rb_mEnumerable, "zip", enum_zip, -1);
927
id_eqq = rb_intern("===");
928
id_each = rb_intern("each");
929
id_cmp = rb_intern("<=>");
added
removed
enum.c
