Arrays are ordered, integer-indexed collections of any object.

Array indexing starts at 0, as in C or Java. A negative index is assumed to be relative to the end of the array---that is, an index of -1 indicates the last element of the array, -2 is the next to last element in the array, and so on.

1. Creating Arrays

A new array can be created by using the literal constructor []. Arrays can contain different types of objects. For example, the array below contains an Integer, a String and a Float:

ary = [1, "two", 3.0] #=> [1, "two", 3.0]

An array can also be created by explicitly calling ::new with zero, one (the initial size of the Array), or two arguments (the initial size and a default object).

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

Note that the second argument populates the array with references to the same object. Therefore, it is only recommended in cases when you need to instantiate arrays with natively immutable objects such as symbols, numbers, true, or false.

To create an array with separate objects, a block can be passed instead. This method is safe to use with mutable objects such as hashes, strings, or other arrays:

Array.new(4){Hash.new} #=> [{}, {}, {}, {}]

This is also a quick way to build up multi-dimensional arrays:

empty_table = Array.new(3){Array.new(3)}
#=> [[nil, nil, nil], [nil, nil, nil], [nil, nil, nil]]

An array can also be created by using the Array() method, provided by Kernel, which tries to call to_ary, then to_a on its argument.

Array({:a => "a", :b => "b"}) #=> [[:a, "a"], [:b, "b"]]

2. Example Usage

In addition to the methods it mixes in through the Enumerable module, the Array class has proprietary methods for accessing, searching and otherwise manipulating arrays.

Some of the more common ones are illustrated below.

3. Accessing Elements

Elements in an array can be retrieved using the #[] method. It can take a single integer argument (a numeric index), a pair of arguments (start and length), or a range. Negative indices start counting from the end, with -1 being the last element.

arr = [1, 2, 3, 4, 5, 6]
arr[2]     #=> 3
arr[100]   #=> nil
arr[-3]    #=> 4
arr[2, 3]  #=> [3, 4, 5]
arr[1..4]  #=> [2, 3, 4, 5]
arr[1..-3] #=> [2, 3, 4]

Another way to access a particular array element is by using the at method

arr.at(0) #=> 1

The slice method works in an identical manner to #[].

To raise an error for indices outside of the array bounds or else to provide a default value when that happens, you can use fetch.

arr = ["a", "b", "c", "d", "e", "f"]
arr.fetch(100) #=> IndexError: index 100 outside of array bounds: -6...6
arr.fetch(100, "oops") #=> "oops"

The special methods first and last will return the first and last elements of an array, respectively.

arr.first #=> 1
arr.last  #=> 6

To return the first n elements of an array, use take

arr.take(3) #=> [1, 2, 3]

drop does the opposite of take, by returning the elements after n elements have been dropped:

arr.drop(3) #=> [4, 5, 6]

4. Obtaining Information about an Array

Arrays keep track of their own length at all times. To query an array about the number of elements it contains, use length, count, or size.

browsers = ["Chrome", "Firefox", "Safari", "Opera", "IE"]
browsers.length #=> 5
browsers.count #=> 5

To check whether an array contains any elements at all

browsers.empty? #=> false

To check whether a particular item is included in the array

browsers.include?("Konqueror") #=> false

5. Adding Items to Arrays

Items can be added to the end of an array by using either push or <<

arr = [1, 2, 3, 4]
arr.push(5) #=> [1, 2, 3, 4, 5]
arr << 6    #=> [1, 2, 3, 4, 5, 6]

unshift will add a new item to the beginning of an array.

arr.unshift(0) #=> [0, 1, 2, 3, 4, 5, 6]

With insert, you can add a new element to an array at any position.

arr.insert(3, "apple") #=> [0, 1, 2, "apple", 3, 4, 5, 6]

Using the insert method, you can also insert multiple values at once:

arr.insert(3, "orange", "pear", "grapefruit")
#=> [0, 1, 2, "orange", "pear", "grapefruit", "apple", 3, 4, 5, 6]

6. Removing Items from an Array

The method pop removes the last element in an array and returns it:

arr =  [1, 2, 3, 4, 5, 6]
arr.pop #=> 6
arr #=> [1, 2, 3, 4, 5]

To retrieve and at the same time remove the first item, use shift:

arr.shift #=> 1
arr #=> [2, 3, 4, 5]

To delete an element at a particular index:

arr.delete_at(2) #=> 4
arr #=> [2, 3, 5]

To delete a particular element anywhere in an array, use delete:

arr = [1, 2, 2, 3]
arr.delete(2) #=> 2
arr #=> [1,3]

A useful method if you need to remove nil values from an array is compact:

arr = ["foo", 0, nil, "bar", 7, "baz", nil]
arr.compact  #=> ["foo", 0, "bar", 7, "baz"]
arr          #=> ["foo", 0, nil, "bar", 7, "baz", nil]
arr.compact! #=> ["foo", 0, "bar", 7, "baz"]
arr          #=> ["foo", 0, "bar", 7, "baz"]

Another common need is to remove duplicate elements from an array.

It has the non-destructive uniq, and destructive method uniq!

arr = [2, 5, 6, 556, 6, 6, 8, 9, 0, 123, 556]
arr.uniq #=> [2, 5, 6, 556, 8, 9, 0, 123]

7. Iterating over Arrays

Like all classes that include the Enumerable module, Array has an each method, which defines what elements should be iterated over and how. In case of Array’s each, all elements in the Array instance are yielded to the supplied block in sequence.

Note that this operation leaves the array unchanged.

arr = [1, 2, 3, 4, 5]
arr.each{|a| print a -= 10, " "}
# prints: -9 -8 -7 -6 -5
#=> [1, 2, 3, 4, 5]

Another sometimes useful iterator is reverse_each which will iterate over the elements in the array in reverse order.

words = %w[first second third fourth fifth sixth]
str = ""
words.reverse_each{|word| str += "\#\{word\} "}
p str #=> "sixth fifth fourth third second first "

The map method can be used to create a new array based on the original array, but with the values modified by the supplied block:

arr.map{|a| 2*a}   #=> [2, 4, 6, 8, 10]
arr                #=> [1, 2, 3, 4, 5]
arr.map!{|a| a**2} #=> [1, 4, 9, 16, 25]
arr                #=> [1, 4, 9, 16, 25]

8. Selecting Items from an Array

Elements can be selected from an array according to criteria defined in a block. The selection can happen in a destructive or a non-destructive manner. While the destructive operations will modify the array they were called on, the non-destructive methods usually return a new array with the selected elements, but leave the original array unchanged.

8.1. Non-destructive Selection

arr = [1, 2, 3, 4, 5, 6]
arr.select{|a| a > 3}     #=> [4, 5, 6]
arr.reject{|a| a < 3}     #=> [3, 4, 5, 6]
arr.drop_while{|a| a < 4} #=> [4, 5, 6]
arr                       #=> [1, 2, 3, 4, 5, 6]

8.2. Destructive Selection

select! and reject! are the corresponding destructive methods to select and reject

Similar to select vs. reject, delete_if and keep_if have the exact opposite result when supplied with the same block:

arr.delete_if{|a| a < 4} #=> [4, 5, 6]
arr                      #=> [4, 5, 6]
arr = [1, 2, 3, 4, 5, 6]
arr.keep_if{|a| a < 4} #=> [1, 2, 3]
arr                    #=> [1, 2, 3]

public class Array

Enumerable

┊

Array

Kernel

┊

Object

BasicObject

<<Array

<<Object

<<BasicObject

Class

Module

Kernel

┊

Object

BasicObject

public 1 Array.[]

Implementation candidates

[]

Usage (*args) → Array

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/]

Test 1. ruby/test/ruby/test_array.rb:test_01_square_brackets

1 Array[5, 4, 3, 2, 1].instance_of?(Array)

2 RETURN.length == 5

3 RETURN[0] == 5

4 RETURN[1] == 4

5 RETURN[2] == 3

6 RETURN[3] == 2

7 RETURN[4] == 1

8 RETURN[6].nil?

public 2 Array.new Misplaced Defined on `Class`.

Implementation candidates

new

Returns a new array.

Usage (size = 0, obj = nil) → Array

If no arguments are sent, the new array will be empty. When a size and an optional obj are sent, an array is created with size copies of obj. Take notice that all elements will reference the same object obj.

Usage (array) → Array

