Returns a new array populated with the given objects.

Array.[](1,'a',/^A/)# => [1, "a", /^A/]Array[1,'a',/^A/ ]# => [1, "a", /^A/][1,'a',/^A/ ]# => [1, "a", /^A/]

                static VALUErb_ary_s_create(int argc, VALUE *argv, VALUE klass){    VALUE ary = ary_new(klass, argc);    if (argc > 0 && argv) {        ary_memcpy(ary, 0, argc, argv);        ARY_SET_LEN(ary, argc);    }    return ary;}

Returns a new Array.

With no block and no arguments, returns a new empty Array object.

With no block and a single Array argumentarray, returns a newArray formed fromarray:

a =Array.new([:foo,'bar',2])a.class# => Arraya# => [:foo, "bar", 2]

With no block and a single Integer argumentsize, returns anew Array of the given size whose elements are allnil:

a =Array.new(3)a# => [nil, nil, nil]

With no block and argumentssize anddefault_value, returns an Array of the given size; eachelement is that samedefault_value:

a =Array.new(3,'x')a# => ['x', 'x', 'x']

With a block and argumentsize, returns an Array of the givensize; the block is called with each successive integerindex;the element for thatindex is the return value from the block:

a =Array.new(3) {|index|"Element #{index}" }a# => ["Element 0", "Element 1", "Element 2"]

RaisesArgumentError ifsizeis negative.

With a block and no argument, or a single argument0, ignoresthe block and returns a new empty Array.

                static VALUErb_ary_initialize(int argc, VALUE *argv, VALUE ary){    long len;    VALUE size, val;    rb_ary_modify(ary);    if (argc == 0) {        if (ARY_OWNS_HEAP_P(ary) && ARY_HEAP_PTR(ary) != NULL) {            ary_heap_free(ary);        }        rb_ary_unshare_safe(ary);        FL_SET_EMBED(ary);        ARY_SET_EMBED_LEN(ary, 0);        if (rb_block_given_p()) {            rb_warning("given block not used");        }        return ary;    }    rb_scan_args(argc, argv, "02", &size, &val);    if (argc == 1 && !FIXNUM_P(size)) {        val = rb_check_array_type(size);        if (!NIL_P(val)) {            rb_ary_replace(ary, val);            return ary;        }    }    len = NUM2LONG(size);    /* NUM2LONG() may call size.to_int, ary can be frozen, modified, etc */    if (len < 0) {        rb_raise(rb_eArgError, "negative array size");    }    if (len > ARY_MAX_SIZE) {        rb_raise(rb_eArgError, "array size too big");    }    /* recheck after argument conversion */    rb_ary_modify(ary);    ary_resize_capa(ary, len);    if (rb_block_given_p()) {        long i;        if (argc == 2) {            rb_warn("block supersedes default value argument");        }        for (i=0; i<len; i++) {            rb_ary_store(ary, i, rb_yield(LONG2NUM(i)));            ARY_SET_LEN(ary, i + 1);        }    }    else {        ary_memfill(ary, 0, len, val);        ARY_SET_LEN(ary, len);    }    return ary;}

Ifobject is an Array object, returnsobject.

Otherwise ifobject responds to:to_ary, callsobject.to_ary and returns the result.

Returnsnil ifobject does not respond to:to_ary

Raises an exception unlessobject.to_ary returns an Arrayobject.

                static VALUErb_ary_s_try_convert(VALUE dummy, VALUE ary){    return rb_check_array_type(ary);}

Returns a new Array containing each element found in botharray and Arrayother_array; duplicates areomitted; items are compared usingeql?:

[0,1,2,3]& [1,2]# => [1, 2][0,1,0,1]& [0,1]# => [0, 1]

Preserves order fromarray:

[0,1,2]& [3,2,1,0]# => [0, 1, 2]

Related:#intersection.

                static VALUErb_ary_and(VALUE ary1, VALUE ary2){    VALUE hash, ary3, v;    st_data_t vv;    long i;    ary2 = to_ary(ary2);    ary3 = rb_ary_new();    if (RARRAY_LEN(ary1) == 0 || RARRAY_LEN(ary2) == 0) return ary3;    if (RARRAY_LEN(ary1) <= SMALL_ARRAY_LEN && RARRAY_LEN(ary2) <= SMALL_ARRAY_LEN) {        for (i=0; i<RARRAY_LEN(ary1); i++) {            v = RARRAY_AREF(ary1, i);            if (!rb_ary_includes_by_eql(ary2, v)) continue;            if (rb_ary_includes_by_eql(ary3, v)) continue;            rb_ary_push(ary3, v);        }        return ary3;    }    hash = ary_make_hash(ary2);    for (i=0; i<RARRAY_LEN(ary1); i++) {        v = RARRAY_AREF(ary1, i);        vv = (st_data_t)v;        if (rb_hash_stlike_delete(hash, &vv, 0)) {            rb_ary_push(ary3, v);        }    }    ary_recycle_hash(hash);    return ary3;}

When non-negative argument Integern is given, returns a newArray built by concatenating then copies ofself:

a = ['x','y']a*3# => ["x", "y", "x", "y", "x", "y"]

When String argumentstring_separator is given, equivalent toarray.join(string_separator):

[0, [0,1], {foo:0}]*', '# => "0, 0, 1, {:foo=>0}"

                static VALUErb_ary_times(VALUE ary, VALUE times){    VALUE ary2, tmp;    const VALUE *ptr;    long t, len;    tmp = rb_check_string_type(times);    if (!NIL_P(tmp)) {        return rb_ary_join(ary, tmp);    }    len = NUM2LONG(times);    if (len == 0) {        ary2 = ary_new(rb_cArray, 0);        goto out;    }    if (len < 0) {        rb_raise(rb_eArgError, "negative argument");    }    if (ARY_MAX_SIZE/len < RARRAY_LEN(ary)) {        rb_raise(rb_eArgError, "argument too big");    }    len *= RARRAY_LEN(ary);    ary2 = ary_new(rb_cArray, len);    ARY_SET_LEN(ary2, len);    ptr = RARRAY_CONST_PTR_TRANSIENT(ary);    t = RARRAY_LEN(ary);    if (0 < t) {        ary_memcpy(ary2, 0, t, ptr);        while (t <= len/2) {            ary_memcpy(ary2, t, t, RARRAY_CONST_PTR_TRANSIENT(ary2));            t *= 2;        }        if (t < len) {            ary_memcpy(ary2, t, len-t, RARRAY_CONST_PTR_TRANSIENT(ary2));        }    }  out:    return ary2;}

Returns a new Array containing all elements ofarray followedby all elements ofother_array:

a = [0,1]+ [2,3]a# => [0, 1, 2, 3]

Related:concat.

                VALUErb_ary_plus(VALUE x, VALUE y){    VALUE z;    long len, xlen, ylen;    y = to_ary(y);    xlen = RARRAY_LEN(x);    ylen = RARRAY_LEN(y);    len = xlen + ylen;    z = rb_ary_new2(len);    ary_memcpy(z, 0, xlen, RARRAY_CONST_PTR_TRANSIENT(x));    ary_memcpy(z, xlen, ylen, RARRAY_CONST_PTR_TRANSIENT(y));    ARY_SET_LEN(z, len);    return z;}

Returns a new Array containing only those elements fromarraythat are not found in Arrayother_array; items are comparedusingeql?; the order fromarray is preserved:

[0,1,1,2,1,1,3,1,1]- [1]# => [0, 2, 3][0,1,2,3]- [3,0]# => [1, 2][0,1,2]- [4]# => [0, 1, 2]

Related:#difference.

                static VALUErb_ary_diff(VALUE ary1, VALUE ary2){    VALUE ary3;    VALUE hash;    long i;    ary2 = to_ary(ary2);    ary3 = rb_ary_new();    if (RARRAY_LEN(ary1) <= SMALL_ARRAY_LEN || RARRAY_LEN(ary2) <= SMALL_ARRAY_LEN) {        for (i=0; i<RARRAY_LEN(ary1); i++) {            VALUE elt = rb_ary_elt(ary1, i);            if (rb_ary_includes_by_eql(ary2, elt)) continue;            rb_ary_push(ary3, elt);        }        return ary3;    }    hash = ary_make_hash(ary2);    for (i=0; i<RARRAY_LEN(ary1); i++) {        if (rb_hash_stlike_lookup(hash, RARRAY_AREF(ary1, i), NULL)) continue;        rb_ary_push(ary3, rb_ary_elt(ary1, i));    }    ary_recycle_hash(hash);    return ary3;}

Appendsobject toself; returnsself:

a = [:foo,'bar',2]a<< :baz# => [:foo, "bar", 2, :baz]

Appendsobject as one element, even if it is another Array:

a = [:foo,'bar',2]a1 =a<< [3,4]a1# => [:foo, "bar", 2, [3, 4]]

                VALUErb_ary_push(VALUE ary, VALUE item){    long idx = RARRAY_LEN((ary_verify(ary), ary));    VALUE target_ary = ary_ensure_room_for_push(ary, 1);    RARRAY_PTR_USE_TRANSIENT(ary, ptr, {        RB_OBJ_WRITE(target_ary, &ptr[idx], item);    });    ARY_SET_LEN(ary, idx + 1);    ary_verify(ary);    return ary;}

Returns -1, 0, or 1 asself is less than, equal to, or greaterthanother_array. For each indexi inself, evaluatesresult = self[i] <=>other_array[i].

Returns -1 if any result is -1:

[0,1,2]<=> [0,1,3]# => -1

Returns 1 if any result is 1:

[0,1,2]<=> [0,1,1]# => 1

When all results are zero:

• Returns -1 ifarray is smaller thanother_array:

  [0,1,2]<=> [0,1,2,3]# => -1

• Returns 1 ifarray is larger thanother_array:

  [0,1,2]<=> [0,1]# => 1

• Returns 0 ifarray andother_array are the samesize:

  [0,1,2]<=> [0,1,2]# => 0

                VALUErb_ary_cmp(VALUE ary1, VALUE ary2){    long len;    VALUE v;    ary2 = rb_check_array_type(ary2);    if (NIL_P(ary2)) return Qnil;    if (ary1 == ary2) return INT2FIX(0);    v = rb_exec_recursive_paired(recursive_cmp, ary1, ary2, ary2);    if (v != Qundef) return v;    len = RARRAY_LEN(ary1) - RARRAY_LEN(ary2);    if (len == 0) return INT2FIX(0);    if (len > 0) return INT2FIX(1);    return INT2FIX(-1);}

Returnstrue if botharray.size ==other_array.size and for each indexi inarray,array[i] == other_array[i]:

a0 = [:foo,'bar',2]a1 = [:foo,'bar',2.0]a1==a0# => true[]== []# => true

Otherwise, returnsfalse.

This method is different from method#eql?, which compares elements usingObject#eql?.

                static VALUErb_ary_equal(VALUE ary1, VALUE ary2){    if (ary1 == ary2) return Qtrue;    if (!RB_TYPE_P(ary2, T_ARRAY)) {        if (!rb_respond_to(ary2, idTo_ary)) {            return Qfalse;        }        return rb_equal(ary2, ary1);    }    if (RARRAY_LEN(ary1) != RARRAY_LEN(ary2)) return Qfalse;    if (RARRAY_CONST_PTR_TRANSIENT(ary1) == RARRAY_CONST_PTR_TRANSIENT(ary2)) return Qtrue;    return rb_exec_recursive_paired(recursive_equal, ary1, ary2, ary2);}

Returns elements fromself; does not modifyself.

When a single Integer argumentindex is given, returns theelement at offsetindex:

a = [:foo,'bar',2]a[0]# => :fooa[2]# => 2a# => [:foo, "bar", 2]

Ifindex is negative, counts relative to the end ofself:

a = [:foo,'bar',2]a[-1]# => 2a[-2]# => "bar"

Ifindex is out of range, returnsnil.

When two Integer argumentsstart andlength aregiven, returns a new Array of sizelength containingsuccessive elements beginning at offsetstart:

a = [:foo,'bar',2]a[0,2]# => [:foo, "bar"]a[1,2]# => ["bar", 2]

Ifstart + length is greater thanself.length,returns all elements from offsetstart to the end:

a = [:foo,'bar',2]a[0,4]# => [:foo, "bar", 2]a[1,3]# => ["bar", 2]a[2,2]# => [2]

Ifstart == self.size andlength >= 0, returnsa new empty Array.

Iflength is negative, returnsnil.

When a single Range argumentrange is given, treatsrange.min asstart above andrange.size aslength above:

a = [:foo,'bar',2]a[0..1]# => [:foo, "bar"]a[1..2]# => ["bar", 2]

Special case: Ifrange.start == a.size, returns a new emptyArray.

Ifrange.end is negative, calculates the end index from theend:

a = [:foo,'bar',2]a[0..-1]# => [:foo, "bar", 2]a[0..-2]# => [:foo, "bar"]a[0..-3]# => [:foo]

Ifrange.start is negative, calculates the start index fromthe end:

a = [:foo,'bar',2]a[-1..2]# => [2]a[-2..2]# => ["bar", 2]a[-3..2]# => [:foo, "bar", 2]

Ifrange.start is larger than the array size, returnsnil.

a = [:foo,'bar',2]a[4..1]# => nila[4..0]# => nila[4..-1]# => nil

When a singleEnumerator::ArithmeticSequenceargumentaseq is given, returns anArray of elements corresponding to the indexesproduced by the sequence.

a = ['--', 'data1', '--', 'data2', '--', 'data3']a[(1..).step(2)] # => ["data1", "data2", "data3"]

Unlike slicing with range, if the start or the end of the arithmeticsequence is larger than array size, throwsRangeError.

a = ['--', 'data1', '--', 'data2', '--', 'data3']a[(1..11).step(2)]# RangeError (((1..11).step(2)) out of range)a[(7..).step(2)]# RangeError (((7..).step(2)) out of range)

If given a single argument, and its type is not one of the listed, tries toconvert it toInteger, and raises if it isimpossible:

a = [:foo,'bar',2]# Raises TypeError (no implicit conversion of Symbol into Integer):a[:foo]

#slice is an alias for#[].

                VALUErb_ary_aref(int argc, const VALUE *argv, VALUE ary){    rb_check_arity(argc, 1, 2);    if (argc == 2) {        return rb_ary_aref2(ary, argv[0], argv[1]);    }    return rb_ary_aref1(ary, argv[0]);}

Assigns elements inself; returns the givenobject.

When Integer argumentindex is given, assignsobject to an element inself.

Ifindex is non-negative, assignsobject theelement at offsetindex:

a = [:foo,'bar',2]a[0] ='foo'# => "foo"a# => ["foo", "bar", 2]

Ifindex is greater thanself.length, extends thearray:

a = [:foo,'bar',2]a[7] ='foo'# => "foo"a# => [:foo, "bar", 2, nil, nil, nil, nil, "foo"]

Ifindex is negative, counts backwards from the end of thearray:

a = [:foo,'bar',2]a[-1] ='two'# => "two"a# => [:foo, "bar", "two"]

When Integer argumentsstart andlength are givenandobject is not an Array, removeslength - 1elements beginning at offsetstart, and assignsobject at offsetstart:

a = [:foo,'bar',2]a[0,2] ='foo'# => "foo"a# => ["foo", 2]

Ifstart is negative, counts backwards from the end of thearray:

a = [:foo,'bar',2]a[-2,2] ='foo'# => "foo"a# => [:foo, "foo"]

Ifstart is non-negative and outside the array ( >=self.size), extends the array withnil, assignsobject at offsetstart, and ignoreslength:

a = [:foo,'bar',2]a[6,50] ='foo'# => "foo"a# => [:foo, "bar", 2, nil, nil, nil, "foo"]

