module Indexable(T)

Overview

A container that allows accessing elements via a numeric index.

Indexing starts at 0. A negative index is assumed to be relative to the end of the container: -1 indicates the last element, -2 is the next to last element, and so on.

Types including this module are typically Array-like types.

Included Modules

Direct including types

Defined in:

indexable.cr

Instance Method Summary

Instance methods inherited from module Enumerable(T)

all?(&block)
all?
all?
, any?(&block)
any?
any?
, chunks(&block : T -> U) forall U chunks, compact_map(&block) compact_map, count(&block)
count(item)
count
, cycle(n, &block)
cycle(&block)
cycle
, each(&block : T -> _) each, each_cons(count : Int, reuse = false, &block) each_cons, each_slice(count : Int, reuse = false, &block) each_slice, each_with_index(offset = 0, &block) each_with_index, each_with_object(obj, &block) each_with_object, find(if_none = nil, &block) find, first(count : Int)
first
first
, first? first?, flat_map(&block : T -> Array(U) | Iterator(U) | U) forall U flat_map, grep(pattern) grep, group_by(&block : T -> U) forall U group_by, in_groups_of(size : Int, filled_up_with : U = nil) forall U
in_groups_of(size : Int, filled_up_with : U = nil, reuse = false, &block) forall U
in_groups_of
, includes?(obj) includes?, index(&block)
index(obj)
index
, index_by(&block : T -> U) forall U index_by, join(separator, io)
join(separator = "")
join(separator, io, &block)
join(separator = "", &block)
join
, map(&block : T -> U) forall U map, map_with_index(&block : T, Int32 -> U) forall U map_with_index, max max, max? max?, max_by(&block : T -> U) forall U max_by, max_by?(&block : T -> U) forall U max_by?, max_of(&block : T -> U) forall U max_of, max_of?(&block : T -> U) forall U max_of?, min min, min? min?, min_by(&block : T -> U) forall U min_by, min_by?(&block : T -> U) forall U min_by?, min_of(&block : T -> U) forall U min_of, min_of?(&block : T -> U) forall U min_of?, minmax minmax, minmax? minmax?, minmax_by(&block : T -> U) forall U minmax_by, minmax_by?(&block : T -> U) forall U minmax_by?, minmax_of(&block : T -> U) forall U minmax_of, minmax_of?(&block : T -> U) forall U minmax_of?, none?(&block)
none?
none?
, one?(&block) one?, partition(&block) partition, product(&block)
product(initial : Number, &block)
product
product(initial : Number)
product
, reduce(&block)
reduce(memo, &block)
reduce
, reject(&block : T -> ) reject, select(&block : T -> ) select, size size, skip(count : Int) skip, skip_while(&block) skip_while, sum(initial)
sum
sum(initial, &block)
sum(&block)
sum
, take_while(&block) take_while, to_a to_a, to_h to_h, to_set to_set

Instance methods inherited from module Iterable(T)

chunk(reuse = false, &block : T -> U) forall U chunk, cycle(n)
cycle
cycle
, each each, each_cons(count : Int, reuse = false) each_cons, each_slice(count : Int, reuse = false) each_slice, each_with_index(offset = 0) each_with_index, each_with_object(obj) each_with_object

Instance Method Detail

def [](index : Int) #

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

View source
def []?(index : Int) #

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

View source
def at(index : Int, &block) #

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

View source
def at(index : Int) #

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

View source
def bsearch(&block) #

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

View source
def bsearch_index(&block) #

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

View source
def each(&block) #

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

View source
def each #

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.


View source
def each_index(&block) : Nil #

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

View source
def each_index #

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.


View source
def empty? #

Returns true if self is empty, false otherwise.

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

View source
def equals?(other : Indexable, &block) #

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


View source
def equals?(other, &block) #

Determines if self equals other according to a comparison done by the given block.

If self's size is the same as other's size, this method yields elements from self and other in tandem: if the block returns true for all of them, this method returns true. Otherwise it returns false.

a = [1, 2, 3]
b = ["a", "ab", "abc"]
a.equals?(b) { |x, y| x == y.size } # => true
a.equals?(b) { |x, y| x == y }      # => false

View source
def first(&block) #

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

View source
def first #

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

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

View source
def first? #

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

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

View source
def hash #

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

See also: Object#hash.


View source
def index(object, offset : Int = 0) #

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

View source
def index(offset : Int = 0, &block) #

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

View source
def last #

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

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

View source
def last(&block) #

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

View source
def last? #

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

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

View source
def reverse_each(&block) : Nil #

Same as #each, but works in reverse.


View source
def reverse_each #

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


View source
def rindex(offset = size - 1, &block) #

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

View source
def rindex(value, offset = size - 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

View source
def sample(random = Random::DEFAULT) #

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

View source
abstract def size #

Returns the number of elements in this container.


View source
abstract def unsafe_at(index : Int) #

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.


View source
def values_at(*indexes : Int) #

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"}

View source
def zip(other : Indexable, &block) #

View source
def zip(other : Indexable(U)) forall U #

View source
def zip?(other : Indexable, &block) #

View source
def zip?(other : Indexable(U)) forall U #

View source