Creates a copy of the array passed as a parameter (the array is generated by calling #to_ary on the parameter).

first_array = ["Matz", "Guido"]
second_array = Array.new(first_array) #=> ["Matz", "Guido"]
first_array.equal? second_array       #=> false

Usage (size){|index| block} → Array

An array of the given size is created. Each element in this array is created by passing the element’s index to the given block and storing the return value.

Array.new(3){|index| index ** 2}
# => [0, 1, 4]

Test 2. ruby/test/ruby/test_array.rb:test_00_new

9 Array.new.instance_of?(Array)

10 RETURN.empty?

11 RETURN[0].nil?

Common gotchas

When sending the second parameter, the same object will be used as the value for all the array elements:

a = Array.new(2, Hash.new)
# => [{}, {}]
a[0]["cat"] = "feline"
a # => [{"cat"=>"feline"}, {"cat"=>"feline"}]
a[1]["cat"] = "Felix"
a # => [{"cat"=>"Felix"}, {"cat"=>"Felix"}]

Since all the Array elements store the same hash, changes to one of them will affect them all.

If multiple copies are what you want, you should use the block version which uses the result of that block each time an element of the array needs to be initialized:

a = Array.new(2){Hash.new}
a[0]["cat"] = "feline"
a # => [{"cat"=>"feline"}, {}]

public 3 Array.try_convert

Implementation candidates

try_convert

Usage (obj) → Array | nil

Tries to convert obj into an array, using to_ary method. Returns the converted array or nil if obj cannot be converted for any reason. This method can be used to check if an argument is an array.

Array.try_convert([1])   #=> [1]
Array.try_convert("1")   #=> nil
if tmp = Array.try_convert(arg)
  # the argument is an array
elsif tmp = String.try_convert(arg)
  # the argument is a string
end

Test 3. ruby/test/ruby/test_array.rb:test_try_convert

12 Array.try_convert([1]) == [1]

13 Array.try_convert("1").nil?

public 1 Array#&

Implementation candidates

public 2 Array#*

Implementation candidates

Repetition

Usage (str) → String

Equivalent to self.join(str).

Usage (int) → Array

Returns a new array built by concatenating the int copies of self.

[1, 2, 3] * 3    #=> [1, 2, 3, 1, 2, 3, 1, 2, 3]
[1, 2, 3] * ","  #=> "1,2,3"

Test 7. ruby/test/ruby/test_array.rb:test_MUL # '*'

20 ([] * 3) == []

21 ([1] * 3) == [1, 1, 1]

22 ([1, 2] * 3) == [1, 2, 1, 2, 1, 2]

23 ([1, 2, 3] * 0) == []

24 ([1, 2] * -3).raise?(ArgumentError)

25 ([1, 2, 3, 4, 5] * "-") == "1-2-3-4-5"

26 ([1, 2, 3, 4, 5] * "") == "12345"

Test 8. ruby/test/ruby/test_array.rb:test_times

Setup code

longp = [127, 63, 31, 15, 7].map{|x| 2**x-1}.find do
  |x|
  begin
    [].first(x)
  rescue ArgumentError
    true
  rescue RangeError
  false
  end
end

27 ([0, 0, 0, 0] * (longp + 1) / 4).raise?(ArgumentError)

Test 9. ruby/test/ruby/test_array.rb:test_0_literal:2/8

28 ([1, 2] * 2) == [1, 2, 1, 2]

29 ([1, 2] * ":") == "1:2"

public 3 Array#+

Implementation candidates

public 4 Array#-

Implementation candidates

Usage (other_ary) → Array

Array Difference

Returns a new array that is a copy of the original array, removing any items that also appear in other_ary. The order is preserved from the original array.

It compares elements using their hash and eql? methods for efficiency.

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

If you need set-like behavior, see the library class Set.

Test 12. ruby/test/ruby/test_array.rb:test_MINUS # '-'

36 ([1] - [1]) == []

37 ([1, 2, 3, 4, 5] - [2, 3, 4, 5]) == [1]

38 ([1, 2, 1, 3, 1, 4, 1, 5] - [2, 3, 4, 5]) == [1, 1, 1, 1]

39 (1000.times.with_object(Array[]){|_, a| a << 1} - [2]) == Array[1] * 1000

40 ([1, 2, 1] - [2]) == [1, 1]

41 ([1, 2, 3] - [4, 5, 6]) == [1, 2, 3]

Test 13. ruby/test/ruby/test_array.rb:test_0_literal:6/8

42 ([1, 2, 3] - [2, 3]) == [1]

public 5 Array#<<

Implementation candidates

<<

Usage (obj) → Array

Append—Pushes the given object on to the end of this array. This expression returns the array itself, so several appends may be chained together.

[1, 2] << "c" << "d" << [3, 4]
        #=>  [1, 2, "c", "d", [3, 4]]

Test 14. ruby/test/ruby/test_array.rb:test_LSHIFT # '<<'

Setup code

a = Array[]

43 (a << 1).succeed?

44 RECEIVER == [1]

45 ((a << 1) << 2 << 3).succeed?

46 RECEIVER == [1, 2, 3]

47 ((((a << 1) << 2) << 3) << nil << "cat").succeed?

48 RECEIVER == [1, 2, 3, nil, "cat"]

49 (((((a << 1) << 2) << 3) << nil) << "cat" << a).succeed?

50 RECEIVER == Array[1, 2, 3, nil, "cat", a]

public 6 Array#<=>

Implementation candidates

<=>

Usage (other_ary) → -1 | 0 | 1 | nil

Comparison — Returns an integer (-1, 0, or +1) if this array is less than, equal to, or greater than other_ary.

nil is returned if the two values are incomparable.

Each object in each array is compared (using the <=> operator).

Arrays are compared in an element-wise manner; the first two elements that are not equal will determine the return value for the whole comparison.

If all the values are equal, then the return is based on a comparison of the array lengths. Thus, two arrays are equal according to Array#<=> if, and only if, they have the same length and the value of each element is equal to the value of the corresponding element in the other array.

["a", "a", "c"]    <=> ["a", "b", "c"]   #=> -1
[1, 2, 3, 4, 5, 6] <=> [1, 2]            #=> +1

Test 15. ruby/test/ruby/test_array.rb:test_CMP # '<=>'

51 ([] <=> []).zero?

52 ([1] <=> [1]).zero?

53 ([1, 2, 3, "cat"] <=> [1, 2, 3, "cat"]).zero?

54 ([] <=> [1]) == -1

55 ([1] <=> []) == 1

56 ([1, 2, 3] <=> [1, 2, 3, "cat"]) == -1

57 ([1, 2, 3, "cat"] <=> [1, 2, 3]) == 1

58 ([1, 2, 3, "cat"] <=> [1, 2, 3, "dog"]) == -1

59 ([1, 2, 3, "dog"] <=> [1, 2, 3, "cat"]) == 1

public 7 Array#==

Implementation candidates

==

Usage (other_ary) → true | false

Equality — Two arrays are equal if they contain the same number of elements and if each element is equal to (according to Object#==) the corresponding element in other_ary.

["a", "c"]    == ["a", "c", 7]     #=> false
["a", "c", 7] == ["a", "c", 7]     #=> true
["a", "c", 7] == ["a", "d", "f"]   #=> false

Test 16. ruby/test/ruby/test_array.rb:test_EQUAL # '=='

60 ([] == []) == true

61 ([1] == [1]) == true

62 ([1, 1, 2, 2] == [1, 1, 2, 2]) == true

63 ([1, 1, 2, 2] == [1.0, 1.0, 2.0, 2.0]) == true

public 8 Array#=== Misplaced Defined on `Kernel`.

Implementation candidates

===

Test 17. ruby/test/ruby/test_array.rb:test_VERY_EQUAL # '==='

64 ([] === []) == true

65 ([1] === [1]) == true

66 ([1, 1, 2, 2] === [1, 1, 2, 2]) == true

67 ([1, 1, 2, 2] === [1.0, 1.0, 2.0, 2.0]) == true

Missing Doc No paragraph given for user.

public 9 Array#[] (alias: slice)

Implementation candidates

[]

Usage (index) → Object | nilUsage (start, length) → Array | nilUsage (range) → Array | nil

Element Reference — Returns the element at index, or returns a subarray starting at the start index and continuing for length elements, or returns a subarray specified by range of indices.

Negative indices count backward from the end of the array (-1 is the last element). For start and range cases, the starting index is just before an element. Additionally, an empty array is returned when the starting index for an element range is at the end of the array.

Returns nil if the index (or starting index) are out of range.

a = ["a", "b", "c", "d", "e"]
a[2] +  a[0] + a[1]    #=> "cab"
a[6]                   #=> nil
a[1, 2]                #=> ["b", "c"]
a[1..3]                #=> ["b", "c", "d"]
a[4..7]                #=> ["e"]
a[6..10]               #=> nil
a[-3, 3]               #=> ["c", "d", "e"]
# special cases
a[5]                   #=> nil
a[6, 1]                #=> nil
a[5, 1]                #=> []
a[5..10]               #=> []

Test 18. ruby/test/ruby/test_array.rb:test_AREF # '[]'

Setup code

a = Array[*(1..100).to_a]

68 a[0] == 1

69 a[99] == 100

70 a[100].nil?

71 a[-1] == 100

72 a[-2] == 99

73 a[-100] == 1

74 a[-101].nil?

75 a[-101, 0].nil?

76 a[-101, 1].nil?

77 a[-101, -1].nil?

78 a[10, -1].nil?

79 a[0, 1] == [1]

80 a[99, 1] == [100]

81 a[100, 1] == []

82 a[99, 100] == [100]

83 a[-1, 1] == [100]

84 a[-2, 1] == [99]

85 a[-100, 0] == []

86 a[-100, 1] == [1]

87 a[9, 3] == [10, 11, 12]

88 a[-91, 3] == [10, 11, 12]

89 a[0..0] == [1]

90 a[99..99] == [100]

91 a[100..100] == []

92 a[99..200] == [100]

93 a[-1..-1] == [100]

94 a[-2..-2] == [99]

95 a[9..11] == [10, 11, 12]

96 a[-91..-89] == [10, 11, 12]

97 a[10, -3].nil?

98 a[10..7] == []

99 a["cat"].raise?(TypeError)

Test 19. ruby/test/ruby/test_array.rb:test_aref

100 [][0, 0, 0].raise?(ArgumentError)

Test 20. ruby/test/ruby/test_array.rb:test_0_literal:7/8

Setup code

x = [0, 1, 2, 3, 4, 5]

101 x[2] == 2

102 x[1..3] == [1, 2, 3]

103 x[1, 3] == [1, 2, 3]

Test 21. ruby/test/ruby/test_array.rb:test_slice_frozen_array

Setup code

a = [1,2,3,4,5]

104 a[0, 4] == [1, 2, 3, 4]

105 a[1, 4] == [2, 3, 4, 5]

public 10 Array#[]=

Implementation candidates

[]=

public 11 Array#assoc

Implementation candidates

assoc

public 12 Array#at

Implementation candidates

at

public 13 Array#bsearch

Implementation candidates

bsearch

Usage {|x| block} → Object

By using binary search, finds a value from this array which meets the given condition in O(log n) where n is the size of the array.

You can use this method in two use cases: a find-minimum mode and a find-any mode. In either case, the elements of the array must be monotone (or sorted) with respect to the block.

In find-minimum mode (this is a good choice for typical use case), the block must return true or false, and there must be an index i (0 <= i <= ary.size) so that:

the block returns false for any element whose index is less than i, and
the block returns true for any element whose index is greater than or equal to i.

This method returns the i-th element. If i is equal to ary.size, it returns nil.

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

In find-any mode (this behaves like libc’s bsearch(3)), the block must return a number, and there must be two indices i and j (0 <= i <= j <= ary.size) so that:

the block returns a positive number for ary if 0 <= k < i,
the block returns zero for ary if i <= k < j, and
the block returns a negative number for ary if j <= k < ary.size.

Under this condition, this method returns any element whose index is within i…j. If i is equal to j (i.e., there is no element that satisfies the block), this method returns nil.

ary = [0, 4, 7, 10, 12]
# try to find v such that 4 <= v < 8
ary.bsearch{|x| 1 - x / 4} #=> 4 or 7
# try to find v such that 8 <= v < 10
ary.bsearch{|x| 4 - x / 2} #=> nil

You must not mix the two modes at a time; the block must always return either true/false, or always return a number. It is undefined which value is actually picked up at each iteration.

Test 27. ruby/test/ruby/test_array.rb:test_bsearch_typechecks_return_values

161 [1, 2, 42, 100, 666].bsearch{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:651)}.raise?(TypeError)

162 [1, 2, 42, 100, 666].bsearch{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:652)} == nil