Iflength is zero, shifts elements at and following offsetstart and assignsobject at offsetstart:

a = [:foo,'bar',2]a[1,0] ='foo'# => "foo"a# => [:foo, "foo", "bar", 2]

Iflength is too large for the existing array, does not extendthe array:

a = [:foo,'bar',2]a[1,5] ='foo'# => "foo"a# => [:foo, "foo"]

When Range argumentrange is given andobject isan Array, removeslength - 1 elements beginning at offsetstart, and assignsobject at offsetstart:

a = [:foo,'bar',2]a[0..1] ='foo'# => "foo"a# => ["foo", 2]

ifrange.begin is negative, counts backwards from the end ofthe array:

a = [:foo,'bar',2]a[-2..2] ='foo'# => "foo"a# => [:foo, "foo"]

If the array length is less thanrange.begin, assignsobject at offsetrange.begin, and ignoreslength:

a = [:foo,'bar',2]a[6..50] ='foo'# => "foo"a# => [:foo, "bar", 2, nil, nil, nil, "foo"]

Ifrange.end is zero, shifts elements at and following offsetstart and assignsobject at offsetstart:

a = [:foo,'bar',2]a[1..0] ='foo'# => "foo"a# => [:foo, "foo", "bar", 2]

Ifrange.end is negative, assignsobject atoffsetstart, retainsrange.end.abs -1 elementspast that, and removes those beyond:

a = [:foo,'bar',2]a[1..-1] ='foo'# => "foo"a# => [:foo, "foo"]a = [:foo,'bar',2]a[1..-2] ='foo'# => "foo"a# => [:foo, "foo", 2]a = [:foo,'bar',2]a[1..-3] ='foo'# => "foo"a# => [:foo, "foo", "bar", 2]a = [:foo,'bar',2]

Ifrange.end is too large for the existing array, replacesarray elements, but does not extend the array withnil values:

a = [:foo,'bar',2]a[1..5] ='foo'# => "foo"a# => [:foo, "foo"]

                static VALUErb_ary_aset(int argc, VALUE *argv, VALUE ary){    long offset, beg, len;    rb_check_arity(argc, 2, 3);    rb_ary_modify_check(ary);    if (argc == 3) {        beg = NUM2LONG(argv[0]);        len = NUM2LONG(argv[1]);        return ary_aset_by_rb_ary_splice(ary, beg, len, argv[2]);    }    if (FIXNUM_P(argv[0])) {        offset = FIX2LONG(argv[0]);        return ary_aset_by_rb_ary_store(ary, offset, argv[1]);    }    if (rb_range_beg_len(argv[0], &beg, &len, RARRAY_LEN(ary), 1)) {        /* check if idx is Range */        return ary_aset_by_rb_ary_splice(ary, beg, len, argv[1]);    }    offset = NUM2LONG(argv[0]);    return ary_aset_by_rb_ary_store(ary, offset, argv[1]);}

Returnstrue if all elements ofself meet a givencriterion.

With no block given and no argument, returnstrue ifself contains only truthy elements,falseotherwise:

[0,1, :foo].all?# => true[0,nil,2].all?# => false[].all?# => true

With a block given and no argument, calls the block with each element inself; returnstrue if the block returns onlytruthy values,false otherwise:

[0,1,2].all? {|element|element<3 }# => true[0,1,2].all? {|element|element<2 }# => false

If argumentobj is given, returnstrue ifobj.=== every element,false otherwise:

['food','fool','foot'].all?(/foo/)# => true['food','drink'].all?(/bar/)# => false[].all?(/foo/)# => true[0,0,0].all?(0)# => true[0,1,2].all?(1)# => false

Related:Enumerable#all?

                static VALUErb_ary_all_p(int argc, VALUE *argv, VALUE ary){    long i, len = RARRAY_LEN(ary);    rb_check_arity(argc, 0, 1);    if (!len) return Qtrue;    if (argc) {        if (rb_block_given_p()) {            rb_warn("given block not used");        }        for (i = 0; i < RARRAY_LEN(ary); ++i) {            if (!RTEST(rb_funcall(argv[0], idEqq, 1, RARRAY_AREF(ary, i)))) return Qfalse;        }    }    else if (!rb_block_given_p()) {        for (i = 0; i < len; ++i) {            if (!RTEST(RARRAY_AREF(ary, i))) return Qfalse;        }    }    else {        for (i = 0; i < RARRAY_LEN(ary); ++i) {            if (!RTEST(rb_yield(RARRAY_AREF(ary, i)))) return Qfalse;        }    }    return Qtrue;}

Returnstrue if any element ofself meets a givencriterion.

With no block given and no argument, returnstrue ifself has any truthy element,false otherwise:

[nil,0,false].any?# => true[nil,false].any?# => false[].any?# => false

With a block given and no argument, calls the block with each element inself; returnstrue if the block returns anytruthy value,false otherwise:

[0,1,2].any? {|element|element>1 }# => true[0,1,2].any? {|element|element>2 }# => false

If argumentobj is given, returnstrue ifobj.=== any element,falseotherwise:

['food','drink'].any?(/foo/)# => true['food','drink'].any?(/bar/)# => false[].any?(/foo/)# => false[0,1,2].any?(1)# => true[0,1,2].any?(3)# => false

Related:Enumerable#any?

                static VALUErb_ary_any_p(int argc, VALUE *argv, VALUE ary){    long i, len = RARRAY_LEN(ary);    rb_check_arity(argc, 0, 1);    if (!len) return Qfalse;    if (argc) {        if (rb_block_given_p()) {            rb_warn("given block not used");        }        for (i = 0; i < RARRAY_LEN(ary); ++i) {            if (RTEST(rb_funcall(argv[0], idEqq, 1, RARRAY_AREF(ary, i)))) return Qtrue;        }    }    else if (!rb_block_given_p()) {        for (i = 0; i < len; ++i) {            if (RTEST(RARRAY_AREF(ary, i))) return Qtrue;        }    }    else {        for (i = 0; i < RARRAY_LEN(ary); ++i) {            if (RTEST(rb_yield(RARRAY_AREF(ary, i)))) return Qtrue;        }    }    return Qfalse;}

Returns the first element inself that is an Array whose firstelement==obj:

a = [{foo:0}, [2,4], [4,5,6], [4,5]]a.assoc(4)# => [4, 5, 6]

Returnsnil if no such element is found.

Related:rassoc.

                VALUErb_ary_assoc(VALUE ary, VALUE key){    long i;    VALUE v;    for (i = 0; i < RARRAY_LEN(ary); ++i) {        v = rb_check_array_type(RARRAY_AREF(ary, i));        if (!NIL_P(v) && RARRAY_LEN(v) > 0 &&            rb_equal(RARRAY_AREF(v, 0), key))            return v;    }    return Qnil;}

Returns the element at Integer offsetindex; does not modifyself.

a = [:foo,'bar',2]a.at(0)# => :fooa.at(2)# => 2

                VALUErb_ary_at(VALUE ary, VALUE pos){    return rb_ary_entry(ary, NUM2LONG(pos));}

Returns an element fromself selected by a binary search.self should be sorted, but this is not checked.

By using binary search, finds a value from this array which meets the givencondition inO(log n) wheren is the size of thearray.

There are two search modes:

• Find-minimum mode: the block should returntrue orfalse.

• Find-any mode: the block should return a numeric value.

The block should not mix the modes by and sometimes returningtrue orfalse and sometimes returning a numericvalue, but this is not checked.

Find-Minimum Mode

In find-minimum mode, the block always returnstrue orfalse. The further requirement (though not checked) is thatthere are no indexesi andj such that:

• 0 <= i < j <= self.size.

• The block returnstrue forself[i] andfalse forself[j].

In find-minimum mode, method bsearch returns the first element for whichthe block returns true.

Examples:

a = [0,4,7,10,12]a.bsearch {|x|x>=4 }# => 4a.bsearch {|x|x>=6 }# => 7a.bsearch {|x|x>=-1 }# => 0a.bsearch {|x|x>=100 }# => nil

Less formally: the block is such that allfalse-evaluatingelements precede alltrue-evaluating elements.

These make sense as blocks in find-minimum mode:

a = [0,4,7,10,12]a.map {|x|x>=4 }# => [false, true, true, true, true]a.map {|x|x>=6 }# => [false, false, true, true, true]a.map {|x|x>=-1 }# => [true, true, true, true, true]a.map {|x|x>=100 }# => [false, false, false, false, false]

This would not make sense:

a = [0,4,7,10,12]a.map {|x|x==7 }# => [false, false, true, false, false]

Find-Any Mode

In find-any mode, the block always returns a numeric value. The furtherrequirement (though not checked) is that there are no indexesi andj such that:

• 0 <= i < j <= self.size.

• The block returns a negative value forself[i] and a positivevalue forself[j].

• The block returns a negative value forself[i] and zeroself[j].

• The block returns zero forself[i] and a positive value forself[j].

In find-any mode, method bsearch returns some element for which the blockreturns zero, ornil if no such element is found.

Examples:

a = [0,4,7,10,12]a.bsearch {|element|7<=>element }# => 7a.bsearch {|element|-1<=>element }# => nila.bsearch {|element|5<=>element }# => nila.bsearch {|element|15<=>element }# => nil

Less formally: the block is such that:

• All positive-evaluating elements precede all zero-evaluating elements.

• All positive-evaluating elements precede all negative-evaluating elements.

• All zero-evaluating elements precede all negative-evaluating elements.

These make sense as blocks in find-any mode:

a = [0,4,7,10,12]a.map {|element|7<=>element }# => [1, 1, 0, -1, -1]a.map {|element|-1<=>element }# => [-1, -1, -1, -1, -1]a.map {|element|5<=>element }# => [1, 1, -1, -1, -1]a.map {|element|15<=>element }# => [1, 1, 1, 1, 1]

This would not make sense:

a = [0,4,7,10,12]a.map {|element|element<=>7 }# => [-1, -1, 0, 1, 1]

Returns an enumerator if no block given:

a = [0,4,7,10,12]a.bsearch# => #<Enumerator: [0, 4, 7, 10, 12]:bsearch>

                static VALUErb_ary_bsearch(VALUE ary){    VALUE index_result = rb_ary_bsearch_index(ary);    if (FIXNUM_P(index_result)) {        return rb_ary_entry(ary, FIX2LONG(index_result));    }    return index_result;}

Searchesself as described at methodbsearch, but returns theindex of the found element instead of the element itself.

                static VALUErb_ary_bsearch_index(VALUE ary){    long low = 0, high = RARRAY_LEN(ary), mid;    int smaller = 0, satisfied = 0;    VALUE v, val;    RETURN_ENUMERATOR(ary, 0, 0);    while (low < high) {        mid = low + ((high - low) / 2);        val = rb_ary_entry(ary, mid);        v = rb_yield(val);        if (FIXNUM_P(v)) {            if (v == INT2FIX(0)) return INT2FIX(mid);            smaller = (SIGNED_VALUE)v < 0; /* Fixnum preserves its sign-bit */        }        else if (v == Qtrue) {            satisfied = 1;            smaller = 1;        }        else if (v == Qfalse || v == Qnil) {            smaller = 0;        }        else if (rb_obj_is_kind_of(v, rb_cNumeric)) {            const VALUE zero = INT2FIX(0);            switch (rb_cmpint(rb_funcallv(v, id_cmp, 1, &zero), v, zero)) {              case 0: return INT2FIX(mid);              case 1: smaller = 1; break;              case -1: smaller = 0;            }        }        else {            rb_raise(rb_eTypeError, "wrong argument type %"PRIsVALUE                     " (must be numeric, true, false or nil)",                     rb_obj_class(v));        }        if (smaller) {            high = mid;        }        else {            low = mid + 1;        }    }    if (!satisfied) return Qnil;    return INT2FIX(low);}

Removes all elements fromself:

a = [:foo,'bar',2]a.clear# => []

                VALUErb_ary_clear(VALUE ary){    rb_ary_modify_check(ary);    if (ARY_SHARED_P(ary)) {        if (!ARY_EMBED_P(ary)) {            rb_ary_unshare(ary);            FL_SET_EMBED(ary);            ARY_SET_EMBED_LEN(ary, 0);        }    }    else {        ARY_SET_LEN(ary, 0);        if (ARY_DEFAULT_SIZE * 2 < ARY_CAPA(ary)) {            ary_resize_capa(ary, ARY_DEFAULT_SIZE * 2);        }    }    ary_verify(ary);    return ary;}

Calls the block, if given, with each element ofself; returnsa new Array whose elements are the return values from the block:

a = [:foo,'bar',2]a1 =a.map {|element|element.class }a1# => [Symbol, String, Integer]

Returns a new Enumerator if no block given:

a = [:foo,'bar',2]a1 =a.mapa1# => #<Enumerator: [:foo, "bar", 2]:map>

#collect is an alias for#map.

                static VALUErb_ary_collect(VALUE ary){    long i;    VALUE collect;    RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length);    collect = rb_ary_new2(RARRAY_LEN(ary));    for (i = 0; i < RARRAY_LEN(ary); i++) {        rb_ary_push(collect, rb_yield(RARRAY_AREF(ary, i)));    }    return collect;}

Calls the block, if given, with each element; replaces the element with theblock's return value:

a = [:foo,'bar',2]a.map! {|element|element.class }# => [Symbol, String, Integer]

Returns a new Enumerator if no block given:

a = [:foo,'bar',2]a1 =a.map!a1# => #<Enumerator: [:foo, "bar", 2]:map!>

#collect! is an alias for#map!.

                static VALUErb_ary_collect_bang(VALUE ary){    long i;    RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length);    rb_ary_modify(ary);    for (i = 0; i < RARRAY_LEN(ary); i++) {        rb_ary_store(ary, i, rb_yield(RARRAY_AREF(ary, i)));    }    return ary;}

Calls the block, if given, with combinations of elements ofself; returnsself. The order of combinations isindeterminate.

When a block and an in-range positive Integer argumentn(0 < n <= self.size) are given, calls the block with alln-tuple combinations ofself.

Example:

a = [0,1,2]a.combination(2) {|combination|pcombination }

Output:

[0,1][0,2][1,2]

Another example:

a = [0,1,2]a.combination(3) {|combination|pcombination }

Output:

[0,1,2]

Whenn is zero, calls the block once with a new empty Array:

a = [0,1,2]a1 =a.combination(0) {|combination|pcombination }

Output:

[]

Whenn is out of range (negative or larger thanself.size), does not call the block:

a = [0,1,2]a.combination(-1) {|combination|fail'Cannot happen' }a.combination(4) {|combination|fail'Cannot happen' }

Returns a new Enumerator if no block given:

a = [0,1,2]a.combination(2)# => #<Enumerator: [0, 1, 2]:combination(2)>

                static VALUErb_ary_combination(VALUE ary, VALUE num){    long i, n, len;    n = NUM2LONG(num);    RETURN_SIZED_ENUMERATOR(ary, 1, &num, rb_ary_combination_size);    len = RARRAY_LEN(ary);    if (n < 0 || len < n) {        /* yield nothing */    }    else if (n == 0) {        rb_yield(rb_ary_new2(0));    }    else if (n == 1) {        for (i = 0; i < RARRAY_LEN(ary); i++) {            rb_yield(rb_ary_new3(1, RARRAY_AREF(ary, i)));        }    }    else {        VALUE ary0 = ary_make_shared_copy(ary); /* private defensive copy of ary */        volatile VALUE t0;        long *stack = ALLOCV_N(long, t0, n+1);        RBASIC_CLEAR_CLASS(ary0);        combinate0(len, n, stack, ary0);        ALLOCV_END(t0);        RBASIC_SET_CLASS_RAW(ary0, rb_cArray);    }    return ary;}

Returns a new Array containing all non-nil elements fromself:

a = [nil,0,nil,1,nil,2,nil]a.compact# => [0, 1, 2]

                static VALUErb_ary_compact(VALUE ary){    ary = rb_ary_dup(ary);    rb_ary_compact_bang(ary);    return ary;}

Removes allnil elements fromself.

Returnsself if any elements removed, otherwisenil.

                static VALUErb_ary_compact_bang(VALUE ary){    VALUE *p, *t, *end;    long n;    rb_ary_modify(ary);    p = t = (VALUE *)RARRAY_CONST_PTR_TRANSIENT(ary); /* WB: no new reference */    end = p + RARRAY_LEN(ary);    while (t < end) {        if (NIL_P(*t)) t++;        else *p++ = *t++;    }    n = p - RARRAY_CONST_PTR_TRANSIENT(ary);    if (RARRAY_LEN(ary) == n) {        return Qnil;    }    ary_resize_smaller(ary, n);    return ary;}

Adds toarray all elements from each Array inother_arrays; returnsself:

a = [0,1]a.concat([2,3], [4,5])# => [0, 1, 2, 3, 4, 5]

                static VALUErb_ary_concat_multi(int argc, VALUE *argv, VALUE ary){    rb_ary_modify_check(ary);    if (argc == 1) {        rb_ary_concat(ary, argv[0]);    }    else if (argc > 1) {        int i;        VALUE args = rb_ary_tmp_new(argc);        for (i = 0; i < argc; i++) {            rb_ary_concat(args, argv[i]);        }        ary_append(ary, args);    }    ary_verify(ary);    return ary;}

Returns a count of specified elements.

With no argument and no block, returns the count of all elements:

[0,1,2].count# => 3[].count# => 0

With argumentobj, returns the count of elementseql? toobj:

[0,1,2,0].count(0)# => 2[0,1,2].count(3)# => 0

With no argument and a block given, calls the block with each element;returns the count of elements for which the block returns a truthy value:

[0,1,2,3].count {|element|element>1}# => 2

With argumentobj and a block given, issues a warning, ignoresthe block, and returns the count of elementseql? toobj:

                static VALUErb_ary_count(int argc, VALUE *argv, VALUE ary){    long i, n = 0;    if (rb_check_arity(argc, 0, 1) == 0) {        VALUE v;        if (!rb_block_given_p())            return LONG2NUM(RARRAY_LEN(ary));        for (i = 0; i < RARRAY_LEN(ary); i++) {            v = RARRAY_AREF(ary, i);            if (RTEST(rb_yield(v))) n++;        }    }    else {        VALUE obj = argv[0];        if (rb_block_given_p()) {            rb_warn("given block not used");        }        for (i = 0; i < RARRAY_LEN(ary); i++) {            if (rb_equal(RARRAY_AREF(ary, i), obj)) n++;        }    }    return LONG2NUM(n);}

When called with positive Integer argumentcount and a block,calls the block with each element, then does so again, until it has done socount times; returnsnil:

output = [][0,1].cycle(2) {|element|output.push(element) }# => niloutput# => [0, 1, 0, 1]

Ifcount is zero or negative, does not call the block:

[0,1].cycle(0) {|element|fail'Cannot happen' }# => nil[0,1].cycle(-1) {|element|fail'Cannot happen' }# => nil

When a block is given, and argument is omitted ornil, cyclesforever:

# Prints 0 and 1 forever.[0,1].cycle {|element|putselement }[0,1].cycle(nil) {|element|putselement }

When no block is given, returns a new Enumerator:

[0,1].cycle(2)# => #<Enumerator: [0, 1]:cycle(2)>[0,1].cycle# => # => #<Enumerator: [0, 1]:cycle>[0,1].cycle.first(5)# => [0, 1, 0, 1, 0]

                static VALUErb_ary_cycle(int argc, VALUE *argv, VALUE ary){    long n, i;    rb_check_arity(argc, 0, 1);    RETURN_SIZED_ENUMERATOR(ary, argc, argv, rb_ary_cycle_size);    if (argc == 0 || NIL_P(argv[0])) {        n = -1;    }    else {        n = NUM2LONG(argv[0]);        if (n <= 0) return Qnil;    }    while (RARRAY_LEN(ary) > 0 && (n < 0 || 0 < n--)) {        for (i=0; i<RARRAY_LEN(ary); i++) {            rb_yield(RARRAY_AREF(ary, i));        }    }    return Qnil;}

Removes zero or more elements fromself; returnsself.

When no block is given, removes fromself each elementele such thatele == obj; returns the lastdeleted element:

s1 ='bar';s2 ='bar'a = [:foo,s1,2,s2]a.delete('bar')# => "bar"a# => [:foo, 2]

Returnsnil if no elements removed.

When a block is given, removes fromself each elementele such thatele == obj.

If any such elements are found, ignores the block and returns the lastdeleted element:

s1 ='bar';s2 ='bar'a = [:foo,s1,2,s2]deleted_obj =a.delete('bar') {|obj|fail'Cannot happen' }a# => [:foo, 2]

If no such elements are found, returns the block's return value:

a = [:foo,'bar',2]a.delete(:nosuch) {|obj|"#{obj} not found" }# => "nosuch not found"

                VALUErb_ary_delete(VALUE ary, VALUE item){    VALUE v = item;    long i1, i2;    for (i1 = i2 = 0; i1 < RARRAY_LEN(ary); i1++) {        VALUE e = RARRAY_AREF(ary, i1);        if (rb_equal(e, item)) {            v = e;            continue;        }        if (i1 != i2) {            rb_ary_store(ary, i2, e);        }        i2++;    }    if (RARRAY_LEN(ary) == i2) {        if (rb_block_given_p()) {            return rb_yield(item);        }        return Qnil;    }    ary_resize_smaller(ary, i2);    ary_verify(ary);    return v;}

Deletes an element fromself, per the given Integerindex.

Whenindex is non-negative, deletes the element at offsetindex:

a = [:foo,'bar',2]a.delete_at(1)# => "bar"a# => [:foo, 2]

If index is too large, returnsnil.

Whenindex is negative, counts backward from the end of thearray:

a = [:foo,'bar',2]a.delete_at(-2)# => "bar"a# => [:foo, 2]

Ifindex is too small (far from zero), returns nil.

                static VALUErb_ary_delete_at_m(VALUE ary, VALUE pos){    return rb_ary_delete_at(ary, NUM2LONG(pos));}

Removes each element inself for which the block returns atruthy value; returnsself:

a = [:foo,'bar',2,'bat']a.delete_if {|element|element.to_s.start_with?('b') }# => [:foo, 2]

Returns a new Enumerator if no block given:

a = [:foo,'bar',2]a.delete_if# => #<Enumerator: [:foo, "bar", 2]:delete_if>

                static VALUErb_ary_delete_if(VALUE ary){    ary_verify(ary);    RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length);    ary_reject_bang(ary);    return ary;}

Returns a new Array containing only those elements fromselfthat are not found in any of the Arraysother_arrays; itemsare compared usingeql?; order fromself ispreserved:

[0,1,1,2,1,1,3,1,1].difference([1])# => [0, 2, 3][0,1,2,3].difference([3,0], [1,3])# => [2][0,1,2].difference([4])# => [0, 1, 2]

Returns a copy ofself if no arguments given.

Related: Array#-.

                static VALUErb_ary_difference_multi(int argc, VALUE *argv, VALUE ary){    VALUE ary_diff;    long i, length;    volatile VALUE t0;    bool *is_hash = ALLOCV_N(bool, t0, argc);    ary_diff = rb_ary_new();    length = RARRAY_LEN(ary);    for (i = 0; i < argc; i++) {        argv[i] = to_ary(argv[i]);        is_hash[i] = (length > SMALL_ARRAY_LEN && RARRAY_LEN(argv[i]) > SMALL_ARRAY_LEN);        if (is_hash[i]) argv[i] = ary_make_hash(argv[i]);    }    for (i = 0; i < RARRAY_LEN(ary); i++) {        int j;        VALUE elt = rb_ary_elt(ary, i);        for (j = 0; j < argc; j++) {            if (is_hash[j]) {                if (rb_hash_stlike_lookup(argv[j], RARRAY_AREF(ary, i), NULL))                    break;            }            else {                if (rb_ary_includes_by_eql(argv[j], elt)) break;            }        }        if (j == argc) rb_ary_push(ary_diff, elt);    }    ALLOCV_END(t0);    return ary_diff;}

Finds and returns the object in nested objects that is specified byindex andidentifiers. The nested objects may beinstances of various classes. SeeDigMethods.

Examples:

a = [:foo, [:bar, :baz, [:bat, :bam]]]a.dig(1)# => [:bar, :baz, [:bat, :bam]]a.dig(1,2)# => [:bat, :bam]a.dig(1,2,0)# => :bata.dig(1,2,3)# => nil

                static VALUErb_ary_dig(int argc, VALUE *argv, VALUE self){    rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);    self = rb_ary_at(self, *argv);    if (!--argc) return self;    ++argv;    return rb_obj_dig(argc, argv, self, Qnil);}

Returns a new Array containing all but the firstn element ofself, wheren is a non-negative Integer; does notmodifyself.

Examples:

a = [0,1,2,3,4,5]a.drop(0)# => [0, 1, 2, 3, 4, 5]a.drop(1)# => [1, 2, 3, 4, 5]a.drop(2)# => [2, 3, 4, 5]

                static VALUErb_ary_drop(VALUE ary, VALUE n){    VALUE result;    long pos = NUM2LONG(n);    if (pos < 0) {        rb_raise(rb_eArgError, "attempt to drop negative size");    }    result = rb_ary_subseq(ary, pos, RARRAY_LEN(ary));    if (result == Qnil) result = rb_ary_new();    return result;}

Returns a new Array containing zero or more trailing elements ofself; does not modifyself.

With a block given, calls the block with each successive element ofself; stops if the block returnsfalse ornil; returns a newArrayomitting those elements for which the block returned a truthyvalue:

a = [0,1,2,3,4,5]a.drop_while {|element|element<3 }# => [3, 4, 5]

With no block given, returns a new Enumerator:

[0,1].drop_while# => # => #<Enumerator: [0, 1]:drop_while>

                static VALUErb_ary_drop_while(VALUE ary){    long i;    RETURN_ENUMERATOR(ary, 0, 0);    for (i = 0; i < RARRAY_LEN(ary); i++) {        if (!RTEST(rb_yield(RARRAY_AREF(ary, i)))) break;    }    return rb_ary_drop(ary, LONG2FIX(i));}

Iterates over array elements.

When a block given, passes each successive array element to the block;returnsself:

a = [:foo,'bar',2]a.each {|element|puts"#{element.class} #{element}" }

Output:

SymbolfooStringbarInteger2

Allows the array to be modified during iteration:

a = [:foo,'bar',2]a.each {|element|putselement;a.clearifelement.to_s.start_with?('b') }

Output:

foobar

When no block given, returns a new Enumerator:

a = [:foo,'bar',2]e =a.eache# => #<Enumerator: [:foo, "bar", 2]:each>a1 =e.each {|element|puts"#{element.class} #{element}" }

Output:

SymbolfooStringbarInteger2

Related:each_index,reverse_each.

                VALUErb_ary_each(VALUE ary){    long i;    ary_verify(ary);    RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length);    for (i=0; i<RARRAY_LEN(ary); i++) {        rb_yield(RARRAY_AREF(ary, i));    }    return ary;}

Iterates over array indexes.

When a block given, passes each successive array index to the block;returnsself:

a = [:foo,'bar',2]a.each_index {|index|puts"#{index} #{a[index]}" }

Output:

0 foo1 bar2 2

Allows the array to be modified during iteration:

a = [:foo,'bar',2]a.each_index {|index|putsindex;a.clearifindex>0 }

Output:

01

When no block given, returns a new Enumerator:

a = [:foo,'bar',2]e =a.each_indexe# => #<Enumerator: [:foo, "bar", 2]:each_index>a1 =e.each {|index|puts"#{index} #{a[index]}"}

Output:

0 foo1 bar2 2

Related:each,reverse_each.

                static VALUErb_ary_each_index(VALUE ary){    long i;    RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length);    for (i=0; i<RARRAY_LEN(ary); i++) {        rb_yield(LONG2NUM(i));    }    return ary;}

Returnstrue if the count of elements inself iszero,false otherwise.

                static VALUErb_ary_empty_p(VALUE ary){    if (RARRAY_LEN(ary) == 0)        return Qtrue;    return Qfalse;}

Returnstrue ifself andother_arrayare the same size, and if, for each indexi inself,self[i].eql? other_array[i]:

a0 = [:foo,'bar',2]a1 = [:foo,'bar',2]a1.eql?(a0)# => true

Otherwise, returnsfalse.

This method is different from methodArray#==, which compares using methodObject#==.

                static VALUErb_ary_eql(VALUE ary1, VALUE ary2){    if (ary1 == ary2) return Qtrue;    if (!RB_TYPE_P(ary2, T_ARRAY)) return Qfalse;    if (RARRAY_LEN(ary1) != RARRAY_LEN(ary2)) return Qfalse;    if (RARRAY_CONST_PTR_TRANSIENT(ary1) == RARRAY_CONST_PTR_TRANSIENT(ary2)) return Qtrue;    return rb_exec_recursive_paired(recursive_eql, ary1, ary2, ary2);}

Returns the element at offsetindex.

With the single Integer argumentindex, returns the element atoffsetindex:

a = [:foo,'bar',2]a.fetch(1)# => "bar"

Ifindex is negative, counts from the end of the array:

a = [:foo,'bar',2]a.fetch(-1)# => 2a.fetch(-2)# => "bar"

With argumentsindex anddefault_value, returnsthe element at offsetindex if index is in range, otherwisereturnsdefault_value:

a = [:foo,'bar',2]a.fetch(1,nil)# => "bar"

With argumentindex and a block, returns the element at offsetindex if index is in range (and the block is not called);otherwise calls the block with index and returns its return value:

a = [:foo,'bar',2]a.fetch(1) {|index|raise'Cannot happen' }# => "bar"a.fetch(50) {|index|"Value for #{index}" }# => "Value for 50"

                static VALUErb_ary_fetch(int argc, VALUE *argv, VALUE ary){    VALUE pos, ifnone;    long block_given;    long idx;    rb_scan_args(argc, argv, "11", &pos, &ifnone);    block_given = rb_block_given_p();    if (block_given && argc == 2) {        rb_warn("block supersedes default value argument");    }    idx = NUM2LONG(pos);    if (idx < 0) {        idx +=  RARRAY_LEN(ary);    }    if (idx < 0 || RARRAY_LEN(ary) <= idx) {        if (block_given) return rb_yield(pos);        if (argc == 1) {            rb_raise(rb_eIndexError, "index %ld outside of array bounds: %ld...%ld",                        idx - (idx < 0 ? RARRAY_LEN(ary) : 0), -RARRAY_LEN(ary), RARRAY_LEN(ary));        }        return ifnone;    }    return RARRAY_AREF(ary, idx);}

Replaces specified elements inself with specified objects;returnsself.

With argumentobj and no block given, replaces all elementswith that one object:

a = ['a','b','c','d']a# => ["a", "b", "c", "d"]a.fill(:X)# => [:X, :X, :X, :X]

With argumentsobj and Integerstart, and noblock given, replaces elements based on the given start.

Ifstart is in range (0 <= start <array.size), replaces all elements from offsetstartthrough the end:

a = ['a','b','c','d']a.fill(:X,2)# => ["a", "b", :X, :X]

Ifstart is too large (start >= array.size),does nothing:

a = ['a','b','c','d']a.fill(:X,4)# => ["a", "b", "c", "d"]a = ['a','b','c','d']a.fill(:X,5)# => ["a", "b", "c", "d"]

