Indexable

Returns the element at the given index.

Negative indices can be used to start counting from the end of the array. Raises IndexError if trying to access an element outside the array's range-

ary = ['a', 'b', 'c']
ary[0]  # => 'a'
ary[2]  # => 'c'
ary[-1] # => 'c'
ary[-2] # => 'b'

ary[3]  # raises IndexError
ary[-4] # raises IndexError

Returns the element at the given index.

Negative indices can be used to start counting from the end of the array. Returns nil if trying to access an element outside the array's range.

ary = ['a', 'b', 'c']
ary[0]?  # => 'a'
ary[2]?  # => 'c'
ary[-1]? # => 'c'
ary[-2]? # => 'b'

ary[3]?  # nil
ary[-4]? # nil

Returns the element at the given index, if in bounds, otherwise executes the given block and returns its value.

a = [:foo, :bar]
a.at(0) { :baz } # => :foo
a.at(2) { :baz } # => :baz

Returns the element at the given index, if in bounds, otherwise raises IndexError-

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

By using binary search, returns the first element for which the passed block returns true.

If the block returns false, the finding element exists behind. If the block returns true, the finding element is itself or exists infront.

Binary search needs sorted array, so self has to be sorted.

Returns nil if the block didn't return true for any element.

[2, 5, 7, 10].bsearch { |x| x >= 4 } # => 5
[2, 5, 7, 10].bsearch { |x| x > 10 } # => nil

By using binary search, returns the index of the first element for which the passed block returns true.

If the block returns false, the finding element exists behind. If the block returns true, the finding element is itself or exists infront.

Binary search needs sorted array, so self has to be sorted.

Returns nil if the block didn't return true for any element.

[2, 5, 7, 10].bsearch_index { |x, i| x >= 4 } # => 1
[2, 5, 7, 10].bsearch_index { |x, i| x > 10 } # => nil

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

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

produces:

a -- b -- c --

Returns an Iterator for the elements of self.

a = ["a", "b", "c"]
iter = a.each
iter.next # => "a"
iter.next # => "b"

The returned iterator keeps a reference to self: if the array changes, the returned values of the iterator change as well.

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

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

produces:

0 -- 1 -- 2 --

Returns an Iterator for each index in self.

a = ["a", "b", "c"]
iter = a.each_index
iter.next # => 0
iter.next # => 1

The returned iterator keeps a reference to self. If the array changes, the returned values of the iterator will change as well.

Returns true if self is empty, false otherwise.

([] of Int32).empty? # => true
([1]).empty?         # => false

Optimized version of #equals? used when other is also an Indexable-

Returns the first element of self if it's not empty, or the given block's value.

([1, 2, 3]).first { 4 }   # => 1
([] of Int32).first { 4 } # => 4

Returns the first element of self if it's not empty, or raises IndexError-

([1, 2, 3]).first   # => 1
([] of Int32).first # raises IndexError

Returns the first element of self if it's not empty, or nil.

([1, 2, 3]).first?   # => 1
([] of Int32).first? # => nil

Returns a hash code based on self's size and elements.

See also: Object#hash.

Returns the index of the first appearance of value in self starting from the given offset, or nil if the value is not in self.

[1, 2, 3, 1, 2, 3].index(2, offset: 2) # => 4

Returns the index of the first object in self for which the block returns true, starting from the given offset, or nil if no match is found.

[1, 2, 3, 1, 2, 3].index(offset: 2) { |x| x < 2 } # => 3

Returns the last element of self if it's not empty, or raises IndexError-

([1, 2, 3]).last   # => 3
([] of Int32).last # raises IndexError

Returns the last element of self if it's not empty, or the given block's value.

([1, 2, 3]).last { 4 }   # => 3
([] of Int32).last { 4 } # => 4

Returns the last element of self if it's not empty, or nil.

([1, 2, 3]).last?   # => 3
([] of Int32).last? # => nil

Same as #each, but works in reverse.

Returns an Iterator over the elements of self in reverse order.

Returns the index of the first object in self for which the block returns true, starting from the last object, or nil if no match is found.

If offset is given, the search starts from that index towards the first elements in self.

[1, 2, 3, 2, 3].rindex { |x| x < 3 }            # => 3
[1, 2, 3, 2, 3].rindex(offset: 2) { |x| x < 3 } # => 1

Returns the index of the last appearance of value in self, or nil if the value is not in self.

If offset is given, it defines the position to end the search (elements beyond this point are ignored).

[1, 2, 3, 2, 3].rindex(2)            # => 3
[1, 2, 3, 2, 3].rindex(2, offset: 2) # => 1

Returns a random element from self, using the given random number generator. Raises IndexError if self is empty-

a = [1, 2, 3]
a.sample                # => 2
a.sample                # => 1
a.sample(Random.new(1)) # => 3

Returns the number of elements in this container.

Returns the element at the given index, without doing any bounds check.

Indexable makes sure to invoke this method with index in 0--.size, so converting negative indices to positive ones is not needed here.

Clients never invoke this method directly. Instead, they access elements with # and #[]?(index).

This method should only be directly invoked if you are absolutely sure the index is in bounds, to avoid a bounds check for a small boost of performance.

Returns a Tuple populated with the elements at the given indexes. Raises IndexError if any index is invalid-

["a", "b", "c", "d"].values_at(0, 2) # => {"a", "c"}