Test 28. ruby/test/ruby/test_array.rb:test_bsearch_with_no_block

163 [1, 2, 42, 100, 666].bsearch.succeed?

164 RETURN.size.nil?

165 RETURN.each{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:656)} == 42

Test 29. ruby/test/ruby/test_array.rb:test_bsearch_in_find_minimum_mode

Setup code

a = [0, 4, 7, 10, 12]

166 a.bsearch{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:659)} == 4

167 a.bsearch{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:660)} == 7

168 a.bsearch{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:661)}.zero?

169 a.bsearch{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:662)}.nil?

Test 30. ruby/test/ruby/test_array.rb:test_bsearch_in_find_any_mode

Setup code

a = [0, 4, 7, 10, 12]

170 a.bsearch{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:665)}.in?([4, 7])

171 a.bsearch{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:666)}.nil?

172 a.bsearch{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:667)}.nil?

173 a.bsearch{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:668)}.nil?

174 a.bsearch{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:669)}.in?([4, 7])

175 a.bsearch{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:670)}.nil?

176 a.bsearch{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:671)}.nil?

177 a.bsearch{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:672)}.in?([4, 7])

public 14 Array#clear

Implementation candidates

clear

Usage → Array

Removes all elements from self.

a = ["a", "b", "c", "d", "e"]
a.clear    #=> []

Test 31. ruby/test/ruby/test_array.rb:test_clear2

178 ([0] * 1024).clear == []

Test 32. ruby/test/ruby/test_array.rb:test_clear

Setup code

a = Array[1, 2, 3]

179 a.clear == []

180 RECEIVER == []

181 RECEIVER == a

public 15 Array#collect (alias: map)

Implementation candidates

collect

See also Enumerable#collect.

Usage {|item| block} → Array

Invokes the given block once for each element of self.

Creates a new array containing the values returned by the block.

Usage → Enumerator

a = ["a", "b", "c", "d"]
a.collect{|x| x + "!"}         #=> ["a!", "b!", "c!", "d!"]
a.map.with_index{|x, i| x * i} #=> ["", "b", "cc", "ddd"]
a                              #=> ["a", "b", "c", "d"]

Missing test Not unit tested.

public 16 Array#collect! (alias: map!)

Implementation candidates

collect!

See also Enumerable#collect.

Usage {|item| block} → Array

Invokes the given block once for each element of self, replacing the element with the value returned by the block.

Usage → Enumerator

a = ["a", "b", "c", "d"]
a.map!{|x| x + "!"}
a #=>  ["a!", "b!", "c!", "d!"]
a.collect!.with_index{|x, i| x[0...i]}
a #=>  ["", "b", "c!", "d!"]

Missing test Not unit tested.

public 17 Array#combination

Implementation candidates

combination

Usage (n){|c| block} → Array

When invoked with a block, yields all combinations of length n of elements from the array and then returns the array itself.

The implementation makes no guarantees about the order in which the combinations are yielded.

Usage (n) → Enumerator

Examples:

a = [1, 2, 3, 4]
a.combination(1).to_a  #=> [[1],[2],[3],[4]]
a.combination(2).to_a  #=> [[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]]
a.combination(3).to_a  #=> [[1,2,3],[1,2,4],[1,3,4],[2,3,4]]
a.combination(4).to_a  #=> [[1,2,3,4]]
a.combination(0).to_a  #=> [[]] # one combination of length 0
a.combination(5).to_a  #=> []   # no combinations of length 5

Test 33. ruby/test/ruby/test_array.rb:test_combination

182 [1, 2, 3, 4].combination(0).to_a == [[]]

183 [1, 2, 3, 4].combination(1).to_a == [[1], [2], [3], [4]]

184 [1, 2, 3, 4].combination(2).to_a == [[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]

185 [1, 2, 3, 4].combination(3).to_a == [[1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4]]

186 [1, 2, 3, 4].combination(4).to_a == [[1, 2, 3, 4]]

187 [1, 2, 3, 4].combination(5).to_a == []

Test 34. ruby/test/ruby/test_array.rb:test_combination2

Test 34.1. ruby-core:29240 Must be yielded even if 100C50 > signed integer

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100].combination(50){(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:739)} == :called

combination: LocalJumpError. Break from proc-closure.
spec:739

public 18 Array#compact

Implementation candidates

compact

Usage → Array

Returns a copy of self with all nil elements removed.

["a", nil, "b", nil, "c", nil].compact
                  #=> ["a", "b", "c"]

Test 35. ruby/test/ruby/test_array.rb:test_compact_0:1/2

188 [nil, 1, nil, nil, 5, nil, nil].compact == [1, 5]

189 RECEIVER == [nil, 1, nil, nil, 5, nil, nil]

Test 36. ruby/test/ruby/test_array.rb:test_compact

190 [1, nil, nil, 2, 3, nil, 4].compact == [1, 2, 3, 4]

191 [nil, 1, nil, 2, 3, nil, 4].compact == [1, 2, 3, 4]

192 [1, nil, nil, 2, 3, nil, 4, nil].compact == [1, 2, 3, 4]

193 [1, 2, 3, 4].compact == [1, 2, 3, 4]

public 19 Array#compact!

Implementation candidates

compact!

Usage → Array | nil

Removes nil elements from the array.

Returns nil if no changes were made, otherwise returns the array.

["a", nil, "b", nil, "c"].compact! #=> ["a", "b", "c"]
["a", "b", "c"].compact!           #=> nil

Test 37. ruby/test/ruby/test_array.rb:test_compact!

194 [1, nil, nil, 2, 3, nil, 4].compact! == [1, 2, 3, 4]

195 RECEIVER == [1, 2, 3, 4]

196 [nil, 1, nil, 2, 3, nil, 4].compact! == [1, 2, 3, 4]

197 RECEIVER == [1, 2, 3, 4]

198 [1, nil, nil, 2, 3, nil, 4, nil].compact! == [1, 2, 3, 4]

199 RECEIVER == [1, 2, 3, 4]

200 [1, 2, 3, 4].compact!.nil?

201 RECEIVER == [1, 2, 3, 4]

Test 38. ruby/test/ruby/test_array.rb:test_compact_0:2/2

202 [nil, 1, nil, nil, 5, nil, nil].compact!.succeed?

203 RECEIVER == [1, 5]

public 20 Array#concat

Implementation candidates

concat

public 21 Array#count

Implementation candidates

count

Usage (count) → Integer

Returns the number of elements.

Usage (obj) → Integer

Counts the number of elements which equal obj using ==.

Usage {|item| block} → Integer

Counts the number of elements for which the block returns a true value.

ary = [1, 2, 4, 2]
ary.count               #=> 4
ary.count(2)            #=> 2
ary.count{|x| (x % 2).zero?} #=> 3

Missing test Not unit tested.

public 22 Array#cycle

Implementation candidates

cycle

Usage (n=nil){|obj| block} → NilClass

Calls the given block for each element n times or forever if nil is given.

Does nothing if a non-positive number is given or the array is empty.

Returns nil if the loop has finished without getting interrupted.

Usage (n=nil) → Enumerator

a = ["a", "b", "c"]
a.cycle{|x| puts x}     # print, a, b, c, a, b, c,.. forever.
a.cycle(2){|x| puts x}  # print, a, b, c, a, b, c.

Missing test Not unit tested.

public 23 Array#delete

Implementation candidates

delete

Usage (obj) → Object | nil

Deletes all items from self that are equal to obj.

Returns the last deleted item, or nil if no matching item is found.

Usage (obj){block} → Object