Ifstart is negative, counts from the end (starting index isstart + array.size):

a = ['a','b','c','d']a.fill(:X,-2)# => ["a", "b", :X, :X]

Ifstart is too small (less than and far from zero), replacesall elements:

a = ['a','b','c','d']a.fill(:X,-6)# => [:X, :X, :X, :X]a = ['a','b','c','d']a.fill(:X,-50)# => [:X, :X, :X, :X]

With argumentsobj, Integerstart, and Integerlength, and no block given, replaces elements based on thegivenstart andlength.

Ifstart is in range, replaceslength elementsbeginning at offsetstart:

a = ['a','b','c','d']a.fill(:X,1,1)# => ["a", :X, "c", "d"]

Ifstart is negative, counts from the end:

a = ['a','b','c','d']a.fill(:X,-2,1)# => ["a", "b", :X, "d"]

Ifstart is large (start >= array.size),extendsself withnil:

a = ['a','b','c','d']a.fill(:X,5,0)# => ["a", "b", "c", "d", nil]a = ['a','b','c','d']a.fill(:X,5,2)# => ["a", "b", "c", "d", nil, :X, :X]

Iflength is zero or negative, replaces no elements:

a = ['a','b','c','d']a.fill(:X,1,0)# => ["a", "b", "c", "d"]a.fill(:X,1,-1)# => ["a", "b", "c", "d"]

With argumentsobj and Rangerange, and no blockgiven, replaces elements based on the given range.

If the range is positive and ascending (0 < range.begin <=range.end), replaces elements fromrange.begin torange.end:

a = ['a','b','c','d']a.fill(:X, (1..1))# => ["a", :X, "c", "d"]

Ifrange.first is negative, replaces no elements:

a = ['a','b','c','d']a.fill(:X, (-1..1))# => ["a", "b", "c", "d"]

Ifrange.last is negative, counts from the end:

a = ['a','b','c','d']a.fill(:X, (0..-2))# => [:X, :X, :X, "d"]a = ['a','b','c','d']a.fill(:X, (1..-2))# => ["a", :X, :X, "d"]

Ifrange.last andrange.last are both negative,both count from the end of the array:

a = ['a','b','c','d']a.fill(:X, (-1..-1))# => ["a", "b", "c", :X]a = ['a','b','c','d']a.fill(:X, (-2..-2))# => ["a", "b", :X, "d"]

With no arguments and a block given, calls the block with each index;replaces the corresponding element with the block's return value:

a = ['a','b','c','d']a.fill {|index|"new_#{index}" }# => ["new_0", "new_1", "new_2", "new_3"]

With argumentstart and a block given, calls the block witheach index from offsetstart to the end; replaces thecorresponding element with the block's return value:

If start is in range (0 <= start < array.size), replacesfrom offsetstart to the end:

a = ['a','b','c','d']a.fill(1) {|index|"new_#{index}" }# => ["a", "new_1", "new_2", "new_3"]

Ifstart is too large(start >= array.size),does nothing:

a = ['a','b','c','d']a.fill(4) {|index|fail'Cannot happen' }# => ["a", "b", "c", "d"]a = ['a','b','c','d']a.fill(4) {|index|fail'Cannot happen' }# => ["a", "b", "c", "d"]

Ifstart is negative, counts from the end:

a = ['a','b','c','d']a.fill(-2) {|index|"new_#{index}" }# => ["a", "b", "new_2", "new_3"]

If start is too small (start <= -array.size, replaces allelements:

a = ['a','b','c','d']a.fill(-6) {|index|"new_#{index}" }# => ["new_0", "new_1", "new_2", "new_3"]a = ['a','b','c','d']a.fill(-50) {|index|"new_#{index}" }# => ["new_0", "new_1", "new_2", "new_3"]

With argumentsstart andlength, and a blockgiven, calls the block for each index specified by start length; replacesthe corresponding element with the block's return value.

Ifstart is in range, replaceslength elementsbeginning at offsetstart:

a = ['a','b','c','d']a.fill(1,1) {|index|"new_#{index}" }# => ["a", "new_1", "c", "d"]

If start is negative, counts from the end:

a = ['a','b','c','d']a.fill(-2,1) {|index|"new_#{index}" }# => ["a", "b", "new_2", "d"]

Ifstart is large (start >= array.size),extendsself withnil:

a = ['a','b','c','d']a.fill(5,0) {|index|"new_#{index}" }# => ["a", "b", "c", "d", nil]a = ['a','b','c','d']a.fill(5,2) {|index|"new_#{index}" }# => ["a", "b", "c", "d", nil, "new_5", "new_6"]

Iflength is zero or less, replaces no elements:

a = ['a','b','c','d']a.fill(1,0) {|index|"new_#{index}" }# => ["a", "b", "c", "d"]a.fill(1,-1) {|index|"new_#{index}" }# => ["a", "b", "c", "d"]

With argumentsobj andrange, and a block given,calls the block with each index in the given range; replaces thecorresponding element with the block's return value.

If the range is positive and ascending (range 0 < range.begin<= range.end, replaces elements fromrange.begin torange.end:

a = ['a','b','c','d']a.fill(1..1) {|index|"new_#{index}" }# => ["a", "new_1", "c", "d"]

Ifrange.first is negative, does nothing:

a = ['a','b','c','d']a.fill(-1..1) {|index|fail'Cannot happen' }# => ["a", "b", "c", "d"]

Ifrange.last is negative, counts from the end:

a = ['a','b','c','d']a.fill(0..-2) {|index|"new_#{index}" }# => ["new_0", "new_1", "new_2", "d"]a = ['a','b','c','d']a.fill(1..-2) {|index|"new_#{index}" }# => ["a", "new_1", "new_2", "d"]

Ifrange.first andrange.last are both negative,both count from the end:

a = ['a','b','c','d']a.fill(-1..-1) {|index|"new_#{index}" }# => ["a", "b", "c", "new_3"]a = ['a','b','c','d']a.fill(-2..-2) {|index|"new_#{index}" }# => ["a", "b", "new_2", "d"]

                static VALUErb_ary_fill(int argc, VALUE *argv, VALUE ary){    VALUE item = Qundef, arg1, arg2;    long beg = 0, end = 0, len = 0;    if (rb_block_given_p()) {        rb_scan_args(argc, argv, "02", &arg1, &arg2);        argc += 1;             /* hackish */    }    else {        rb_scan_args(argc, argv, "12", &item, &arg1, &arg2);    }    switch (argc) {      case 1:        beg = 0;        len = RARRAY_LEN(ary);        break;      case 2:        if (rb_range_beg_len(arg1, &beg, &len, RARRAY_LEN(ary), 1)) {            break;        }        /* fall through */      case 3:        beg = NIL_P(arg1) ? 0 : NUM2LONG(arg1);        if (beg < 0) {            beg = RARRAY_LEN(ary) + beg;            if (beg < 0) beg = 0;        }        len = NIL_P(arg2) ? RARRAY_LEN(ary) - beg : NUM2LONG(arg2);        break;    }    rb_ary_modify(ary);    if (len < 0) {        return ary;    }    if (beg >= ARY_MAX_SIZE || len > ARY_MAX_SIZE - beg) {        rb_raise(rb_eArgError, "argument too big");    }    end = beg + len;    if (RARRAY_LEN(ary) < end) {        if (end >= ARY_CAPA(ary)) {            ary_resize_capa(ary, end);        }        ary_mem_clear(ary, RARRAY_LEN(ary), end - RARRAY_LEN(ary));        ARY_SET_LEN(ary, end);    }    if (item == Qundef) {        VALUE v;        long i;        for (i=beg; i<end; i++) {            v = rb_yield(LONG2NUM(i));            if (i>=RARRAY_LEN(ary)) break;            ARY_SET(ary, i, v);        }    }    else {        ary_memfill(ary, beg, len, item);    }    return ary;}

Calls the block, if given, with each element ofself; returnsa new Array containing those elements ofself for which theblock returns a truthy value:

a = [:foo,'bar',2, :bam]a1 =a.select {|element|element.to_s.start_with?('b') }a1# => ["bar", :bam]

Returns a new Enumerator if no block given:

a = [:foo,'bar',2, :bam]a.select# => #<Enumerator: [:foo, "bar", 2, :bam]:select>

#filter is an alias for#select.

                static VALUErb_ary_select(VALUE ary){    VALUE result;    long i;    RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length);    result = rb_ary_new2(RARRAY_LEN(ary));    for (i = 0; i < RARRAY_LEN(ary); i++) {        if (RTEST(rb_yield(RARRAY_AREF(ary, i)))) {            rb_ary_push(result, rb_ary_elt(ary, i));        }    }    return result;}

Calls the block, if given with each element ofself; removesfromself those elements for which the block returnsfalse ornil.

Returnsself if any elements were removed:

a = [:foo,'bar',2, :bam]a.select! {|element|element.to_s.start_with?('b') }# => ["bar", :bam]

Returnsnil if no elements were removed.

Returns a new Enumerator if no block given:

a = [:foo,'bar',2, :bam]a.select!# => #<Enumerator: [:foo, "bar", 2, :bam]:select!>

#filter! is an alias for#select!.

                static VALUErb_ary_select_bang(VALUE ary){    struct select_bang_arg args;    RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length);    rb_ary_modify(ary);    args.ary = ary;    args.len[0] = args.len[1] = 0;    return rb_ensure(select_bang_i, (VALUE)&args, select_bang_ensure, (VALUE)&args);}

Returns the index of a specified element.

When argumentobject is given but no block, returns the indexof the first elementelement for whichobject ==element:

a = [:foo,'bar',2,'bar']a.index('bar')# => 1

Returnsnil if no such element found.

When both argumentobject and a block are given, calls theblock with each successive element; returns the index of the first elementfor which the block returns a truthy value:

a = [:foo,'bar',2,'bar']a.index {|element|element=='bar' }# => 1

Returnsnil if the block never returns a truthy value.

When neither an argument nor a block is given, returns a new Enumerator:

a = [:foo,'bar',2]e =a.indexe# => #<Enumerator: [:foo, "bar", 2]:index>e.each {|element|element=='bar' }# => 1

#find_index is an alias for#index.

Related:rindex.

                static VALUErb_ary_index(int argc, VALUE *argv, VALUE ary){    VALUE val;    long i;    if (argc == 0) {        RETURN_ENUMERATOR(ary, 0, 0);        for (i=0; i<RARRAY_LEN(ary); i++) {            if (RTEST(rb_yield(RARRAY_AREF(ary, i)))) {                return LONG2NUM(i);            }        }        return Qnil;    }    rb_check_arity(argc, 0, 1);    val = argv[0];    if (rb_block_given_p())        rb_warn("given block not used");    for (i=0; i<RARRAY_LEN(ary); i++) {        VALUE e = RARRAY_AREF(ary, i);        if (rb_equal(e, val)) {            return LONG2NUM(i);        }    }    return Qnil;}

Returns elements fromself; does not modifyself.

When no argument is given, returns the first element:

a = [:foo,'bar',2]a.first# => :fooa# => [:foo, "bar", 2]

Ifself is empty, returnsnil.

When non-negative Integer argumentn is given, returns thefirstn elements in a new Array:

a = [:foo,'bar',2]a.first(2)# => [:foo, "bar"]

Ifn >= array.size, returns all elements:

a = [:foo,'bar',2]a.first(50)# => [:foo, "bar", 2]

Ifn == 0 returns an new empty Array:

a = [:foo,'bar',2]a.first(0)# []

Related:last.

                static VALUErb_ary_first(int argc, VALUE *argv, VALUE ary){    if (argc == 0) {        if (RARRAY_LEN(ary) == 0) return Qnil;        return RARRAY_AREF(ary, 0);    }    else {        return ary_take_first_or_last(argc, argv, ary, ARY_TAKE_FIRST);    }}

Returns a new Array that is a recursive flattening ofself:

• Each non-Array element is unchanged.

• Each Array is replaced by its individual elements.

With non-negative Integer argumentlevel, flattens recursivelythroughlevel levels:

a = [0, [1, [2,3],4 ],5 ]a.flatten(0)# => [0, [1, [2, 3], 4], 5]a = [0, [1, [2,3],4 ],5 ]a.flatten(1)# => [0, 1, [2, 3], 4, 5]a = [0, [1, [2,3],4 ],5 ]a.flatten(2)# => [0, 1, 2, 3, 4, 5]a = [0, [1, [2,3],4 ],5 ]a.flatten(3)# => [0, 1, 2, 3, 4, 5]

With no argument, anil argument, or with negative argumentlevel, flattens all levels:

a = [0, [1, [2,3],4 ],5 ]a.flatten# => [0, 1, 2, 3, 4, 5][0,1,2].flatten# => [0, 1, 2]a = [0, [1, [2,3],4 ],5 ]a.flatten(-1)# => [0, 1, 2, 3, 4, 5]a = [0, [1, [2,3],4 ],5 ]a.flatten(-2)# => [0, 1, 2, 3, 4, 5][0,1,2].flatten(-1)# => [0, 1, 2]

                static VALUErb_ary_flatten(int argc, VALUE *argv, VALUE ary){    int level = -1;    VALUE result;    if (rb_check_arity(argc, 0, 1) && !NIL_P(argv[0])) {        level = NUM2INT(argv[0]);        if (level == 0) return ary_make_shared_copy(ary);    }    result = flatten(ary, level);    if (result == ary) {        result = ary_make_shared_copy(ary);    }    return result;}

Replaces each nested Array inself with the elements from thatArray; returnsself if any changes,nilotherwise.

With non-negative Integer argumentlevel, flattens recursivelythroughlevel levels:

a = [0, [1, [2,3],4 ],5 ]a.flatten!(1)# => [0, 1, [2, 3], 4, 5]a = [0, [1, [2,3],4 ],5 ]a.flatten!(2)# => [0, 1, 2, 3, 4, 5]a = [0, [1, [2,3],4 ],5 ]a.flatten!(3)# => [0, 1, 2, 3, 4, 5][0,1,2].flatten!(1)# => nil

With no argument, anil argument, or with negative argumentlevel, flattens all levels:

a = [0, [1, [2,3],4 ],5 ]a.flatten!# => [0, 1, 2, 3, 4, 5][0,1,2].flatten!# => nila = [0, [1, [2,3],4 ],5 ]a.flatten!(-1)# => [0, 1, 2, 3, 4, 5]a = [0, [1, [2,3],4 ],5 ]a.flatten!(-2)# => [0, 1, 2, 3, 4, 5][0,1,2].flatten!(-1)# => nil

                static VALUErb_ary_flatten_bang(int argc, VALUE *argv, VALUE ary){    int mod = 0, level = -1;    VALUE result, lv;    lv = (rb_check_arity(argc, 0, 1) ? argv[0] : Qnil);    rb_ary_modify_check(ary);    if (!NIL_P(lv)) level = NUM2INT(lv);    if (level == 0) return Qnil;    result = flatten(ary, level);    if (result == ary) {        return Qnil;    }    if (!(mod = ARY_EMBED_P(result))) rb_obj_freeze(result);    rb_ary_replace(ary, result);    if (mod) ARY_SET_EMBED_LEN(result, 0);    return ary;}

Returns the integer hash value forself.

Two arrays with the same content will have the same hash code (and willcompare using eql?):

[0,1,2].hash== [0,1,2].hash# => true[0,1,2].hash== [0,1,3].hash# => false

                static VALUErb_ary_hash(VALUE ary){    long i;    st_index_t h;    VALUE n;    h = rb_hash_start(RARRAY_LEN(ary));    h = rb_hash_uint(h, (st_index_t)rb_ary_hash);    for (i=0; i<RARRAY_LEN(ary); i++) {        n = rb_hash(RARRAY_AREF(ary, i));        h = rb_hash_uint(h, NUM2LONG(n));    }    h = rb_hash_end(h);    return ST2FIX(h);}