The result of the block is returned if the item is not found. (To remove nil elements and get an informative return value, use #compact!)

a = ["a", "b", "b", "b", "c"]
a.delete("b")                #=> "b"
a                            #=> ["a", "c"]
a.delete("z")                #=> nil
a.delete("z"){"not found"}   #=> "not found"

Test 40. ruby/test/ruby/test_array.rb:test_delete

213 Array[*("cab".."cat").to_a].delete("cap") == "cap"

214 RECEIVER == Array[*("cab".."cao").to_a] + Array[*("caq".."cat").to_a]

215 Array[*("cab".."cat").to_a].delete("cab") == "cab"

216 RECEIVER == Array[*("cac".."cat").to_a]

217 Array[*("cab".."cat").to_a].delete("cat") == "cat"

218 RECEIVER == Array[*("cab".."cas").to_a]

219 Array[*("cab".."cat").to_a].delete("cup").nil?

220 RECEIVER == Array[*("cab".."cat").to_a]

221 Array[*("cab".."cat").to_a].delete("cup"){(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:848)} == 99

222 RECEIVER == Array[*("cab".."cat").to_a]

Setup code

o = Object.new
def o.==(other); true; end
o2 = Object.new
def o2.==(other); true; end

223 Array[1, o, o2, 2].delete(42) == o2

224 RECEIVER == [1, 2]

public 24 Array#delete_at

Implementation candidates

delete_at

public 25 Array#delete_if

Implementation candidates

delete_if

public 26 Array#drop

Implementation candidates

drop

public 27 Array#drop_while

Implementation candidates

drop_while

public 28 Array#each

Implementation candidates

each

Usage {|item| block} → Array

Calls the given block once for each element in self, passing that element as a parameter.

Usage → Enumerator

a = ["a", "b", "c"]
a.each{|x| print x, " -- "}

produces:

a -- b -- c --

Missing test Not unit tested.

public 29 Array#each_index

Implementation candidates

each_index

Usage {|index| block} → Array

Same as #each, but passes the index of the element instead of the element itself.

Usage → Enumerator

a = ["a", "b", "c"]
a.each_index{|x| print x, " -- "}

produces:

0 -- 1 -- 2 --

Missing test Not unit tested.

public 30 Array#empty?

Implementation candidates

empty?

Usage → true | false

Returns true if self contains no elements.

[].empty?   #=> true

Test 44. ruby/test/ruby/test_array.rb:test_empty_0

242 [].empty? == true

243 [1].empty? == false

244 [1, 1, 4, 2, 5, 4, 5, 1, 2].empty? == false

Test 45. ruby/test/ruby/test_array.rb:test_empty?

245 [].empty? == true

246 [1].empty? == false

public 31 Array#eql?

Implementation candidates

eql?

Usage (other) → true | false

Returns true if self and other are the same object, or are both arrays with the same content (according to Object#eql?).

Test 46. ruby/test/ruby/test_array.rb:test_eql?

247 [].eql?([]) == true

248 [1].eql?([1]) == true

249 [1, 1, 2, 2].eql?([1, 1, 2, 2]) == true

250 [1, 1, 2, 2].eql?([1.0, 1.0, 2.0, 2.0]) == false

public 32 Array#fetch

Implementation candidates

fetch

Usage (index) → Object

Tries to return the element at position index, but throws an IndexError exception if the referenced index lies outside of the array bounds.

Usage (index, default) → Object

This error is prevented by the default, which will act as a default value.

Usage (index){|index| block} → Object

It will only be executed when an invalid index is referenced. Negative values of index count from the end of the array.

a = [11, 22, 33, 44]
a.fetch(1)               #=> 22
a.fetch(-1)              #=> 44
a.fetch(4, "cat")        #=> "cat"
a.fetch(100){|i| puts "\#\{i\} is out of bounds"}
                         #=> "100 is out of bounds"

Test 47. ruby/test/ruby/test_array.rb:test_fetch

251 [].fetch(0, 0){(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:995)} == 1

252 [0, 1].fetch(-1) == 1

253 [0, 1].fetch(2).raise?(IndexError)

254 [0, 1].fetch(-3).raise?(IndexError)

255 [0, 1].fetch(2, 2) == 2

public 33 Array#fill

Implementation candidates

fill

Usage (obj) → ArrayUsage (obj, start [, length]) → ArrayUsage (obj, range) → Array

Sets the selected elements of self (which may be the entire array) to obj.

A start of nil is equivalent to zero.

A length of nil is equivalent to the length of the array.

Negative values of start count from the end of the array, where -1 is the last element.

Usage {|index| block} → ArrayUsage (start [, length]){|index| block} → ArrayUsage (range){|index| block} → Array

Fills the array with the value of the given block, which is passed the absolute index of each element to be filled.

a = ["a", "b", "c", "d"]
a.fill("x")           #=> ["x", "x", "x", "x"]
a.fill("z", 2, 2)     #=> ["x", "x", "z", "z"]
a.fill("y", 0..1)     #=> ["y", "y", "z", "z"]
a.fill{|i| i*i}       #=> [0, 1, 4, 9]
a.fill(-2){|i| i*i*i} #=> [0, 1, 8, 27]

Test 48. ruby/test/ruby/test_array.rb:test_fill

256 [].fill(99) == []

257 [].fill(99, 0) == []

258 [].fill(99, 0, 1) == [99]

259 [].fill(99, 0..0) == [99]

260 [1].fill(99) == [99]

261 [1].fill(99, 0) == [99]

262 [1].fill(99, 0, 1) == [99]

263 [1].fill(99, 0..0) == [99]

264 [1, 2].fill(99) == [99, 99]

265 [1, 2].fill(99, 0) == [99, 99]

266 [1, 2].fill(99, nil) == [99, 99]

267 [1, 2].fill(99, 1, nil) == [1, 99]

268 [1, 2].fill(99, 0, 1) == [99, 2]

269 [1, 2].fill(99, 0..0) == [99, 2]

Test 49. ruby/test/ruby/test_array.rb:test_fill_0

270 [0, 1, 2, 3, 4, 5].fill(-1) == [-1, -1, -1, -1, -1, -1]

271 [0, 1, 2, 3, 4, 5].fill(-1, 3) == [0, 1, 2, -1, -1, -1]

272 [0, 1, 2, 3, 4, 5].fill(-1, 3, 2) == [0, 1, 2, -1, -1, 5]

273 [0, 1, 2, 3, 4, 5].fill(-1, 3, 5) == [0, 1, 2, -1, -1, -1, -1, -1]

274 [0, 1, 2, 3, 4, 5].fill(-1, 2, 2) == [0, 1, -1, -1, 4, 5]

275 [0, 1, 2, 3, 4, 5].fill(-1, 2, 5) == [0, 1, -1, -1, -1, -1, -1]

276 [0, 1, 2, 3, 4, 5].fill(-1, -2, 1) == [0, 1, 2, 3, -1, 5]

277 [0, 1, 2, 3, 4, 5].fill(-1, -2, 3) == [0, 1, 2, 3, -1, -1, -1]

278 [0, 1, 2, 3, 4, 5].fill(-1, 3..4) == [0, 1, 2, -1, -1, 5]

279 [0, 1, 2, 3, 4, 5].fill(-1, 3...4) == [0, 1, 2, -1, 4, 5]

280 [0, 1, 2, 3, 4, 5].fill(-1, 2..-2) == [0, 1, -1, -1, -1, 5]

281 [0, 1, 2, 3, 4, 5].fill(-1, 2...-2) == [0, 1, -1, -1, 4, 5]

282 [0, 1, 2, 3, 4, 5].fill{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:1049)} == [10, 11, 12, 13, 14, 15]

283 [0, 1, 2, 3, 4, 5].fill(3){(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:1050)} == [0, 1, 2, 13, 14, 15]

284

[0, 1, 2, 3, 4, 5].fill(3, 2){(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:1051)} == [0, 1, 2, 13, 14, 5]

285

[0, 1, 2, 3, 4, 5].fill(3, 5){(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:1052)} == [0, 1, 2, 13, 14, 15, 16, 17]

286

[0, 1, 2, 3, 4, 5].fill(3..4){(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:1053)} == [0, 1, 2, 13, 14, 5]

287

[0, 1, 2, 3, 4, 5].fill(3...4){(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:1054)} == [0, 1, 2, 13, 4, 5]

288

[0, 1, 2, 3, 4, 5].fill(2..-2){(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:1055)} == [0, 1, 12, 13, 14, 5]

289

[0, 1, 2, 3, 4, 5].fill(2...-2){(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:1056)} == [0, 1, 12, 13, 4, 5]

Test 50. ruby/test/ruby/test_array.rb:test_fill2

290 [].fill(0, 1, longp).raise?(ArgumentError)

public 34 Array#find_index (alias: index)

Implementation candidates

find_index

public 35 Array#first

Implementation candidates

first

See also #last for the opposite effect.

Usage first → Object | nil

Returns the first element of the array. If the array is empty, returns nil.

Usage (n) → Array

Returns the first n elements of the array. If the array is empty, returns an empty array.

a = ["q", "r", "s", "t"]
a.first     #=> "q"
a.first(2)  #=> ["q", "r"]

Test 51. ruby/test/ruby/test_array.rb:test_first

291 [3, 4, 5].first == 3

292 [].first.nil?

Test 52. ruby/test/ruby/test_array.rb:test_first2

293 [0].first(2) == [0]

294 [0].first(-1).raise?(ArgumentError)

Test 53. ruby/test/ruby/test_array.rb:test_beg_end_0:1/6

Setup code

x = [1, 2, 3, 4, 5]

295 x.first == 1

296 x.first(1) == [1]

297 x.first(3) == [1, 2, 3]

public 36 Array#flatten

Implementation candidates

flatten

Usage → Array

Returns a new array that is a one-dimensional flattening of self (recursively). That is, for every element that is an array, extract its elements into the new array.

Usage (level) → Array

The optional level argument determines the level of recursion to flatten.

s = [1, 2, 3]           #=> [1, 2, 3]
t = [4, 5, 6, [7, 8]]   #=> [4, 5, 6, [7, 8]]
a = [s, t, 9, 10]       #=> [[1, 2, 3], [4, 5, 6, [7, 8]], 9, 10]
a.flatten               #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
a = [1, 2, [3, [4, 5]]]
a.flatten(1)            #=> [1, 2, 3, [4, 5]]

Test 54. ruby/test/ruby/test_array.rb:test_flatten

Setup code

a1 = Array[1, 2, 3]
a3 = Array[4, Array[5, 6]]

298 Array[a1, a3].flatten == [1, 2, 3, 4, 5, 6]

299 RECEIVER == Array[a1, a3]

300 Array[a1, Array[], a3].flatten == [1, 2, 3, 4, 5, 6]

301 [].flatten == []

302 [[[[], []], [[]], []], [[[]]]].flatten == []

Test 54.1. ruby-dev:31197

303 [[]].flatten("").raise?(TypeError)

Setup code

a6 = Array[[1, 2], 3]
a6.taint
a8 = Array[[1, 2], 3]

304 a6.flatten.tainted?

305 a8.flatten(0) == a8

306 RETURN.equal?(a8).!

public 37 Array#flatten!

Implementation candidates

flatten!

Usage → Array | nil

Flattens self in place. Returns nil if no modifications were made (i.e., the array contains no subarrays.

Usage (level) → Array | nil

The optional level argument determines the level of recursion to flatten.

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

Test 55. ruby/test/ruby/test_array.rb:test_flatten!

Setup code

a1 = Array[1, 2, 3]
a3 = Array[4, Array[5, 6]]
a5 = Array[a1, Array[], a3]

307 Array[a1, a3].flatten! == [1, 2, 3, 4, 5, 6]

308 RECEIVER == [1, 2, 3, 4, 5, 6]

Test 55.1. ruby-core:23382

309 a5.flatten! == [1, 2, 3, 4, 5, 6]

310 a5.flatten!(0).nil?

3 RECEIVER == [1, 2, 3, 4, 5, 6]

flatten!: The receiver of verification == is [[1, 2, 3], [], [4, [5, 6]]].

311 [].flatten!.nil?

312 [[[[], []], [[]], []], [[[]]]].flatten! == []

Test 55.2. ruby-core:23382

313 [].flatten!(0).nil?

public 38 Array#frozen?

Implementation candidates

frozen?

public 39 Array#hash

Implementation candidates

hash

Usage → Fixnum

Computes a hash-code for this array. Two arrays with the same content will have the same hash code (and will compare using eql?).

Test 56. ruby/test/ruby/test_array.rb:test_hash

314 ["cat", "dog"].hash == Array["cat", "dog"].hash

4 ["dog", "cat"].hash == Array["cat", "dog"].hash

hash: The receiver of verification == is -67794575767490625.

Test 56.1. bug9231 = ruby-core:58993 Bug #9231

315 [].hash != false.hash

Test 57. ruby/test/ruby/test_array.rb:test_0_literal:3/8

316 [1, 2].hash == [1, 2].hash

public 40 Array#include?

Implementation candidates

include?

Usage (object) → true | false

Returns true if the given object is present in self (that is, if any element == object), otherwise returns false.

a = ["a", "b", "c"]
a.include?("b")   #=> true
a.include?("z")   #=> false

Test 58. ruby/test/ruby/test_array.rb:test_include?

Setup code

a = Array["cat", 99, /a/, Array[1, 2, 3]]

317 a.include?("cat") == true

318 a.include?(99) == true

319 a.include?(/a/) == true

320 a.include?([1, 2, 3]) == true

321 a.include?("ca") == false

322 a.include?([1, 2]) == false

public 41 Array#index

Implementation candidates

index

private 42 Array#initialize_copy

Implementation candidates

initialize_copy

Usage (other_ary) → Array

Replaces the contents of self with the contents of other_ary, truncating or expanding if necessary.

a = ["a", "b", "c", "d", "e"]
a.replace(["x", "y", "z"])   #=> ["x", "y", "z"]
a                            #=> ["x", "y", "z"]

Missing test Not unit tested.

public 43 Array#insert

Implementation candidates

insert

Usage (index, obj...) → Array

Inserts the given values before the element with the given index.

Negative indices count backwards from the end of the array, where -1 is the last element.

a = %w{a b c d}
a.insert(2, 99)         #=> ["a", "b", 99, "c", "d"]
a.insert(-2, 1, 2, 3)   #=> ["a", "b", 99, "c", 1, 2, 3, "d"]

Missing test Not unit tested.

public 44 Array#inspect (alias: to_s)

Implementation candidates

inspect

Also aliased as: to_s

Usage → String

Creates a string representation of self.

["a", "b", "c"].to_s     #=> "[\"a\", \"b\", \"c\"]"

Missing test Not unit tested.

public 45 Array#join

Implementation candidates

join

Usage (separator=$,) → String

Returns a string created by converting each element of the array to a string, separated by the given separator. If the separator is nil, it uses current $,. If both the separator and $, are nil, it uses empty string.

["a", "b", "c"].join        #=> "abc"
["a", "b", "c"].join("-")   #=> "a-b-c"

Test 60. ruby/test/ruby/test_array.rb:test_join

Setup code

$, = ""
a = Array[]

329 a.join == ""

330 a.join(",") == ""

331 a.join.encoding == #<Encoding:US-ASCII>

Setup code

$, = ""
a = Array[1, 2]

332 a.join == "12"

333 a.join(nil) == "12"

334 a.join(",") == "1,2"

Setup code

$, = ""
a = Array[1, 2, 3]

335 a.join == "123"

336 a.join(nil) == "123"

337 a.join(",") == "1,2,3"

Setup code

$, = ":"
a = Array[1, 2, 3]

338 a.join == "1:2:3"

339 a.join(nil) == "1:2:3"

340 a.join(",") == "1,2,3"

Setup code

$, = ""
a = Array[1, 2, 3]
a.taint

341 a.join.tainted?

Test 60.1. bug5902 ruby-core:42161

Setup code

sep = ":".taint

342 [].join(sep).tainted? == false

343 [1].join(sep).tainted? == false

344 [1, 2].join(sep).tainted?

Setup code

e = "".force_encoding("EUC-JP")
u = "".force_encoding("UTF-8")

345 [[]].join.encoding == #<Encoding:US-ASCII>

346 [1, [u]].join.encoding == #<Encoding:US-ASCII>

347 [u, [e]].join.encoding == #<Encoding:UTF-8>

348 [u, [1]].join.encoding == #<Encoding:UTF-8>

Test 60.2. bug5379 ruby-core:39776

349 [[], u, nil].join.encoding == #<Encoding:US-ASCII>

350 [[], "あ", nil].join.encoding == #<Encoding:UTF-8>

Setup code

$, = nil

public 46 Array#keep_if

Implementation candidates

keep_if

public 47 Array#last

Implementation candidates

last

See also #first for the opposite effect.

Usage → Object | nil

Returns the last element of self. If the array is empty, returns nil.

Usage (n) → Array

Returns the last element(s) of self.

a = ["w", "x", "y", "z"]
a.last     #=> "z"
a.last(2)  #=> ["y", "z"]

Test 61. ruby/test/ruby/test_array.rb:test_last

351 [].last.nil?

352 [1].last == 1

Setup code

a = Array[*(3..99).to_a]

353 a.last == 99

Test 62. ruby/test/ruby/test_array.rb:test_beg_end_0:2/6

Setup code

x = [1, 2, 3, 4, 5]

354 x.last == 5

355 x.last(1) == [5]

356 x.last(3) == [3, 4, 5]

public 48 Array#length (alias: size)

Implementation candidates

length

Also aliased as: size

Usage → Integer

Returns the number of elements in self. May be zero.

[1, 2, 3, 4, 5].length   #=> 5
[].length                #=> 0

Test 63. ruby/test/ruby/test_array.rb:test_length

357 [].length.zero?

358 [1].length == 1

359 [1, nil].length == 2

360 [nil, 1].length == 2

361 Array[*(0..233).to_a].length == 234

public 49 Array#map

Implementation candidates

map

See also Enumerable#collect.

Usage {|item| block} → Array

Invokes the given block once for each element of self.

Creates a new array containing the values returned by the block.

Usage → Enumerator

a = ["a", "b", "c", "d"]
a.collect{|x| x + "!"}         #=> ["a!", "b!", "c!", "d!"]
a.map.with_index{|x, i| x * i} #=> ["", "b", "cc", "ddd"]
a                              #=> ["a", "b", "c", "d"]

Test 64. ruby/test/ruby/test_array.rb:test_collect

362 [1, "cat", 1..1].map{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:1365)} == [Fixnum, String, Range]

363 [1, "cat", 1..1].map{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:1366)} == [99, 99, 99]

364 [].map{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:1367)} == []

365 [1, 2, 3].map.kind_of?(Enumerator)

public 50 Array#map!

Implementation candidates

map!

See also Enumerable#collect.

Usage {|item| block} → Array

Invokes the given block once for each element of self, replacing the element with the value returned by the block.

Usage → Enumerator

a = ["a", "b", "c", "d"]
a.map!{|x| x + "!"}
a #=>  ["a!", "b!", "c!", "d!"]
a.collect!.with_index{|x, i| x[0...i]}
a #=>  ["", "b", "c!", "d!"]

Test 65. ruby/test/ruby/test_array.rb:test_collect!

366 [1, "cat", 1..1].map!{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:1383)} == [Fixnum, String, Range]

367 RECEIVER == [Fixnum, String, Range]

368 [1, "cat", 1..1].map!{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:1385)} == [99, 99, 99]

369 RECEIVER == [99, 99, 99]

370 [].map!{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:1387)} == []

371 RECEIVER == []

Test 66. ruby/test/ruby/test_array.rb:test_map!

372 [1, "cat", 1..1].map!{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:1390)} == [Fixnum, String, Range]

373 RECEIVER == [Fixnum, String, Range]

374 [1, "cat", 1..1].map!{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:1392)} == [99, 99, 99]

375 RECEIVER == [99, 99, 99]

376 [].map!{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:1394)} == []

377 RECEIVER == []

public 51 Array#pack

Implementation candidates

pack

public 52 Array#permutation

Implementation candidates

permutation

The implementation makes no guarantees about the order in which the permutations are yielded.

Usage (n){|p| block} → Array

Yields all permutations of length n of the elements of the array, then return the array itself.

Usage {|p| block} → Array

Yields all permutations of all elements.

Usage (n) → EnumeratorUsage → Enumerator

Examples:

a = [1, 2, 3]
a.permutation.to_a    #=> [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
a.permutation(1).to_a #=> [[1],[2],[3]]
a.permutation(2).to_a #=> [[1,2],[1,3],[2,1],[2,3],[3,1],[3,2]]
a.permutation(3).to_a #=> [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
a.permutation(0).to_a #=> [[]] # one permutation of length 0
a.permutation(4).to_a #=> []   # no permutations of length 4

Test 68. ruby/test/ruby/test_array.rb:test_permutation

Setup code

a = Array[1,2,3]

404 a.permutation(0).to_a == [[]]

405 a.permutation(1).to_a.sort == [[1], [2], [3]]

406 a.permutation(2).to_a.sort == [[1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2]]

407 a.permutation(3).sort.to_a == [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]

408 a.permutation(4).to_a == []

409 a.permutation(-1).to_a == []

Setup code

a = "edcba".each_char.to_a

410 a.permutation(5).sort == 'abcde'.each_char.to_a.permutation(5).sort

411 [].permutation(0).to_a == [[]]

Setup code

a = Array[1, 2, 3, 4]
b = Array[]

13 a.permutation{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:1649)} == [9, 8, 7, 6]