Returnstrue if for some indexi inself,obj == self[i]; otherwisefalse:

[0,1,2].include?(2)# => true[0,1,2].include?(3)# => false

                VALUErb_ary_includes(VALUE ary, VALUE item){    long i;    VALUE e;    for (i=0; i<RARRAY_LEN(ary); i++) {        e = RARRAY_AREF(ary, i);        if (rb_equal(e, item)) {            return Qtrue;        }    }    return Qfalse;}

Returns the index of a specified element.

When argumentobject is given but no block, returns the indexof the first elementelement for whichobject ==element:

a = [:foo,'bar',2,'bar']a.index('bar')# => 1

Returnsnil if no such element found.

When both argumentobject and a block are given, calls theblock with each successive element; returns the index of the first elementfor which the block returns a truthy value:

a = [:foo,'bar',2,'bar']a.index {|element|element=='bar' }# => 1

Returnsnil if the block never returns a truthy value.

When neither an argument nor a block is given, returns a new Enumerator:

a = [:foo,'bar',2]e =a.indexe# => #<Enumerator: [:foo, "bar", 2]:index>e.each {|element|element=='bar' }# => 1

#find_index is an alias for#index.

Related:rindex.

                static VALUErb_ary_index(int argc, VALUE *argv, VALUE ary){    VALUE val;    long i;    if (argc == 0) {        RETURN_ENUMERATOR(ary, 0, 0);        for (i=0; i<RARRAY_LEN(ary); i++) {            if (RTEST(rb_yield(RARRAY_AREF(ary, i)))) {                return LONG2NUM(i);            }        }        return Qnil;    }    rb_check_arity(argc, 0, 1);    val = argv[0];    if (rb_block_given_p())        rb_warn("given block not used");    for (i=0; i<RARRAY_LEN(ary); i++) {        VALUE e = RARRAY_AREF(ary, i);        if (rb_equal(e, val)) {            return LONG2NUM(i);        }    }    return Qnil;}

Replaces the content ofself with the content ofother_array; returnsself:

a = [:foo,'bar',2]a.replace(['foo', :bar,3])# => ["foo", :bar, 3]

                VALUErb_ary_replace(VALUE copy, VALUE orig){    rb_ary_modify_check(copy);    orig = to_ary(orig);    if (copy == orig) return copy;    if (RARRAY_LEN(orig) <= RARRAY_EMBED_LEN_MAX) {        VALUE shared_root = 0;        if (ARY_OWNS_HEAP_P(copy)) {            ary_heap_free(copy);        }        else if (ARY_SHARED_P(copy)) {            shared_root = ARY_SHARED_ROOT(copy);            FL_UNSET_SHARED(copy);        }        FL_SET_EMBED(copy);        ary_memcpy(copy, 0, RARRAY_LEN(orig), RARRAY_CONST_PTR_TRANSIENT(orig));        if (shared_root) {            rb_ary_decrement_share(shared_root);        }        ARY_SET_LEN(copy, RARRAY_LEN(orig));    }    else {        VALUE shared_root = ary_make_shared(orig);        if (ARY_OWNS_HEAP_P(copy)) {            ary_heap_free(copy);        }        else {            rb_ary_unshare_safe(copy);        }        FL_UNSET_EMBED(copy);        ARY_SET_PTR(copy, ARY_HEAP_PTR(orig));        ARY_SET_LEN(copy, ARY_HEAP_LEN(orig));        rb_ary_set_shared(copy, shared_root);    }    ary_verify(copy);    return copy;}

Inserts givenobjects before or after the element at Integerindexoffset; returnsself.

Whenindex is non-negative, inserts all givenobjects before the element at offsetindex:

a = [:foo,'bar',2]a.insert(1, :bat, :bam)# => [:foo, :bat, :bam, "bar", 2]

Extends the array ifindex is beyond the array (index>= self.size):

a = [:foo,'bar',2]a.insert(5, :bat, :bam)a# => [:foo, "bar", 2, nil, nil, :bat, :bam]

Does nothing if no objects given:

a = [:foo,'bar',2]a.insert(1)a.insert(50)a.insert(-50)a# => [:foo, "bar", 2]

Whenindex is negative, inserts all givenobjectsafter the element at offsetindex+self.size:

a = [:foo,'bar',2]a.insert(-2, :bat, :bam)a# => [:foo, "bar", :bat, :bam, 2]

                static VALUErb_ary_insert(int argc, VALUE *argv, VALUE ary){    long pos;    rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);    rb_ary_modify_check(ary);    pos = NUM2LONG(argv[0]);    if (argc == 1) return ary;    if (pos == -1) {        pos = RARRAY_LEN(ary);    }    else if (pos < 0) {        long minpos = -RARRAY_LEN(ary) - 1;        if (pos < minpos) {            rb_raise(rb_eIndexError, "index %ld too small for array; minimum: %ld",                     pos, minpos);        }        pos++;    }    rb_ary_splice(ary, pos, 0, argv + 1, argc - 1);    return ary;}

Returns the new String formed by calling method#inspect oneach array element:

a = [:foo,'bar',2]a.inspect# => "[:foo, \"bar\", 2]"

#to_s is an alias for#inspect.

                static VALUErb_ary_inspect(VALUE ary){    if (RARRAY_LEN(ary) == 0) return rb_usascii_str_new2("[]");    return rb_exec_recursive(inspect_ary, ary, 0);}

Returns a new Array containing each element found both inselfand in all of the given Arraysother_arrays; duplicates areomitted; items are compared usingeql?:

[0,1,2,3].intersection([0,1,2], [0,1,3])# => [0, 1][0,0,1,1,2,3].intersection([0,1,2], [0,1,3])# => [0, 1]

Preserves order fromself:

[0,1,2].intersection([2,1,0])# => [0, 1, 2]

Returns a copy ofself if no arguments given.

Related: Array#&.

                static VALUErb_ary_intersection_multi(int argc, VALUE *argv, VALUE ary){    VALUE result = rb_ary_dup(ary);    int i;    for (i = 0; i < argc; i++) {        result = rb_ary_and(result, argv[i]);    }    return result;}

Returns the new String formed by joining the array elements afterconversion. For each elementelement

• Useselement.to_s ifelement is not akind_of?(Array).

• Uses recursiveelement.join(separator) ifelementis akind_of?(Array).

With no argument, joins using the output field separator,$,:

a = [:foo,'bar',2]$,# => nila.join# => "foobar2"

With string argumentseparator, joins using that separator:

a = [:foo,'bar',2]a.join("\n")# => "foo\nbar\n2"

Joins recursively for nested Arrays:

a = [:foo, [:bar, [:baz, :bat]]]a.join# => "foobarbazbat"

                static VALUErb_ary_join_m(int argc, VALUE *argv, VALUE ary){    VALUE sep;    if (rb_check_arity(argc, 0, 1) == 0 || NIL_P(sep = argv[0])) {        sep = rb_output_fs;        if (!NIL_P(sep)) {            rb_category_warn(RB_WARN_CATEGORY_DEPRECATED, "$, is set to non-nil value");        }    }    return rb_ary_join(ary, sep);}

Retains those elements for which the block returns a truthy value; deletesall other elements; returnsself:

a = [:foo,'bar',2, :bam]a.keep_if {|element|element.to_s.start_with?('b') }# => ["bar", :bam]

Returns a new Enumerator if no block given:

a = [:foo,'bar',2, :bam]a.keep_if# => #<Enumerator: [:foo, "bar", 2, :bam]:keep_if>

                static VALUErb_ary_keep_if(VALUE ary){    RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length);    rb_ary_select_bang(ary);    return ary;}

Returns elements fromself;self is not modified.

When no argument is given, returns the last element:

a = [:foo,'bar',2]a.last# => 2a# => [:foo, "bar", 2]

Ifself is empty, returnsnil.

When non-negative Innteger argumentn is given, returns thelastn elements in a new Array:

a = [:foo,'bar',2]a.last(2)# => ["bar", 2]

Ifn >= array.size, returns all elements:

a = [:foo,'bar',2]a.last(50)# => [:foo, "bar", 2]

Ifn == 0, returns an new empty Array:

a = [:foo,'bar',2]a.last(0)# []

Related:first.

                VALUErb_ary_last(int argc, const VALUE *argv, VALUE ary){    if (argc == 0) {        long len = RARRAY_LEN(ary);        if (len == 0) return Qnil;        return RARRAY_AREF(ary, len-1);    }    else {        return ary_take_first_or_last(argc, argv, ary, ARY_TAKE_LAST);    }}

Returns the count of elements inself.

                static VALUErb_ary_length(VALUE ary){    long len = RARRAY_LEN(ary);    return LONG2NUM(len);}

Calls the block, if given, with each element ofself; returnsa new Array whose elements are the return values from the block:

a = [:foo,'bar',2]a1 =a.map {|element|element.class }a1# => [Symbol, String, Integer]

Returns a new Enumerator if no block given:

a = [:foo,'bar',2]a1 =a.mapa1# => #<Enumerator: [:foo, "bar", 2]:map>

#collect is an alias for#map.

                static VALUErb_ary_collect(VALUE ary){    long i;    VALUE collect;    RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length);    collect = rb_ary_new2(RARRAY_LEN(ary));    for (i = 0; i < RARRAY_LEN(ary); i++) {        rb_ary_push(collect, rb_yield(RARRAY_AREF(ary, i)));    }    return collect;}

Calls the block, if given, with each element; replaces the element with theblock's return value:

a = [:foo,'bar',2]a.map! {|element|element.class }# => [Symbol, String, Integer]

Returns a new Enumerator if no block given:

a = [:foo,'bar',2]a1 =a.map!a1# => #<Enumerator: [:foo, "bar", 2]:map!>

#collect! is an alias for#map!.

                static VALUErb_ary_collect_bang(VALUE ary){    long i;    RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length);    rb_ary_modify(ary);    for (i = 0; i < RARRAY_LEN(ary); i++) {        rb_ary_store(ary, i, rb_yield(RARRAY_AREF(ary, i)));    }    return ary;}

Returns one of the following:

• The maximum-valued element fromself.

• A new Array of maximum-valued elements selected fromself.

When no block is given, each element inself must respond tomethod<=> with an Integer.

With no argument and no block, returns the element inselfhaving the maximum value per method<=>:

[0,1,2].max# => 2

With an argument Integern and no block, returns a new Arraywith at mostn elements, in descending order per method<=>:

[0,1,2,3].max(3)# => [3, 2, 1][0,1,2,3].max(6)# => [3, 2, 1]

When a block is given, the block must return an Integer.

With a block and no argument, calls the blockself.size-1times to compare elements; returns the element having the maximum value perthe block:

['0','00','000'].max {|a,b|a.size<=>b.size }# => "000"

With an argumentn and a block, returns a new Array with atmostn elements, in descending order per the block:

['0','00','000'].max(2) {|a,b|a.size<=>b.size }# => ["000", "00"]

                static VALUErb_ary_max(int argc, VALUE *argv, VALUE ary){    struct cmp_opt_data cmp_opt = { 0, 0 };    VALUE result = Qundef, v;    VALUE num;    long i;    if (rb_check_arity(argc, 0, 1) && !NIL_P(num = argv[0]))       return rb_nmin_run(ary, num, 0, 1, 1);    const long n = RARRAY_LEN(ary);    if (rb_block_given_p()) {        for (i = 0; i < RARRAY_LEN(ary); i++) {           v = RARRAY_AREF(ary, i);           if (result == Qundef || rb_cmpint(rb_yield_values(2, v, result), v, result) > 0) {               result = v;           }        }    }    else if (n > 0) {        result = RARRAY_AREF(ary, 0);        if (n > 1) {            if (FIXNUM_P(result) && CMP_OPTIMIZABLE(cmp_opt, Integer)) {                return ary_max_opt_fixnum(ary, 1, result);            }            else if (STRING_P(result) && CMP_OPTIMIZABLE(cmp_opt, String)) {                return ary_max_opt_string(ary, 1, result);            }            else if (RB_FLOAT_TYPE_P(result) && CMP_OPTIMIZABLE(cmp_opt, Float)) {                return ary_max_opt_float(ary, 1, result);            }            else {                return ary_max_generic(ary, 1, result);            }        }    }    if (result == Qundef) return Qnil;    return result;}

Returns one of the following:

• The minimum-valued element fromself.

• A new Array of minimum-valued elements selected fromself.

When no block is given, each element inself must respond tomethod<=> with an Integer.

With no argument and no block, returns the element inselfhaving the minimum value per method<=>:

[0,1,2].min# => 0

With Integer argumentn and no block, returns a new Array withat mostn elements, in ascending order per method<=>:

[0,1,2,3].min(3)# => [0, 1, 2][0,1,2,3].min(6)# => [0, 1, 2, 3]

When a block is given, the block must return anInteger.

With a block and no argument, calls the blockself.size-1times to compare elements; returns the element having the minimum value perthe block:

['0','00','000'].min {|a,b|a.size<=>b.size }# => "0"

With an argumentn and a block, returns a new Array with atmostn elements, in ascending order per the block:

[0,1,2,3].min(3)# => [0, 1, 2][0,1,2,3].min(6)# => [0, 1, 2, 3]

                static VALUErb_ary_min(int argc, VALUE *argv, VALUE ary){    struct cmp_opt_data cmp_opt = { 0, 0 };    VALUE result = Qundef, v;    VALUE num;    long i;    if (rb_check_arity(argc, 0, 1) && !NIL_P(num = argv[0]))       return rb_nmin_run(ary, num, 0, 0, 1);    const long n = RARRAY_LEN(ary);    if (rb_block_given_p()) {        for (i = 0; i < RARRAY_LEN(ary); i++) {           v = RARRAY_AREF(ary, i);           if (result == Qundef || rb_cmpint(rb_yield_values(2, v, result), v, result) < 0) {               result = v;           }        }    }    else if (n > 0) {        result = RARRAY_AREF(ary, 0);        if (n > 1) {            if (FIXNUM_P(result) && CMP_OPTIMIZABLE(cmp_opt, Integer)) {                return ary_min_opt_fixnum(ary, 1, result);            }            else if (STRING_P(result) && CMP_OPTIMIZABLE(cmp_opt, String)) {                return ary_min_opt_string(ary, 1, result);            }            else if (RB_FLOAT_TYPE_P(result) && CMP_OPTIMIZABLE(cmp_opt, Float)) {                return ary_min_opt_float(ary, 1, result);            }            else {                return ary_min_generic(ary, 1, result);            }        }    }    if (result == Qundef) return Qnil;    return result;}

Returns a new 2-element Array containing the minimum and maximum valuesfromself, either per method<=> or per agiven block:.

When no block is given, each element inself must respond tomethod<=> with an Integer; returns a new 2-elementArray containing the minimum and maximum values fromself, permethod<=>:

[0,1,2].minmax# => [0, 2]

When a block is given, the block must return an Integer; the block iscalledself.size-1 times to compare elements; returns a new2-element Array containing the minimum and maximum values fromself, per the block:

['0','00','000'].minmax {|a,b|a.size<=>b.size }# => ["0", "000"]

                static VALUErb_ary_minmax(VALUE ary){    if (rb_block_given_p()) {        return rb_call_super(0, NULL);    }    return rb_assoc_new(rb_ary_min(0, 0, ary), rb_ary_max(0, 0, ary));}

Returnstrue if no element ofself meet a givencriterion.

With no block given and no argument, returnstrue ifself has no truthy elements,false otherwise:

[nil,false].none?# => true[nil,0,false].none?# => false[].none?# => true

With a block given and no argument, calls the block with each element inself; returnstrue if the block returns no truthyvalue,false otherwise:

[0,1,2].none? {|element|element>3 }# => true[0,1,2].none? {|element|element>1 }# => false

If argumentobj is given, returnstrue ifobj.=== no element,false otherwise:

['food','drink'].none?(/bar/)# => true['food','drink'].none?(/foo/)# => false[].none?(/foo/)# => true[0,1,2].none?(3)# => true[0,1,2].none?(1)# => false

Related:Enumerable#none?

                static VALUErb_ary_none_p(int argc, VALUE *argv, VALUE ary){    long i, len = RARRAY_LEN(ary);    rb_check_arity(argc, 0, 1);    if (!len) return Qtrue;    if (argc) {        if (rb_block_given_p()) {            rb_warn("given block not used");        }        for (i = 0; i < RARRAY_LEN(ary); ++i) {            if (RTEST(rb_funcall(argv[0], idEqq, 1, RARRAY_AREF(ary, i)))) return Qfalse;        }    }    else if (!rb_block_given_p()) {        for (i = 0; i < len; ++i) {            if (RTEST(RARRAY_AREF(ary, i))) return Qfalse;        }    }    else {        for (i = 0; i < RARRAY_LEN(ary); ++i) {            if (RTEST(rb_yield(RARRAY_AREF(ary, i)))) return Qfalse;        }    }    return Qtrue;}

Returnstrue if exactly one element ofself meetsa given criterion.

With no block given and no argument, returnstrue ifself has exactly one truthy element,falseotherwise:

[nil,0].one?# => true[0,0].one?# => false[nil,nil].one?# => false[].one?# => false

With a block given and no argument, calls the block with each element inself; returnstrue if the block a truthy valuefor exactly one element,false otherwise:

[0,1,2].one? {|element|element>0 }# => false[0,1,2].one? {|element|element>1 }# => true[0,1,2].one? {|element|element>2 }# => false

If argumentobj is given, returnstrue ifobj.=== exactly one element,false otherwise:

[0,1,2].one?(0)# => true[0,0,1].one?(0)# => false[1,1,2].one?(0)# => false['food','drink'].one?(/bar/)# => false['food','drink'].one?(/foo/)# => true[].one?(/foo/)# => false

Related:Enumerable#one?

                static VALUErb_ary_one_p(int argc, VALUE *argv, VALUE ary){    long i, len = RARRAY_LEN(ary);    VALUE result = Qfalse;    rb_check_arity(argc, 0, 1);    if (!len) return Qfalse;    if (argc) {        if (rb_block_given_p()) {            rb_warn("given block not used");        }        for (i = 0; i < RARRAY_LEN(ary); ++i) {            if (RTEST(rb_funcall(argv[0], idEqq, 1, RARRAY_AREF(ary, i)))) {                if (result) return Qfalse;                result = Qtrue;            }        }    }    else if (!rb_block_given_p()) {        for (i = 0; i < len; ++i) {            if (RTEST(RARRAY_AREF(ary, i))) {                if (result) return Qfalse;                result = Qtrue;            }        }    }    else {        for (i = 0; i < RARRAY_LEN(ary); ++i) {            if (RTEST(rb_yield(RARRAY_AREF(ary, i)))) {                if (result) return Qfalse;                result = Qtrue;            }        }    }    return result;}

Packs the contents ofarr into a binary sequence according to thedirectives inaTemplateString (see the table below) Directives“A,'' “a,'' and “Z'' may be followed by a count,which gives the width of the resulting field. The remaining directives alsomay take a count, indicating the number of array elements to convert. Ifthe count is an asterisk (“*''), all remaining arrayelements will be converted. Any of the directives“sSiIlL'' may be followed by an underscore(“_'') or exclamation mark (“!'')to use the underlying platform's native size for the specified type;otherwise, they use a platform-independent size. Spaces are ignored in thetemplate string. See alsoString#unpack.

a = ["a","b","c" ]n = [65,66,67 ]a.pack("A3A3A3")#=> "a  b  c  "a.pack("a3a3a3")#=> "a\000\000b\000\000c\000\000"n.pack("ccc")#=> "ABC"

IfaBufferString is specified and its capacity is enough,pack uses it as the buffer and returns it. When the offset isspecified by the beginning ofaTemplateString, the result isfilled after the offset. If original contents ofaBufferStringexists and it's longer than the offset, the rest ofoffsetOfBuffer are overwritten by the result. If it's shorter,the gap is filled with “\0''.

Note that “buffer:'' option does not guarantee not to allocatememory inpack. If the capacity ofaBufferString isnot enough,pack allocates memory.

Directives forpack.

Integer       | Array   |Directive     | Element | Meaning----------------------------------------------------------------------------C             | Integer | 8-bit unsigned (unsigned char)S             | Integer | 16-bit unsigned, native endian (uint16_t)L             | Integer | 32-bit unsigned, native endian (uint32_t)Q             | Integer | 64-bit unsigned, native endian (uint64_t)J             | Integer | pointer width unsigned, native endian (uintptr_t)              |         | (J is available since Ruby 2.3.)              |         |c             | Integer | 8-bit signed (signed char)s             | Integer | 16-bit signed, native endian (int16_t)l             | Integer | 32-bit signed, native endian (int32_t)q             | Integer | 64-bit signed, native endian (int64_t)j             | Integer | pointer width signed, native endian (intptr_t)              |         | (j is available since Ruby 2.3.)              |         |S_ S!         | Integer | unsigned short, native endianI I_ I!       | Integer | unsigned int, native endianL_ L!         | Integer | unsigned long, native endianQ_ Q!         | Integer | unsigned long long, native endian (ArgumentError              |         | if the platform has no long long type.)              |         | (Q_ and Q! is available since Ruby 2.1.)J!            | Integer | uintptr_t, native endian (same with J)              |         | (J! is available since Ruby 2.3.)              |         |s_ s!         | Integer | signed short, native endiani i_ i!       | Integer | signed int, native endianl_ l!         | Integer | signed long, native endianq_ q!         | Integer | signed long long, native endian (ArgumentError              |         | if the platform has no long long type.)              |         | (q_ and q! is available since Ruby 2.1.)j!            | Integer | intptr_t, native endian (same with j)              |         | (j! is available since Ruby 2.3.)              |         |S> s> S!> s!> | Integer | same as the directives without ">" exceptL> l> L!> l!> |         | big endianI!> i!>       |         | (available since Ruby 1.9.3)Q> q> Q!> q!> |         | "S>" is same as "n"J> j> J!> j!> |         | "L>" is same as "N"              |         |S< s< S!< s!< | Integer | same as the directives without "<" exceptL< l< L!< l!< |         | little endianI!< i!<       |         | (available since Ruby 1.9.3)Q< q< Q!< q!< |         | "S<" is same as "v"J< j< J!< j!< |         | "L<" is same as "V"              |         |n             | Integer | 16-bit unsigned, network (big-endian) byte orderN             | Integer | 32-bit unsigned, network (big-endian) byte orderv             | Integer | 16-bit unsigned, VAX (little-endian) byte orderV             | Integer | 32-bit unsigned, VAX (little-endian) byte order              |         |U             | Integer | UTF-8 characterw             | Integer | BER-compressed integerFloat        | Array   |Directive    | Element | Meaning---------------------------------------------------------------------------D d          | Float   | double-precision, native formatF f          | Float   | single-precision, native formatE            | Float   | double-precision, little-endian byte ordere            | Float   | single-precision, little-endian byte orderG            | Float   | double-precision, network (big-endian) byte orderg            | Float   | single-precision, network (big-endian) byte orderString       | Array   |Directive    | Element | Meaning---------------------------------------------------------------------------A            | String  | arbitrary binary string (space padded, count is width)a            | String  | arbitrary binary string (null padded, count is width)Z            | String  | same as ``a'', except that null is added with *B            | String  | bit string (MSB first)b            | String  | bit string (LSB first)H            | String  | hex string (high nibble first)h            | String  | hex string (low nibble first)u            | String  | UU-encoded stringM            | String  | quoted printable, MIME encoding (see also RFC2045)             |         | (text mode but input must use LF and output LF)m            | String  | base64 encoded string (see RFC 2045)             |         | (if count is 0, no line feed are added, see RFC 4648)             |         | (count specifies input bytes between each LF,             |         | rounded down to nearest multiple of 3)P            | String  | pointer to a structure (fixed-length string)p            | String  | pointer to a null-terminated stringMisc.        | Array   |Directive    | Element | Meaning---------------------------------------------------------------------------@            | ---     | moves to absolute positionX            | ---     | back up a bytex            | ---     | null byte

# File pack.rb, line 133defpack(fmt,buffer:nil)Primitive.pack_pack(fmt,buffer)end

When invoked with a block, yield all permutations of elements ofself; returnsself. The order of permutations isindeterminate.

When a block and an in-range positive Integer argumentn(0 < n <= self.size) are given, calls the block with alln-tuple permutations ofself.

Example:

a = [0,1,2]a.permutation(2) {|permutation|ppermutation }

Output:

[0,1][0,2][1,0][1,2][2,0][2,1]

Another example:

a = [0,1,2]a.permutation(3) {|permutation|ppermutation }

Output:

[0,1,2][0,2,1][1,0,2][1,2,0][2,0,1][2,1,0]

Whenn is zero, calls the block once with a new empty Array:

a = [0,1,2]a.permutation(0) {|permutation|ppermutation }

Output:

[]

Whenn is out of range (negative or larger thanself.size), does not call the block:

a = [0,1,2]a.permutation(-1) {|permutation|fail'Cannot happen' }a.permutation(4) {|permutation|fail'Cannot happen' }

When a block given but no argument, behaves the same asa.permutation(a.size):

a = [0,1,2]a.permutation {|permutation|ppermutation }

Output:

[0,1,2][0,2,1][1,0,2][1,2,0][2,0,1][2,1,0]

Returns a new Enumerator if no block given:

a = [0,1,2]a.permutation# => #<Enumerator: [0, 1, 2]:permutation>a.permutation(2)# => #<Enumerator: [0, 1, 2]:permutation(2)>

                static VALUErb_ary_permutation(int argc, VALUE *argv, VALUE ary){    long r, n, i;    n = RARRAY_LEN(ary);                  /* Array length */    RETURN_SIZED_ENUMERATOR(ary, argc, argv, rb_ary_permutation_size);   /* Return enumerator if no block */    r = n;    if (rb_check_arity(argc, 0, 1) && !NIL_P(argv[0]))        r = NUM2LONG(argv[0]);            /* Permutation size from argument */    if (r < 0 || n < r) {        /* no permutations: yield nothing */    }    else if (r == 0) { /* exactly one permutation: the zero-length array */        rb_yield(rb_ary_new2(0));    }    else if (r == 1) { /* this is a special, easy case */        for (i = 0; i < RARRAY_LEN(ary); i++) {            rb_yield(rb_ary_new3(1, RARRAY_AREF(ary, i)));        }    }    else {             /* this is the general case */        volatile VALUE t0;        long *p = ALLOCV_N(long, t0, r+roomof(n, sizeof(long)));        char *used = (char*)(p + r);        VALUE ary0 = ary_make_shared_copy(ary); /* private defensive copy of ary */        RBASIC_CLEAR_CLASS(ary0);        MEMZERO(used, char, n); /* initialize array */        permute0(n, r, p, used, ary0); /* compute and yield permutations */        ALLOCV_END(t0);        RBASIC_SET_CLASS_RAW(ary0, rb_cArray);    }    return ary;}

Removes and returns trailing elements.

When no argument is given andself is not empty, removes andreturns the last element:

a = [:foo,'bar',2]a.pop# => 2a# => [:foo, "bar"]

Returnsnil if the array is empty.

When a non-negative Integer argumentn is given and is inrange, removes and returns the lastn elements in a new Array:

a = [:foo,'bar',2]a.pop(2)# => ["bar", 2]

Ifn is positive and out of range, removes and returns allelements:

a = [:foo,'bar',2]a.pop(50)# => [:foo, "bar", 2]

Related:push,shift,unshift.

                static VALUErb_ary_pop_m(int argc, VALUE *argv, VALUE ary){    VALUE result;    if (argc == 0) {        return rb_ary_pop(ary);    }    rb_ary_modify_check(ary);    result = ary_take_first_or_last(argc, argv, ary, ARY_TAKE_LAST);    ARY_INCREASE_LEN(ary, -RARRAY_LEN(result));    ary_verify(ary);    return result;}

Computes and returns or yields all combinations of elements from all theArrays, including bothself andother_arrays.

• The number of combinations is the product of the sizes of all the arrays,including bothself andother_arrays.

• The order of the returned combinations is indeterminate.

When no block is given, returns the combinations as an Array of Arrays:

a = [0,1,2]a1 = [3,4]a2 = [5,6]p =a.product(a1)p.size# => 6 # a.size * a1.sizep# => [[0, 3], [0, 4], [1, 3], [1, 4], [2, 3], [2, 4]]p =a.product(a1,a2)p.size# => 12 # a.size * a1.size * a2.sizep# => [[0, 3, 5], [0, 3, 6], [0, 4, 5], [0, 4, 6], [1, 3, 5], [1, 3, 6], [1, 4, 5], [1, 4, 6], [2, 3, 5], [2, 3, 6], [2, 4, 5], [2, 4, 6]]

If any argument is an empty Array, returns an empty Array.

If no argument is given, returns an Array of 1-element Arrays, eachcontaining an element ofself:

a.product# => [[0], [1], [2]]

When a block is given, yields each combination as an Array; returnsself:

a.product(a1) {|combination|pcombination }

Output:

[0,3][0,4][1,3][1,4][2,3][2,4]

If any argument is an empty Array, does not call the block:

a.product(a1,a2, []) {|combination|fail'Cannot happen' }

If no argument is given, yields each element ofself as a1-element Array:

a.product {|combination|pcombination }

Output:

[0][1][2]

                static VALUErb_ary_product(int argc, VALUE *argv, VALUE ary){    int n = argc+1;    /* How many arrays we're operating on */    volatile VALUE t0 = tmpary(n);    volatile VALUE t1 = Qundef;    VALUE *arrays = RARRAY_PTR(t0); /* The arrays we're computing the product of */    int *counters = ALLOCV_N(int, t1, n); /* The current position in each one */    VALUE result = Qnil;      /* The array we'll be returning, when no block given */    long i,j;    long resultlen = 1;    RBASIC_CLEAR_CLASS(t0);    /* initialize the arrays of arrays */    ARY_SET_LEN(t0, n);    arrays[0] = ary;    for (i = 1; i < n; i++) arrays[i] = Qnil;    for (i = 1; i < n; i++) arrays[i] = to_ary(argv[i-1]);    /* initialize the counters for the arrays */    for (i = 0; i < n; i++) counters[i] = 0;    /* Otherwise, allocate and fill in an array of results */    if (rb_block_given_p()) {        /* Make defensive copies of arrays; exit if any is empty */        for (i = 0; i < n; i++) {            if (RARRAY_LEN(arrays[i]) == 0) goto done;            arrays[i] = ary_make_shared_copy(arrays[i]);        }    }    else {        /* Compute the length of the result array; return [] if any is empty */        for (i = 0; i < n; i++) {            long k = RARRAY_LEN(arrays[i]);            if (k == 0) {                result = rb_ary_new2(0);                goto done;            }            if (MUL_OVERFLOW_LONG_P(resultlen, k))                rb_raise(rb_eRangeError, "too big to product");            resultlen *= k;        }        result = rb_ary_new2(resultlen);    }    for (;;) {        int m;        /* fill in one subarray */        VALUE subarray = rb_ary_new2(n);        for (j = 0; j < n; j++) {            rb_ary_push(subarray, rb_ary_entry(arrays[j], counters[j]));        }        /* put it on the result array */        if (NIL_P(result)) {            FL_SET(t0, FL_USER5);            rb_yield(subarray);            if (! FL_TEST(t0, FL_USER5)) {                rb_raise(rb_eRuntimeError, "product reentered");            }            else {                FL_UNSET(t0, FL_USER5);            }        }        else {            rb_ary_push(result, subarray);        }        /*         * Increment the last counter.  If it overflows, reset to 0         * and increment the one before it.         */        m = n-1;        counters[m]++;        while (counters[m] == RARRAY_LEN(arrays[m])) {            counters[m] = 0;            /* If the first counter overflows, we are done */            if (--m < 0) goto done;            counters[m]++;        }    }done:    tmpary_discard(t0);    ALLOCV_END(t1);    return NIL_P(result) ? ary : result;}