permutation: The receiver of verification == is [1, 2, 3, 4].

14 [1, 2, 3, 4].permutation.to_a == b

permutation: The receiver of verification == is [[1, 2, 3, 4], [1, 2, 4, 3], [1, 3, 2, 4], [1, 3, 4, 2], [1, 4, 2, 3], [1, 4, 3, 2], [2, 1, 3, 4], [2, 1, 4, 3], [2, 3, 1, 4], [2, 3, 4, 1], [2, 4, 1, 3], [2, 4, 3, 1], [3, 1, 2, 4], [3, 1, 4, 2], [3, 2, 1, 4], [3, 2, 4, 1], [3, 4, 1, 2], [3, 4, 2, 1], [4, 1, 2, 3], [4, 1, 3, 2], [4, 2, 1, 3], [4, 2, 3, 1], [4, 3, 1, 2], [4, 3, 2, 1]].

Test 68.1. bug3708 ruby-dev:42067

15 [1, 2, 3, 4].permutation.to_a == b

permutation: The receiver of verification == is [[1, 2, 3, 4], [1, 2, 4, 3], [1, 3, 2, 4], [1, 3, 4, 2], [1, 4, 2, 3], [1, 4, 3, 2], [2, 1, 3, 4], [2, 1, 4, 3], [2, 3, 1, 4], [2, 3, 4, 1], [2, 4, 1, 3], [2, 4, 3, 1], [3, 1, 2, 4], [3, 1, 4, 2], [3, 2, 1, 4], [3, 2, 4, 1], [3, 4, 1, 2], [3, 4, 2, 1], [4, 1, 2, 3], [4, 1, 3, 2], [4, 2, 1, 3], [4, 2, 3, 1], [4, 3, 1, 2], [4, 3, 2, 1]].

Test 69. bug9932 ruby-core:63103 Bug #9932

public 53 Array#pop

Implementation candidates

pop

See also #push for the opposite effect.

Usage → Object | nil

Removes the last element from self and returns it, or nil if the array is empty.

Usage (n) → Array

Returns an array of the last n elements (or less) just like array.slice!(-n, n) does.

a = ["a", "b", "c", "d"]
a.pop     #=> "d"
a.pop(2)  #=> ["b", "c"]
a         #=> ["a"]

Test 70. ruby/test/ruby/test_array.rb:test_pop

Setup code

a = Array["cat", "dog"]

412 a.pop == "dog"

413 RECEIVER == ["cat"]

16 a.pop == "cat"

pop: The receiver of verification == is "dog".

17 RECEIVER == []

pop: The receiver of verification == is ["cat"].

18 a.pop.nil?

pop: The receiver of verification nil? is "dog".

19 RECEIVER == []

pop: The receiver of verification == is ["cat"].

Test 71. ruby/test/ruby/test_array.rb:test_beg_end_0:5/6

Setup code

x = [1, 2, 3, 4, 5]

414 x.pop == 5

20 x.pop(2) == [3, 4]

pop: The receiver of verification == is [4, 5].

21 RECEIVER == [1, 2]

pop: The receiver of verification == is [1, 2, 3].

public 54 Array#product

Implementation candidates

product

Usage (other_ary, ...) → Array

Returns an array of all combinations of elements from all arrays.

The length of the returned array is the product of the length of self and the argument arrays.

Usage (other_ary, ...){|p| block} → Array

Product will yield all combinations and return self.

[1,2,3].product([4,5])     #=> [[1,4],[1,5],[2,4],[2,5],[3,4],[3,5]]
[1,2].product([1,2])       #=> [[1,1],[1,2],[2,1],[2,2]]
[1,2].product([3,4],[5,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]]
[1,2].product()            #=> [[1],[2]]
[1,2].product([])          #=> []

Test 72. ruby/test/ruby/test_array.rb:test_product

415 [1, 2, 3].product([4, 5]) == [[1, 4], [1, 5], [2, 4], [2, 5], [3, 4], [3, 5]]

416 [1, 2].product([1, 2]) == [[1, 1], [1, 2], [2, 1], [2, 2]]

417

[1, 2].product([3, 4], [5, 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]]

418 [1, 2].product == [[1], [2]]

419 [1, 2].product([]) == []

Test 72.1. bug3394 = ruby-dev:41540

public 55 Array#push

Implementation candidates

push

See also #pop for the opposite effect.

Usage (obj, ...) → Array

Append — Pushes the given object(s) on to the end of this array. This expression returns the array itself, so several appends may be chained together.

a = ["a", "b", "c"]
a.push("d", "e", "f")
        #=> ["a", "b", "c", "d", "e", "f"]
[1, 2, 3,].push(4).push(5)
        #=> [1, 2, 3, 4, 5]

Test 73. ruby/test/ruby/test_array.rb:test_push

Setup code

a = Array[1, 2, 3]

420 a.push(4, 5) == [1, 2, 3, 4, 5]

22 a.push(nil) == [1, 2, 3, 4, 5, nil]

push: The receiver of verification == is [1, 2, 3, nil].

421 a.push.succeed?

23 RECEIVER == [1, 2, 3, 4, 5, nil]

push: The receiver of verification == is [1, 2, 3].

422 a.push(6, 7).succeed?

24 RECEIVER == [1, 2, 3, 4, 5, nil, 6, 7]

push: The receiver of verification == is [1, 2, 3, 6, 7].

Test 74. ruby/test/ruby/test_array.rb:test_beg_end_0:6/6

Setup code

x = [1, 2]

423 x.push(3, 4) == [1, 2, 3, 4]

25 x.push(5) == [1, 2, 3, 4, 5]

push: The receiver of verification == is [1, 2, 5].

26 RECEIVER == [1, 2, 3, 4, 5]

push: The receiver of verification == is [1, 2, 5].

public 56 Array#rassoc

Implementation candidates

rassoc

public 57 Array#reject

Implementation candidates

reject

public 58 Array#reject!

Implementation candidates

reject!

See also Enumerable#reject and #delete_if.

Usage {|item| block} → Array

Equivalent to #delete_if, deleting elements from self for which the block evaluates to true, but returns nil if no changes were made.

The array is changed instantly every time the block is called, not after the iteration is over.

Usage {|item| block} → NilClassUsage → Enumerator

Test 77. ruby/test/ruby/test_array.rb:test_reject!

430 [1, 2, 3, 4, 5].reject!{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:1788)}.nil?

431 RECEIVER == [1, 2, 3, 4, 5]

Setup code

a = Array[1, 2, 3, 4, 5]

432 a.reject!{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:1791)} == a

433 RECEIVER == []

Setup code

a = Array[1, 2, 3, 4, 5]

434 a.reject!{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:1794)} == a

435 RECEIVER == [1, 2, 3]

Test 77.1. bug2545 ruby-core:27366

Setup code

a = Array[5, 6, 7, 8, 9, 10]

27 a.reject!{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:1798)} == 9

reject!: LocalJumpError. Break from proc-closure.
spec:1798

2 RECEIVER == [7, 8, 9, 10]

Missing a preceding successful unit test.

public 59 Array#repeated_combination

Implementation candidates

repeated_combination

Usage (n){|c| block} → Array

When invoked with a block, yields all repeated combinations of length n of elements from the array and then returns the array itself.

The implementation makes no guarantees about the order in which the repeated combinations are yielded.

Usage (n) → Enumerator

If no block is given, an Enumerator is returned instead.

Examples:

a = [1, 2, 3]
a.repeated_combination(1).to_a  #=> [[1], [2], [3]]
a.repeated_combination(2).to_a  #=> [[1,1],[1,2],[1,3],[2,2],[2,3],[3,3]]
a.repeated_combination(3).to_a  #=> [[1,1,1],[1,1,2],[1,1,3],[1,2,2],[1,2,3],
                                #    [1,3,3],[2,2,2],[2,2,3],[2,3,3],[3,3,3]]
a.repeated_combination(4).to_a  #=> [[1,1,1,1],[1,1,1,2],[1,1,1,3],[1,1,2,2],[1,1,2,3],
                                #    [1,1,3,3],[1,2,2,2],[1,2,2,3],[1,2,3,3],[1,3,3,3],
                                #    [2,2,2,2],[2,2,2,3],[2,2,3,3],[2,3,3,3],[3,3,3,3]]
a.repeated_combination(0).to_a  #=> [[]] # one combination of length 0

Missing test Not unit tested.

public 60 Array#repeated_permutation

Implementation candidates

repeated_permutation

Usage (n){|p| block} → Array

When invoked with a block, yield all repeated permutations of length n of the elements of the array, then return the array itself.

The implementation makes no guarantees about the order in which the repeated permutations are yielded.

Usage (n) → Enumerator

Examples:

a = [1, 2]
a.repeated_permutation(1).to_a  #=> [[1], [2]]
a.repeated_permutation(2).to_a  #=> [[1,1],[1,2],[2,1],[2,2]]
a.repeated_permutation(3).to_a  #=> [[1,1,1],[1,1,2],[1,2,1],[1,2,2],
                                #    [2,1,1],[2,1,2],[2,2,1],[2,2,2]]
a.repeated_permutation(0).to_a  #=> [[]] # one permutation of length 0

Missing test Not unit tested.

public 61 Array#replace (alias: initialize_copy)

Implementation candidates

replace

Usage (other_ary) → Array

Replaces the contents of self with the contents of other_ary, truncating or expanding if necessary.

a = ["a", "b", "c", "d", "e"]
a.replace(["x", "y", "z"])   #=> ["x", "y", "z"]
a                              #=> ["x", "y", "z"]

Test 78. ruby/test/ruby/test_array.rb:test_replace_shared_ary

Setup code

a = [1] * 100
b = []

1 b.replace(a)

Missing a verification.

436 a.replace([1, 2, 3]).succeed?

437 RECEIVER == [1, 2, 3]

public 62 Array#reverse

Implementation candidates

reverse

Usage → Array

Returns a new array containing self‘s elements in reverse order.

["a", "b", "c"].reverse   #=> ["c", "b", "a"]
[1].reverse               #=> [1]

Test 79. ruby/test/ruby/test_array.rb:test_reverse

438 ["dog", "cat", "bee", "ant"].reverse == ["ant", "bee", "cat", "dog"]

439 RECEIVER == ["dog", "cat", "bee", "ant"]

440 [].reverse == []

public 63 Array#reverse!

Implementation candidates

reverse!

Usage → Array

Reverses self in place.

a = ["a", "b", "c"]
a.reverse!       #=> ["c", "b", "a"]
a                #=> ["c", "b", "a"]

Test 80. ruby/test/ruby/test_array.rb:test_reverse!

441 ["dog", "cat", "bee", "ant"].reverse! == ["ant", "bee", "cat", "dog"]

442 RECEIVER == ["ant", "bee", "cat", "dog"]

Test 80.1. Array#reverse always returns self.

443 [].reverse! == []

public 64 Array#reverse_each

Implementation candidates

reverse_each

Usage {|item| block} → ArrayUsage → Enumerator

Same as #each, but traverses self in reverse order.

a = ["a", "b", "c"]
a.reverse_each{|x| print x, " "}

produces:

c b a

Missing test Not unit tested.

public 65 Array#rindex

Implementation candidates

rindex

public 66 Array#rotate

Implementation candidates

rotate

Usage (count=1) → Array

Returns a new array by rotating self so that the element at count is the first element of the new array.

If count is negative then it rotates in the opposite direction, starting from the end of self where -1 is the last element.

a = ["a", "b", "c", "d"]
a.rotate         #=> ["b", "c", "d", "a"]
a                #=> ["a", "b", "c", "d"]
a.rotate(2)      #=> ["c", "d", "a", "b"]
a.rotate(-3)     #=> ["b", "c", "d", "a"]

Test 81. ruby/test/ruby/test_array.rb:test_rotate

Setup code

a = [1,2,3,4,5]

444 a.rotate == [2, 3, 4, 5, 1]

445 a.rotate(-1) == [5, 1, 2, 3, 4]

446 a.rotate(2) == [3, 4, 5, 1, 2]

447 a.rotate(-2) == [4, 5, 1, 2, 3]

448 a.rotate(13) == [4, 5, 1, 2, 3]

449 a.rotate(-13) == [3, 4, 5, 1, 2]

Setup code

a = [1]

450 a.rotate == [1]

451 a.rotate(2) == [1]

452 a.rotate(-4) == [1]

453 a.rotate(13) == [1]

454 a.rotate(-13) == [1]

Setup code

a = []

455 a.rotate == []

456 a.rotate(2) == []

457 a.rotate(-4) == []

458 a.rotate(13) == []

459 a.rotate(-13) == []

460 [1, 2, 3].rotate(1, 1).raise?(ArgumentError)

461 [1, 2, 3, 4, 5].rotate(2147483647.9) == [3, 4, 5, 1, 2]

462 [1, 2, 3, 4, 5].rotate(-2147483648.9) == [3, 4, 5, 1, 2]

public 67 Array#rotate!

Implementation candidates

rotate!

Usage (count=1) → Array

Rotates self in place so that the element at count comes first, and returns self.

If count is negative, then it rotates in the opposite direction, starting from the end of the array where -1 is the last element.

a = ["a", "b", "c", "d"]
a.rotate!        #=> ["b", "c", "d", "a"]
a                #=> ["b", "c", "d", "a"]
a.rotate!(2)     #=> ["d", "a", "b", "c"]
a.rotate!(-3)    #=> ["a", "b", "c", "d"]

Test 82. ruby/test/ruby/test_array.rb:test_rotate!

Setup code

a = [1,2,3,4,5]

463 a.rotate! == [2, 3, 4, 5, 1]

464 RECEIVER == [2, 3, 4, 5, 1]

28 a.rotate!(2) == [4, 5, 1, 2, 3]

rotate!: The receiver of verification == is [3, 4, 5, 1, 2].

29 a.rotate!(-4) == [5, 1, 2, 3, 4]

rotate!: The receiver of verification == is [2, 3, 4, 5, 1].

30 a.rotate!(13) == [3, 4, 5, 1, 2]

rotate!: The receiver of verification == is [4, 5, 1, 2, 3].

31 a.rotate!(-13) == [5, 1, 2, 3, 4]

rotate!: The receiver of verification == is [3, 4, 5, 1, 2].

Setup code

a = [1]

465 a.rotate! == [1]

466 a.rotate!(2) == [1]

467 a.rotate!(-4) == [1]

468 a.rotate!(13) == [1]

469 a.rotate!(-13) == [1]

Setup code

a = []

470 a.rotate! == []

471 a.rotate!(2) == []

472 a.rotate!(-4) == []

473 a.rotate!(13) == []

474 a.rotate!(-13) == []