Appends trailing elements.

Appends each argument inobjects toself; returnsself:

a = [:foo,'bar',2]a.push(:baz, :bat)# => [:foo, "bar", 2, :baz, :bat]

Appends each argument as one element, even if it is another Array:

a = [:foo,'bar',2]a1 =a.push([:baz, :bat], [:bam, :bad])a1# => [:foo, "bar", 2, [:baz, :bat], [:bam, :bad]]

#append is an alias forArray#push.

Related:pop,shift,unshift.

                static VALUErb_ary_push_m(int argc, VALUE *argv, VALUE ary){    return rb_ary_cat(ary, argv, argc);}

Returns the first element inself that is an Array whosesecond element==obj:

a = [{foo:0}, [2,4], [4,5,6], [4,5]]a.rassoc(4)# => [2, 4]

Returnsnil if no such element is found.

Related:assoc.

                VALUErb_ary_rassoc(VALUE ary, VALUE value){    long i;    VALUE v;    for (i = 0; i < RARRAY_LEN(ary); ++i) {        v = RARRAY_AREF(ary, i);        if (RB_TYPE_P(v, T_ARRAY) &&            RARRAY_LEN(v) > 1 &&            rb_equal(RARRAY_AREF(v, 1), value))            return v;    }    return Qnil;}

Returns a new Array whose elements are all those fromself forwhich the block returnsfalse ornil:

a = [:foo,'bar',2,'bat']a1 =a.reject {|element|element.to_s.start_with?('b') }a1# => [:foo, 2]

Returns a new Enumerator if no block given:

a = [:foo,'bar',2]a.reject# => #<Enumerator: [:foo, "bar", 2]:reject>

                static VALUErb_ary_reject(VALUE ary){    VALUE rejected_ary;    RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length);    rejected_ary = rb_ary_new();    ary_reject(ary, rejected_ary);    return rejected_ary;}

Removes each element for which the block returns a truthy value.

Returnsself if any elements removed:

a = [:foo,'bar',2,'bat']a.reject! {|element|element.to_s.start_with?('b') }# => [:foo, 2]

Returnsnil if no elements removed.

Returns a new Enumerator if no block given:

a = [:foo,'bar',2]a.reject!# => #<Enumerator: [:foo, "bar", 2]:reject!>

                static VALUErb_ary_reject_bang(VALUE ary){    RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length);    rb_ary_modify(ary);    return ary_reject_bang(ary);}

Calls the block with each repeated combination of lengthn ofthe elements ofself; each combination is an Array; returnsself. The order of the combinations is indeterminate.

When a block and a positive Integer argumentn are given,calls the block with eachn-tuple repeated combination of theelements ofself. The number of combinations is(n+1)(n+2)/2.

n = 1:

a = [0,1,2]a.repeated_combination(1) {|combination|pcombination }

Output:

[0][1][2]

n = 2:

a.repeated_combination(2) {|combination|pcombination }

Output:

[0,0][0,1][0,2][1,1][1,2][2,2]

Ifn is zero, calls the block once with an empty Array.

Ifn is negative, does not call the block:

a.repeated_combination(-1) {|combination|fail'Cannot happen' }

Returns a new Enumerator if no block given:

a = [0,1,2]a.repeated_combination(2)# => #<Enumerator: [0, 1, 2]:combination(2)>

Using Enumerators, it's convenient to show the combinations and countsfor some values ofn:

e =a.repeated_combination(0)e.size# => 1e.to_a# => [[]]e =a.repeated_combination(1)e.size# => 3e.to_a# => [[0], [1], [2]]e =a.repeated_combination(2)e.size# => 6e.to_a# => [[0, 0], [0, 1], [0, 2], [1, 1], [1, 2], [2, 2]]

                static VALUErb_ary_repeated_combination(VALUE ary, VALUE num){    long n, i, len;    n = NUM2LONG(num);                 /* Combination size from argument */    RETURN_SIZED_ENUMERATOR(ary, 1, &num, rb_ary_repeated_combination_size);   /* Return enumerator if no block */    len = RARRAY_LEN(ary);    if (n < 0) {        /* yield nothing */    }    else if (n == 0) {        rb_yield(rb_ary_new2(0));    }    else if (n == 1) {        for (i = 0; i < RARRAY_LEN(ary); i++) {            rb_yield(rb_ary_new3(1, RARRAY_AREF(ary, i)));        }    }    else if (len == 0) {        /* yield nothing */    }    else {        volatile VALUE t0;        long *p = ALLOCV_N(long, t0, n);        VALUE ary0 = ary_make_shared_copy(ary); /* private defensive copy of ary */        RBASIC_CLEAR_CLASS(ary0);        rcombinate0(len, n, p, n, ary0); /* compute and yield repeated combinations */        ALLOCV_END(t0);        RBASIC_SET_CLASS_RAW(ary0, rb_cArray);    }    return ary;}

Calls the block with each repeated permutation of lengthn ofthe elements ofself; each permutation is an Array; returnsself. The order of the permutations is indeterminate.

When a block and a positive Integer argumentn are given,calls the block with eachn-tuple repeated permutation of theelements ofself. The number of permutations isself.size**n.

n = 1:

a = [0,1,2]a.repeated_permutation(1) {|permutation|ppermutation }

Output:

[0][1][2]

n = 2:

a.repeated_permutation(2) {|permutation|ppermutation }

Output:

[0,0][0,1][0,2][1,0][1,1][1,2][2,0][2,1][2,2]

Ifn is zero, calls the block once with an empty Array.

Ifn is negative, does not call the block:

a.repeated_permutation(-1) {|permutation|fail'Cannot happen' }

Returns a new Enumerator if no block given:

a = [0,1,2]a.repeated_permutation(2)# => #<Enumerator: [0, 1, 2]:permutation(2)>

Using Enumerators, it's convenient to show the permutations and countsfor some values ofn:

e =a.repeated_permutation(0)e.size# => 1e.to_a# => [[]]e =a.repeated_permutation(1)e.size# => 3e.to_a# => [[0], [1], [2]]e =a.repeated_permutation(2)e.size# => 9e.to_a# => [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [2, 0], [2, 1], [2, 2]]

                static VALUErb_ary_repeated_permutation(VALUE ary, VALUE num){    long r, n, i;    n = RARRAY_LEN(ary);                  /* Array length */    RETURN_SIZED_ENUMERATOR(ary, 1, &num, rb_ary_repeated_permutation_size);      /* Return Enumerator if no block */    r = NUM2LONG(num);                    /* Permutation size from argument */    if (r < 0) {        /* no permutations: yield nothing */    }    else if (r == 0) { /* exactly one permutation: the zero-length array */        rb_yield(rb_ary_new2(0));    }    else if (r == 1) { /* this is a special, easy case */        for (i = 0; i < RARRAY_LEN(ary); i++) {            rb_yield(rb_ary_new3(1, RARRAY_AREF(ary, i)));        }    }    else {             /* this is the general case */        volatile VALUE t0;        long *p = ALLOCV_N(long, t0, r);        VALUE ary0 = ary_make_shared_copy(ary); /* private defensive copy of ary */        RBASIC_CLEAR_CLASS(ary0);        rpermute0(n, r, p, ary0); /* compute and yield repeated permutations */        ALLOCV_END(t0);        RBASIC_SET_CLASS_RAW(ary0, rb_cArray);    }    return ary;}

Replaces the content ofself with the content ofother_array; returnsself:

a = [:foo,'bar',2]a.replace(['foo', :bar,3])# => ["foo", :bar, 3]

                VALUErb_ary_replace(VALUE copy, VALUE orig){    rb_ary_modify_check(copy);    orig = to_ary(orig);    if (copy == orig) return copy;    if (RARRAY_LEN(orig) <= RARRAY_EMBED_LEN_MAX) {        VALUE shared_root = 0;        if (ARY_OWNS_HEAP_P(copy)) {            ary_heap_free(copy);        }        else if (ARY_SHARED_P(copy)) {            shared_root = ARY_SHARED_ROOT(copy);            FL_UNSET_SHARED(copy);        }        FL_SET_EMBED(copy);        ary_memcpy(copy, 0, RARRAY_LEN(orig), RARRAY_CONST_PTR_TRANSIENT(orig));        if (shared_root) {            rb_ary_decrement_share(shared_root);        }        ARY_SET_LEN(copy, RARRAY_LEN(orig));    }    else {        VALUE shared_root = ary_make_shared(orig);        if (ARY_OWNS_HEAP_P(copy)) {            ary_heap_free(copy);        }        else {            rb_ary_unshare_safe(copy);        }        FL_UNSET_EMBED(copy);        ARY_SET_PTR(copy, ARY_HEAP_PTR(orig));        ARY_SET_LEN(copy, ARY_HEAP_LEN(orig));        rb_ary_set_shared(copy, shared_root);    }    ary_verify(copy);    return copy;}

Returns a new Array with the elements ofself in reverseorder.

a = ['foo','bar','two']a1 =a.reversea1# => ["two", "bar", "foo"]

                static VALUErb_ary_reverse_m(VALUE ary){    long len = RARRAY_LEN(ary);    VALUE dup = rb_ary_new2(len);    if (len > 0) {        const VALUE *p1 = RARRAY_CONST_PTR_TRANSIENT(ary);        VALUE *p2 = (VALUE *)RARRAY_CONST_PTR_TRANSIENT(dup) + len - 1;        do *p2-- = *p1++; while (--len > 0);    }    ARY_SET_LEN(dup, RARRAY_LEN(ary));    return dup;}

Reversesself in place:

a = ['foo','bar','two']a.reverse!# => ["two", "bar", "foo"]

                static VALUErb_ary_reverse_bang(VALUE ary){    return rb_ary_reverse(ary);}

Iterates backwards over array elements.

When a block given, passes, in reverse order, each element to the block;returnsself:

a = [:foo,'bar',2]a.reverse_each {|element|puts"#{element.class} #{element}" }

Output:

Integer2StringbarSymbolfoo

Allows the array to be modified during iteration:

a = [:foo,'bar',2]a.reverse_each {|element|putselement;a.clearifelement.to_s.start_with?('b') }

Output:

2bar

When no block given, returns a new Enumerator:

a = [:foo,'bar',2]e =a.reverse_eache# => #<Enumerator: [:foo, "bar", 2]:reverse_each>a1 =e.each {|element|puts"#{element.class} #{element}" }

Output:

Integer2StringbarSymbolfoo

Related:each,each_index.

                static VALUErb_ary_reverse_each(VALUE ary){    long len;    RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length);    len = RARRAY_LEN(ary);    while (len--) {        long nlen;        rb_yield(RARRAY_AREF(ary, len));        nlen = RARRAY_LEN(ary);        if (nlen < len) {            len = nlen;        }    }    return ary;}

Returns the index of the last element for whichobject ==element.

When argumentobject is given but no block, returns the indexof the last such element found:

a = [:foo,'bar',2,'bar']a.rindex('bar')# => 3

Returnsnil if no such object found.

When a block is given but no argument, calls the block with each successiveelement; returns the index of the last element for which the block returnsa truthy value:

a = [:foo,'bar',2,'bar']a.rindex {|element|element=='bar' }# => 3

Returnsnil if the block never returns a truthy value.

When neither an argument nor a block is given, returns a new Enumerator:

a = [:foo,'bar',2,'bar']e =a.rindexe# => #<Enumerator: [:foo, "bar", 2, "bar"]:rindex>e.each {|element|element=='bar' }# => 3

Related:index.

                static VALUErb_ary_rindex(int argc, VALUE *argv, VALUE ary){    VALUE val;    long i = RARRAY_LEN(ary), len;    if (argc == 0) {        RETURN_ENUMERATOR(ary, 0, 0);        while (i--) {            if (RTEST(rb_yield(RARRAY_AREF(ary, i))))                return LONG2NUM(i);            if (i > (len = RARRAY_LEN(ary))) {                i = len;            }        }        return Qnil;    }    rb_check_arity(argc, 0, 1);    val = argv[0];    if (rb_block_given_p())        rb_warn("given block not used");    while (i--) {        VALUE e = RARRAY_AREF(ary, i);        if (rb_equal(e, val)) {            return LONG2NUM(i);        }        if (i > RARRAY_LEN(ary)) {            break;        }    }    return Qnil;}

Returns a new Array formed fromself with elements rotatedfrom one end to the other.

When no argument given, returns a new Array that is likeself,except that the first element has been rotated to the last position:

a = [:foo,'bar',2,'bar']a1 =a.rotatea1# => ["bar", 2, "bar", :foo]

When given a non-negative Integercount, returns a new Arraywithcount elements rotated from the beginning to the end:

a = [:foo,'bar',2]a1 =a.rotate(2)a1# => [2, :foo, "bar"]

Ifcount is large, usescount % array.size as thecount:

a = [:foo,'bar',2]a1 =a.rotate(20)a1# => [2, :foo, "bar"]

Ifcount is zero, returns a copy ofself,unmodified:

a = [:foo,'bar',2]a1 =a.rotate(0)a1# => [:foo, "bar", 2]

When given a negative Integercount, rotates in the oppositedirection, from end to beginning:

a = [:foo,'bar',2]a1 =a.rotate(-2)a1# => ["bar", 2, :foo]

Ifcount is small (far from zero), usescount %array.size as the count:

a = [:foo,'bar',2]a1 =a.rotate(-5)a1# => ["bar", 2, :foo]

                static VALUErb_ary_rotate_m(int argc, VALUE *argv, VALUE ary){    VALUE rotated;    const VALUE *ptr;    long len;    long cnt = (rb_check_arity(argc, 0, 1) ? NUM2LONG(argv[0]) : 1);    len = RARRAY_LEN(ary);    rotated = rb_ary_new2(len);    if (len > 0) {        cnt = rotate_count(cnt, len);        ptr = RARRAY_CONST_PTR_TRANSIENT(ary);        len -= cnt;        ary_memcpy(rotated, 0, len, ptr + cnt);        ary_memcpy(rotated, len, cnt, ptr);    }    ARY_SET_LEN(rotated, RARRAY_LEN(ary));    return rotated;}

Rotatesself in place by moving elements from one end to theother; returnsself.

When no argument given, rotates the first element to the last position:

a = [:foo,'bar',2,'bar']a.rotate!# => ["bar", 2, "bar", :foo]

When given a non-negative Integercount, rotatescount elements from the beginning to the end:

a = [:foo,'bar',2]a.rotate!(2)a# => [2, :foo, "bar"]

Ifcount is large, usescount % array.size as thecount:

a = [:foo,'bar',2]a.rotate!(20)a# => [2, :foo, "bar"]

Ifcount is zero, returnsself unmodified:

a = [:foo,'bar',2]a.rotate!(0)a# => [:foo, "bar", 2]

When given a negativeIntegercount, rotates in the opposite direction, from end tobeginning:

a = [:foo,'bar',2]a.rotate!(-2)a# => ["bar", 2, :foo]

Ifcount is small (far from zero), usescount %array.size as the count:

a = [:foo,'bar',2]a.rotate!(-5)a# => ["bar", 2, :foo]

                static VALUErb_ary_rotate_bang(int argc, VALUE *argv, VALUE ary){    long n = (rb_check_arity(argc, 0, 1) ? NUM2LONG(argv[0]) : 1);    rb_ary_rotate(ary, n);    return ary;}

Returns random elements fromself.

When no arguments are given, returns a random element fromself:

a = [1,2,3,4,5,6,7,8,9,10]a.sample# => 3a.sample# => 8

Ifself is empty, returnsnil.

When argumentn is given, returns a new Array containingn random elements fromself:

a.sample(3)# => [8, 9, 2]a.sample(6)# => [9, 6, 10, 3, 1, 4]

Returns no more thana.size elements (because no newduplicates are introduced):

a.sample(a.size*2)# => [6, 4, 1, 8, 5, 9, 10, 2, 3, 7]

Butself may contain duplicates:

a = [1,1,1,2,2,3]a.sample(a.size*2)# => [1, 1, 3, 2, 1, 2]

Returns a new empty Array ifself is empty.

The optionalrandom argument will be used as the random numbergenerator:

a = [1,2,3,4,5,6,7,8,9,10]a.sample(random:Random.new(1))#=> 6a.sample(4,random:Random.new(1))#=> [6, 10, 9, 2]

# File array.rb, line 58defsample(n = (ary =false),random:Random)Primitive.rb_ary_sample(random,n,ary)end

Calls the block, if given, with each element ofself; returnsa new Array containing those elements ofself for which theblock returns a truthy value:

a = [:foo,'bar',2, :bam]a1 =a.select {|element|element.to_s.start_with?('b') }a1# => ["bar", :bam]

Returns a new Enumerator if no block given:

a = [:foo,'bar',2, :bam]a.select# => #<Enumerator: [:foo, "bar", 2, :bam]:select>

#filter is an alias for#select.

                static VALUErb_ary_select(VALUE ary){    VALUE result;    long i;    RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length);    result = rb_ary_new2(RARRAY_LEN(ary));    for (i = 0; i < RARRAY_LEN(ary); i++) {        if (RTEST(rb_yield(RARRAY_AREF(ary, i)))) {            rb_ary_push(result, rb_ary_elt(ary, i));        }    }    return result;}

Calls the block, if given with each element ofself; removesfromself those elements for which the block returnsfalse ornil.

Returnsself if any elements were removed:

a = [:foo,'bar',2, :bam]a.select! {|element|element.to_s.start_with?('b') }# => ["bar", :bam]

Returnsnil if no elements were removed.

Returns a new Enumerator if no block given:

a = [:foo,'bar',2, :bam]a.select!# => #<Enumerator: [:foo, "bar", 2, :bam]:select!>

#filter! is an alias for#select!.

                static VALUErb_ary_select_bang(VALUE ary){    struct select_bang_arg args;    RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length);    rb_ary_modify(ary);    args.ary = ary;    args.len[0] = args.len[1] = 0;    return rb_ensure(select_bang_i, (VALUE)&args, select_bang_ensure, (VALUE)&args);}

Removes and returns leading elements.

When no argument is given, removes and returns the first element:

a = [:foo,'bar',2]a.shift# => :fooa# => ['bar', 2]

Returnsnil ifself is empty.

When positive Integer argumentn is given, removes the firstn elements; returns those elements in a new Array:

a = [:foo,'bar',2]a.shift(2)# => [:foo, 'bar']a# => [2]

Ifn is as large as or larger thanself.length,removes all elements; returns those elements in a new Array:

a = [:foo,'bar',2]a.shift(3)# => [:foo, 'bar', 2]

Ifn is zero, returns a new empty Array;self isunmodified.

Related:push,pop,unshift.

                static VALUErb_ary_shift_m(int argc, VALUE *argv, VALUE ary){    VALUE result;    long n;    if (argc == 0) {        return rb_ary_shift(ary);    }    rb_ary_modify_check(ary);    result = ary_take_first_or_last(argc, argv, ary, ARY_TAKE_FIRST);    n = RARRAY_LEN(result);    rb_ary_behead(ary,n);    return result;}

Returns a new array with elements ofself shuffled.

a = [1,2,3]#=> [1, 2, 3]a.shuffle#=> [2, 3, 1]a#=> [1, 2, 3]

The optionalrandom argument will be used as the random numbergenerator:

a.shuffle(random:Random.new(1))#=> [1, 3, 2]

# File array.rb, line 26defshuffle(random:Random)Primitive.rb_ary_shuffle(random)end

Shuffles the elements ofself in place.

a = [1,2,3]#=> [1, 2, 3]a.shuffle!#=> [2, 3, 1]a#=> [2, 3, 1]

The optionalrandom argument will be used as the random numbergenerator:

a.shuffle!(random:Random.new(1))#=> [1, 3, 2]

# File array.rb, line 12defshuffle!(random:Random)Primitive.rb_ary_shuffle_bang(random)end

Returns elements fromself; does not modifyself.

When a single Integer argumentindex is given, returns theelement at offsetindex:

a = [:foo,'bar',2]a[0]# => :fooa[2]# => 2a# => [:foo, "bar", 2]

Ifindex is negative, counts relative to the end ofself:

a = [:foo,'bar',2]a[-1]# => 2a[-2]# => "bar"

Ifindex is out of range, returnsnil.

When two Integer argumentsstart andlength aregiven, returns a new Array of sizelength containingsuccessive elements beginning at offsetstart:

a = [:foo,'bar',2]a[0,2]# => [:foo, "bar"]a[1,2]# => ["bar", 2]

Ifstart + length is greater thanself.length,returns all elements from offsetstart to the end:

a = [:foo,'bar',2]a[0,4]# => [:foo, "bar", 2]a[1,3]# => ["bar", 2]a[2,2]# => [2]

Ifstart == self.size andlength >= 0, returnsa new empty Array.

Iflength is negative, returnsnil.

When a single Range argumentrange is given, treatsrange.min asstart above andrange.size aslength above:

a = [:foo,'bar',2]a[0..1]# => [:foo, "bar"]a[1..2]# => ["bar", 2]

Special case: Ifrange.start == a.size, returns a new emptyArray.

Ifrange.end is negative, calculates the end index from theend:

a = [:foo,'bar',2]a[0..-1]# => [:foo, "bar", 2]a[0..-2]# => [:foo, "bar"]a[0..-3]# => [:foo]

Ifrange.start is negative, calculates the start index fromthe end:

a = [:foo,'bar',2]a[-1..2]# => [2]a[-2..2]# => ["bar", 2]a[-3..2]# => [:foo, "bar", 2]

Ifrange.start is larger than the array size, returnsnil.

a = [:foo,'bar',2]a[4..1]# => nila[4..0]# => nila[4..-1]# => nil

When a singleEnumerator::ArithmeticSequenceargumentaseq is given, returns anArray of elements corresponding to the indexesproduced by the sequence.

a = ['--', 'data1', '--', 'data2', '--', 'data3']a[(1..).step(2)] # => ["data1", "data2", "data3"]

Unlike slicing with range, if the start or the end of the arithmeticsequence is larger than array size, throwsRangeError.

a = ['--', 'data1', '--', 'data2', '--', 'data3']a[(1..11).step(2)]# RangeError (((1..11).step(2)) out of range)a[(7..).step(2)]# RangeError (((7..).step(2)) out of range)

If given a single argument, and its type is not one of the listed, tries toconvert it toInteger, and raises if it isimpossible:

a = [:foo,'bar',2]# Raises TypeError (no implicit conversion of Symbol into Integer):a[:foo]

#slice is an alias for#[].

                VALUErb_ary_aref(int argc, const VALUE *argv, VALUE ary){    rb_check_arity(argc, 1, 2);    if (argc == 2) {        return rb_ary_aref2(ary, argv[0], argv[1]);    }    return rb_ary_aref1(ary, argv[0]);}

Removes and returns elements fromself.

When the only argument is an Integern, removes and returnsthenth element inself:

a = [:foo,'bar',2]a.slice!(1)# => "bar"a# => [:foo, 2]

Ifn is negative, counts backwards from the end ofself:

a = [:foo,'bar',2]a.slice!(-1)# => 2a# => [:foo, "bar"]

Ifn is out of range, returnsnil.

When the only arguments are Integersstart andlength, removeslength elements fromself beginning at offsetstart; returns thedeleted objects in a new Array:

a = [:foo,'bar',2]a.slice!(0,2)# => [:foo, "bar"]a# => [2]

Ifstart + length exceeds the array size, removes and returnsall elements from offsetstart to the end:

a = [:foo,'bar',2]a.slice!(1,50)# => ["bar", 2]a# => [:foo]

Ifstart == a.size andlength is non-negative,returns a new empty Array.

Iflength is negative, returnsnil.

When the only argument is a Range objectrange, treatsrange.min asstart above andrange.size aslength above:

a = [:foo,'bar',2]a.slice!(1..2)# => ["bar", 2]a# => [:foo]

Ifrange.start == a.size, returns a new empty Array.

Ifrange.start is larger than the array size, returnsnil.

Ifrange.end is negative, counts backwards from the end of thearray:

a = [:foo,'bar',2]a.slice!(0..-2)# => [:foo, "bar"]a# => [2]

Ifrange.start is negative, calculates the start indexbackwards from the end of the array:

a = [:foo,'bar',2]a.slice!(-2..2)# => ["bar", 2]a# => [:foo]

                static VALUErb_ary_slice_bang(int argc, VALUE *argv, VALUE ary){    VALUE arg1;    long pos, len;    rb_ary_modify_check(ary);    rb_check_arity(argc, 1, 2);    arg1 = argv[0];    if (argc == 2) {        pos = NUM2LONG(argv[0]);        len = NUM2LONG(argv[1]);        return ary_slice_bang_by_rb_ary_splice(ary, pos, len);    }    if (!FIXNUM_P(arg1)) {        switch (rb_range_beg_len(arg1, &pos, &len, RARRAY_LEN(ary), 0)) {          case Qtrue:            /* valid range */            return ary_slice_bang_by_rb_ary_splice(ary, pos, len);          case Qnil:            /* invalid range */            return Qnil;          default:            /* not a range */            break;        }    }    return rb_ary_delete_at(ary, NUM2LONG(arg1));}

Returns a new Array whose elements are those fromself,sorted.

With no block, compares elements using operator<=> (seeComparable):

a ='abcde'.split('').shufflea# => ["e", "b", "d", "a", "c"]a1 =a.sorta1# => ["a", "b", "c", "d", "e"]

With a block, calls the block with each element pair; for each element paira andb, the block should return an integer:

• Negative whenb is to followa.

• Zero whena andb are equivalent.

• Positive whena is to followb.

Example:

a ='abcde'.split('').shufflea# => ["e", "b", "d", "a", "c"]a1 =a.sort {|a,b|a<=>b }a1# => ["a", "b", "c", "d", "e"]a2 =a.sort {|a,b|b<=>a }a2# => ["e", "d", "c", "b", "a"]

When the block returns zero, the order fora andb is indeterminate, and may be unstable:

a ='abcde'.split('').shufflea# => ["e", "b", "d", "a", "c"]a1 =a.sort {|a,b|0 }a1# =>  ["c", "e", "b", "d", "a"]

Related:Enumerable#sort_by.

                VALUErb_ary_sort(VALUE ary){    ary = rb_ary_dup(ary);    rb_ary_sort_bang(ary);    return ary;}

Returnsself with its elements sorted in place.

With no block, compares elements using operator<=> (seeComparable):

a ='abcde'.split('').shufflea# => ["e", "b", "d", "a", "c"]a.sort!a# => ["a", "b", "c", "d", "e"]

With a block, calls the block with each element pair; for each element paira andb, the block should return an integer:

• Negative whenb is to followa.

• Zero whena andb are equivalent.

• Positive whena is to followb.

Example:

a ='abcde'.split('').shufflea# => ["e", "b", "d", "a", "c"]a.sort! {|a,b|a<=>b }a# => ["a", "b", "c", "d", "e"]a.sort! {|a,b|b<=>a }a# => ["e", "d", "c", "b", "a"]

When the block returns zero, the order fora andb is indeterminate, and may be unstable:

a ='abcde'.split('').shufflea# => ["e", "b", "d", "a", "c"]a.sort! {|a,b|0 }a# => ["d", "e", "c", "a", "b"]

                VALUErb_ary_sort_bang(VALUE ary){    rb_ary_modify(ary);    assert(!ARY_SHARED_P(ary));    if (RARRAY_LEN(ary) > 1) {        VALUE tmp = ary_make_substitution(ary); /* only ary refers tmp */        struct ary_sort_data data;        long len = RARRAY_LEN(ary);        RBASIC_CLEAR_CLASS(tmp);        data.ary = tmp;        data.cmp_opt.opt_methods = 0;        data.cmp_opt.opt_inited = 0;        RARRAY_PTR_USE(tmp, ptr, {            ruby_qsort(ptr, len, sizeof(VALUE),                       rb_block_given_p()?sort_1:sort_2, &data);        }); /* WB: no new reference */        rb_ary_modify(ary);        if (ARY_EMBED_P(tmp)) {            if (ARY_SHARED_P(ary)) { /* ary might be destructively operated in the given block */                rb_ary_unshare(ary);                FL_SET_EMBED(ary);            }            ary_memcpy(ary, 0, ARY_EMBED_LEN(tmp), ARY_EMBED_PTR(tmp));            ARY_SET_LEN(ary, ARY_EMBED_LEN(tmp));        }        else {            if (!ARY_EMBED_P(ary) && ARY_HEAP_PTR(ary) == ARY_HEAP_PTR(tmp)) {                FL_UNSET_SHARED(ary);                ARY_SET_CAPA(ary, RARRAY_LEN(tmp));            }            else {                assert(!ARY_SHARED_P(tmp));                if (ARY_EMBED_P(ary)) {                    FL_UNSET_EMBED(ary);                }                else if (ARY_SHARED_P(ary)) {                    /* ary might be destructively operated in the given block */                    rb_ary_unshare(ary);                }                else {                    ary_heap_free(ary);                }                ARY_SET_PTR(ary, ARY_HEAP_PTR(tmp));                ARY_SET_HEAP_LEN(ary, len);                ARY_SET_CAPA(ary, ARY_HEAP_LEN(tmp));            }            /* tmp was lost ownership for the ptr */            FL_UNSET(tmp, FL_FREEZE);            FL_SET_EMBED(tmp);            ARY_SET_EMBED_LEN(tmp, 0);            FL_SET(tmp, FL_FREEZE);        }        /* tmp will be GC'ed. */        RBASIC_SET_CLASS_RAW(tmp, rb_cArray); /* rb_cArray must be marked */    }    ary_verify(ary);    return ary;}

Sorts the elements ofself in place, using an orderingdetermined by the block; returns self.

Calls the block with each successive element; sorts elements based on thevalues returned from the block.

For duplicates returned by the block, the ordering is indeterminate, andmay be unstable.

This example sorts strings based on their sizes:

a = ['aaaa','bbb','cc','d']a.sort_by! {|element|element.size }a# => ["d", "cc", "bbb", "aaaa"]

Returns a new Enumerator if no block given:

a = ['aaaa','bbb','cc','d']a.sort_by!# => #<Enumerator: ["aaaa", "bbb", "cc", "d"]:sort_by!>

                static VALUErb_ary_sort_by_bang(VALUE ary){    VALUE sorted;    RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length);    rb_ary_modify(ary);    sorted = rb_block_call(ary, rb_intern("sort_by"), 0, 0, sort_by_i, 0);    rb_ary_replace(ary, sorted);    return ary;}

When no block is given, returns the object equivalent to:

sum =initarray.each {|element|sum+=element }sum

For example,[e1, e2, e3].sum returns </tt>init + e1 +e2 + e3</tt>.