32 [].rotate!.raise?(RuntimeError, message: /can\'t modify frozen/)

rotate!: Did not raise an exception.

475 [1, 2, 3].rotate!(1, 1).raise?(ArgumentError)

public 68 Array#sample

Implementation candidates

sample

The elements are chosen by using random and unique indices into the array in order to ensure that an element doesn’t repeat itself unless the array already contained duplicate elements.

If the array is empty the first form returns nil and the second form returns an empty array.

Usage → Object

Chooses a random element from the array. If the array is empty,returns nil.

Usage (n) → Array

Chooses n random elements from the array. If the array is empty, returns an empty array.

Usage (random: rng) → ObjectUsage (n, random: rng) → Array

The optional rng argument will be used as the random number generator.

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

Missing test Not unit tested.

public 69 Array#select

Implementation candidates

select

public 70 Array#select!

Implementation candidates

select!

public 71 Array#shift

Implementation candidates

shift

See also #unshift for the opposite effect.

Usage → Object | nil

Removes the first element of self and returns it (shifting all other elements down by one). Returns nil if the array is empty.

Usage (n) → Array

Returns an array of the first n elements (or less) just like array.slice!(0, n) does. With ary containing only the remainder elements, not including what was shifted to new_ary.

args = ["-m", "-q", "filename"]
args.shift     #=> "-m"
args           #=> ["-q", "filename"]

args = ["-m", "-q", "filename"]
args.shift(2)  #=> ["-m", "-q"]
args           #=> ["filename"]

Test 84. ruby/test/ruby/test_array.rb:test_unshift_error

33 [].shift("cat").raise?(RuntimeError)

shift: TypeError. No implicit conversion of String into Integer.

34 [].shift.raise?(RuntimeError)

shift: Did not raise an exception.

Test 85. ruby/test/ruby/test_array.rb:test_beg_end_0:3/6

Setup code

x = [1, 2, 3, 4, 5]

477 x.shift == 1

35 x.shift(3) == [2, 3, 4]

shift: The receiver of verification == is [1, 2, 3].

36 RECEIVER == [5]

shift: The receiver of verification == is [4, 5].

public 72 Array#shuffle

Implementation candidates

shuffle

Usage → Array

Returns a new array with elements of self shuffled.

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

Usage (random: rng) → Array

The optional rng argument will be used as the random number generator.

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

Missing test Not unit tested.

public 73 Array#shuffle!

Implementation candidates

shuffle!

Usage → Array

Shuffles elements in self in place.

Usage (random: rng) → Array

The optional rng argument will be used as the random number generator.

Missing test Not unit tested.

public 74 Array#size Misplaced Defined as alias of `length`.

Implementation candidates

size

Alias for: length

Test 86. ruby/test/ruby/test_array.rb:test_size

478 [].size.zero?

479 [1].size == 1

480 Array[*(0..99).to_a].size == 100

Missing Doc No method signature given.

public 75 Array#slice

Implementation candidates

slice

Element Reference

Negative indices count backward from the end of the array (-1 is the last element).

Returns nil if the index (or starting index) are out of range.

Usage (index) → Object | nil

Returns the element at index.

Usage (start, length) → Array | nilUsage (range) → Array | nil

Returns a subarray starting at the start index and continuing for length elements, or a subarray specified by range of indices.

The starting index is just before an element.

An empty array is returned when the starting index for an element range is at the end of the array.

a = ["a", "b", "c", "d", "e"]
a[2] +  a[0] + a[1]    #=> "cab"
a[6]                   #=> nil
a[1, 2]                #=> ["b", "c"]
a[1..3]                #=> ["b", "c", "d"]
a[4..7]                #=> ["e"]
a[6..10]               #=> nil
a[-3, 3]               #=> ["c", "d", "e"]
# special cases
a[5]                   #=> nil
a[6, 1]                #=> nil
a[5, 1]                #=> []
a[5..10]               #=> []

Missing test Not unit tested.

public 76 Array#slice!

Implementation candidates

slice!

Returns the deleted object (or objects), or nil if the index is out of range.

Usage (index) → Object | nil

Deletes the element given by an index.

Usage (start, length) → Array | nilUsage (range) → Array | nil

Deletes the element(s) given by an index up to length elements or by range.

a = ["a", "b", "c"]
a.slice!(1)     #=> "b"
a               #=> ["a", "c"]
a.slice!(-1)    #=> "c"
a               #=> ["a"]
a.slice!(100)   #=> nil
a               #=> ["a"]

Test 87. ruby/test/ruby/test_array.rb:test_slice!

481 [1, 2, 3, 4, 5].slice!(2) == 3

482 RECEIVER == [1, 2, 4, 5]

483 [1, 2, 3, 4, 5].slice!(-2) == 4

484 RECEIVER == [1, 2, 3, 5]

485 [1, 2, 3, 4, 5].slice!(2, 2) == [3, 4]

486 RECEIVER == [1, 2, 5]

487 [1, 2, 3, 4, 5].slice!(-2, 2) == [4, 5]

488 RECEIVER == [1, 2, 3]

489 [1, 2, 3, 4, 5].slice!(2..3) == [3, 4]

490 RECEIVER == [1, 2, 5]

491 [1, 2, 3, 4, 5].slice!(20).nil?

492 RECEIVER == [1, 2, 3, 4, 5]

493 [1, 2, 3, 4, 5].slice!(-6).nil?

494 RECEIVER == [1, 2, 3, 4, 5]

495 [1, 2, 3, 4, 5].slice!(-6..4).nil?

496 RECEIVER == [1, 2, 3, 4, 5]

497 [1, 2, 3, 4, 5].slice!(-6, 2).nil?

498 RECEIVER == [1, 2, 3, 4, 5]

499 [1].slice!.raise?(ArgumentError)

500 [1].slice!(0, 0, 0).raise?(ArgumentError)

public 77 Array#sort

Implementation candidates

sort

public 78 Array#sort!

Implementation candidates

sort!

public 79 Array#sort_by!

Implementation candidates

sort_by!

Usage {|obj| block} → Array

Sorts self in place using a set of keys generated by mapping the values in self through the given block.

Usage → Enumerator

Test 90. ruby/test/ruby/test_array.rb:test_sort_by!

506 [1, 3, 5, 2, 4].sort_by!{(/home/sawa/Dropbox/implicit/gem/manager/examples/array/spec:2170)}.succeed?

507 RECEIVER == [5, 4, 3, 2, 1]

public 80 Array#take

Implementation candidates

take

public 81 Array#take_while

Implementation candidates

take_while

public 82 Array#to_a

Implementation candidates

to_a

Usage → Array

Returns self.

If called on a subclass of Array, converts the receiver to an Array object.

Missing test Not unit tested.

public 83 Array#to_ary

Implementation candidates

to_ary

Usage → Array

Returns self.

Missing test Not unit tested.

public 84 Array#to_h

Implementation candidates

to_h

Usage → Hash

Returns the result of interpreting ary as an array of [key, value] pairs.

[[:foo, :bar], [1, 2]].to_h
  # => {:foo => :bar, 1 => 2}

Missing test Not unit tested.

public 85 Array#to_s Misplaced Defined as alias of `inspect`.

Implementation candidates

to_s

Alias for: inspect.

Test 93. ruby/test/ruby/test_array.rb:test_to_s

Setup code

$, = ""

512 [].to_s == "[]"

Setup code

$, = ""

513 [1, 2].to_s == "[1, 2]"

Setup code

$, = ""

514 [1, 2, 3].to_s == "[1, 2, 3]"

Setup code

$, = ":"

515 [1, 2, 3].to_s == "[1, 2, 3]"

Setup code

$, = nil

Teardown

Missing Doc No method signature given.

public 86 Array#transpose

Implementation candidates

transpose

Usage → Array

Assumes that self is an array of arrays and transposes the rows and columns.

a = [[1,2], [3,4], [5,6]]
a.transpose   #=> [[1, 3, 5], [2, 4, 6]]

If the length of the subarrays don’t match, an IndexError is raised.

Test 94. ruby/test/ruby/test_array.rb:test_transpose

516 [[1, 2, 3], [:a, :b, :c]].transpose == [[1, :a], [2, :b], [3, :c]]

517 [[1, 2, 3], [:a, :b]].transpose.raise?(IndexError)

public 87 Array#uniq

Implementation candidates

uniq

Usage → Array

Returns a new array by removing duplicate values in self.

It compares values using their hash and eql? methods for efficiency.

Usage {|item| ...} → Array

It will use the return value of the block for comparison.

a = ["a", "a", "b", "b", "c"]
a.uniq   # => ["a", "b", "c"]

b = [["student","sam"], ["student","george"], ["teacher","matz"]]
b.uniq{|s| s.first} # => [["student", "sam"], ["teacher", "matz"]]

Missing test Not unit tested.

public 88 Array#uniq!

Implementation candidates

uniq!

Usage → Array | nil

Removes duplicate elements from self.

It compares values using their hash and eql? methods for efficiency.

Returns nil if no changes are made (that is, no duplicates are found).

Usage {|item| ...} → Array | nil

It will use the return value of the block for comparison.

a = ["a", "a", "b", "b", "c"]
a.uniq!   # => ["a", "b", "c"]

b = ["a", "b", "c"]
b.uniq!   # => nil

c = [["student","sam"], ["student","george"], ["teacher","matz"]]
c.uniq!{|s| s.first} # => [["student", "sam"], ["teacher", "matz"]]

Test 95. ruby/test/ruby/test_array.rb:test_uniq_0

518 [1, 1, 4, 2, 5, 4, 5, 1, 2].uniq!.succeed?

519 RECEIVER == [1, 4, 2, 5]

public 89 Array#unshift

Implementation candidates

unshift

See also #shift for the opposite effect.

Usage (obj, ...) → Array

Prepends objects to the front of self, moving other elements upwards.

a = ["b", "c", "d"]
a.unshift("a")   #=> ["a", "b", "c", "d"]
a.unshift(1, 2)  #=> [1, 2, "a", "b", "c", "d"]

Test 96. ruby/test/ruby/test_array.rb:test_beg_end_0:4/6

Setup code

x = [5]

520 x.unshift(2, 3, 4) == [2, 3, 4, 5]

37 x.unshift(1) == [1, 2, 3, 4, 5]

unshift: The receiver of verification == is [1, 5].

38 RECEIVER == [1, 2, 3, 4, 5]

unshift: The receiver of verification == is [1, 5].

public 90 Array#values_at

Implementation candidates

values_at

public 91 Array#zip

Implementation candidates

zip

Converts any arguments to arrays, then merges elements of self with corresponding elements from each argument.

This generates a sequence of ary.size n-element arrays, where n is one more than the count of arguments.

If the size of any argument is less than the size of the initial array, nil values are supplied.

Usage (arg, ...) → Array

An array of arrays is returned.

Usage (arg, ...){|arr| block} → NilClass

It is invoked for each output array.

a = [4, 5, 6]
b = [7, 8, 9]
[1, 2, 3].zip(a, b)   #=> [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
[1, 2].zip(a, b)      #=> [[1, 4, 7], [2, 5, 8]]
a.zip([1, 2], [8])    #=> [[4, 1, 8], [5, 2, nil], [6, nil, nil]]

Missing test Not unit tested.

public 92 Array#|

Implementation candidates

public class String

Comparable

┊

String

Kernel

┊

Object

BasicObject

<<String

<<Object

<<BasicObject

Class

Module

Kernel

┊

Object

BasicObject

public 93 String#split

Implementation candidates

split

Test 100. ruby/test/ruby/test_array.rb:test_split_0

Setup code

x = "The Book of Mormon"
y = x.reverse

526 x.split(//).reverse!.join == x.reverse

527 RECEIVER.reverse! == x

528 "1 byte string".split(//).reverse.join(":") == "g:n:i:r:t:s: :e:t:y:b: :1"

Setup code

x = "a b c d"

529 x.split == ["a", "b", "c", "d"]

530 x.split(" ") == ["a", "b", "c", "d"]

Missing Doc No paragraph given for user.

Category	Name	Version	Lines
Depended	`ruby`	2.3.1p112
Specification	`spec`	2016-04-25 22:36	3438
Unknown source

Integer Directive	Array 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)
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)
S_, S!	Integer	unsigned short, native endian
I, I_, I!	Integer	unsigned int, native endian
L_, L!	Integer	unsigned long, native endian
Q_, Q!	Integer	unsigned long long, native endian (ArgumentError if the platform has no long long type. Q_ and Q! are available since Ruby 2.1.)
s_, s!	Integer	signed short, native endian
i, i_, i!	Integer	signed int, native endian
l_, l!	Integer	signed long, native endian
q_, q!	Integer	signed long long, native endian (ArgumentError if the platform has no long long type. q_ and q! are available since Ruby 2.1.)
S> L> Q>	Integer	same as the directives without ">" except
s> l> q>		big endian

1. Creating Arrays

2. Example Usage

3. Accessing Elements

4. Obtaining Information about an Array

5. Adding Items to Arrays

6. Removing Items from an Array

7. Iterating over Arrays

8. Selecting Items from an Array

8.1. Non-destructive Selection

8.2. Destructive Selection

public class Array

public 1 Array.[]

public 2 Array.new Misplaced Defined on Class.

public 3 Array.try_convert

public 1 Array#&

public 2 Array#*

public 3 Array#+

public 4 Array#-

public 5 Array#<<

public 6 Array#<=>

public 7 Array#==

public 8 Array#=== Misplaced Defined on Kernel.

public 9 Array#[] (alias: slice)

public 10 Array#[]=

public 11 Array#assoc

public 12 Array#at

public 13 Array#bsearch

public 14 Array#clear

public 15 Array#collect (alias: map)

public 16 Array#collect! (alias: map!)

public 17 Array#combination

public 18 Array#compact

public 19 Array#compact!

public 20 Array#concat

public 21 Array#count

public 22 Array#cycle

public 23 Array#delete

public 24 Array#delete_at

public 25 Array#delete_if

public 26 Array#drop

public 27 Array#drop_while

public 28 Array#each

public 29 Array#each_index

public 30 Array#empty?

public 31 Array#eql?

public 32 Array#fetch

public 33 Array#fill

public 34 Array#find_index (alias: index)

public 35 Array#first

public 36 Array#flatten

public 37 Array#flatten!

public 38 Array#frozen?

public 39 Array#hash

public 40 Array#include?

public 41 Array#index

private 42 Array#initialize_copy

public 43 Array#insert

public 44 Array#inspect (alias: to_s)

public 45 Array#join

public 46 Array#keep_if

public 47 Array#last

public 48 Array#length (alias: size)

public 49 Array#map

public 50 Array#map!

public 51 Array#pack

public 52 Array#permutation

public 53 Array#pop

public 54 Array#product

public 55 Array#push

public 56 Array#rassoc

public 57 Array#reject

public 58 Array#reject!

public 59 Array#repeated_combination

public 60 Array#repeated_permutation

public 61 Array#replace (alias: initialize_copy)

public 62 Array#reverse

public 63 Array#reverse!

public 64 Array#reverse_each

public 65 Array#rindex

public 66 Array#rotate

public 2 Array.new Misplaced Defined on `Class`.

public 8 Array#=== Misplaced Defined on `Kernel`.

public 74 Array#size Misplaced Defined as alias of `length`.

public 85 Array#to_s Misplaced Defined as alias of `inspect`.