Creates a new static array and invokes the block once for each index of the array, assigning the block's value in that index.

StaticArray(Int32, 3).new { |i| i * 2 } # => StaticArray[0, 2, 4]

Creates a new static array filled with the given value.

StaticArray(Int32, 3).new(42) # => StaticArray[42, 42, 42]

Creates a newStaticArray with the givenargs. The type of the static array will be the union of the type of the givenargs, and its size will be the number of elements inargs.

ary = StaticArray[1, 'a']
ary[0]    # => 1
ary[1]    # => 'a'
ary.class # => StaticArray(Char | Int32, 2)

• Number.static_array is a convenient alternative for designating a specific numerical item type.

The comparison operator. Returns0 if the two objects are equal, a negative number if this object is considered less thanother, a positive number if this object is considered greater thanother, ornil if the two objects are not comparable.

Subclasses define this method to provide class-specific ordering.

The comparison operator is usually used to sort values:

# Sort in a descending way:
[3, 1, 2].sort { |x, y| y <=> x } # => [3, 2, 1]

# Sort in an ascending way:
[3, 1, 2].sort { |x, y| x <=> y } # => [1, 2, 3]

Equality. Returnstrue if each element inself is equal to each corresponding element inother.

array = StaticArray(Int32, 3).new 0  # => StaticArray[0, 0, 0]
array2 = StaticArray(Int32, 3).new 0 # => StaticArray[0, 0, 0]
array3 = StaticArray(Int32, 3).new 1 # => StaticArray[1, 1, 1]
array == array2                      # => true
array == array3                      # => false

Equality with another object. Always returnsfalse.

array = StaticArray(Int32, 3).new 0 # => StaticArray[0, 0, 0]
array == nil                        # => false

Returns a newStaticArray where each element is cloned from elements inself.

Replacescount or less (if there aren't enough) elements starting at the givenstart index withvalue. Returnsself.

Negative values ofstart count from the end of the container.

RaisesIndexError if thestart index is out of range.

RaisesArgumentError ifcount is negative.

array = [1, 2, 3, 4, 5]
array.fill(9, 2, 2) # => [1, 2, 9, 9, 5]
array               # => [1, 2, 9, 9, 5]

Replaces the elements within the givenrange withvalue. Returnsself.

Negative indices count backward from the end of the container.

RaisesIndexError if the starting index is out of range.

array = [1, 2, 3, 4, 5]
array.fill(9, 2..3) # => [1, 2, 9, 9, 5]
array               # => [1, 2, 9, 9, 5]

Replaces every element inself with the givenvalue. Returnsself.

array = [1, 2, 3, 4]
array.fill(2) # => [2, 2, 2, 2]
array         # => [2, 2, 2, 2]

Returns the index of the first appearance ofobject inself starting from the givenoffset, ornil ifobject is not inself.

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

Returns a new static array where elements are mapped by the given block.

array = StaticArray[1, 2.5, "a"]
array.map &.to_s # => StaticArray["1", "2.5", "a"]

Like#map, but the block gets passed both the element and its index.

Accepts an optionaloffset parameter, which tells it to start counting from there.

Shifts all elements ofself to the leftn times. Returnsself.

a1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a2 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a3 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

a1.rotate!
a2.rotate!(1)
a3.rotate!(3)

a1 # => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
a2 # => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
a3 # => [3, 4, 5, 6, 7, 8, 9, 0, 1, 2]

Returns the size ofself

array = StaticArray(Int32, 3).new { |i| i + 1 }
array.size # => 3

Returns a new instance with all elements sorted based on the return value of their comparison methodT#<=> (seeComparable#<=>), using a stable sort algorithm.

a = StaticArray[3, 1, 2]
a.sort # => StaticArray[1, 2, 3]
a      # => StaticArray[3, 1, 2]

SeeIndexable::Mutable#sort! for details on the sorting mechanism.

RaisesArgumentError if the comparison between any two elements returnsnil.

Returns a new instance with all elements sorted based on the comparator in the given block, using a stable sort algorithm.

a = StaticArray[3, 1, 2]
b = a.sort { |a, b| b <=> a }

b # => StaticArray[3, 2, 1]
a # => StaticArray[3, 1, 2]

SeeIndexable::Mutable#sort!(&block : T, T -> U) for details on the sorting mechanism.

RaisesArgumentError if for any two elements the block returnsnil.=

Sorts all elements inself based on the return value of the comparison methodT#<=> (seeComparable#<=>), using a stable sort algorithm.

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

This sort operation modifiesself. See#sort for a non-modifying option that allocates a new instance.

SeeSlice#sort! for details on the implementation.

RaisesArgumentError if the comparison between any two elements returnsnil.

Sorts all elements inself based on the comparator in the given block, using a stable sort algorithm.

The block must implement a comparison between two elementsa andb, wherea < b returns-1,a == b returns0, anda > b returns1. The comparison operator<=> can be used for this.

a = [3, 1, 2]
# This is a reverse sort (forward sort would be `a <=> b`)
a.sort! { |a, b| b <=> a }
a # => [3, 2, 1]

This sort operation modifiesself. See#sort(&block : T, T -> U) for a non-modifying option that allocates a new instance.

SeeSlice#sort!(&block : T, T -> U) for details on the implementation.

RaisesArgumentError if for any two elements the block returnsnil.

Returns a new instance with all elements sorted by the output value of the block. The output values are compared via the comparison methodT#<=> (seeComparable#<=>), using a stable sort algorithm.

a = StaticArray["apple", "pear", "fig"]
b = a.sort_by { |word| word.size }
b # => StaticArray["fig", "pear", "apple"]
a # => StaticArray["apple", "pear", "fig"]

If stability is expendable,#unstable_sort_by(&block : T -> _) provides a performance advantage over stable sort.

SeeIndexable::Mutable#sort_by!(&block : T -> _) for details on the sorting mechanism.

RaisesArgumentError if the comparison between any two comparison values returnsnil.

Sorts all elements inself by the output value of the block. The output values are compared via the comparison method#<=> (seeComparable#<=>), using a stable sort algorithm.

a = %w(apple pear fig)
a.sort_by! { |word| word.size }
a # => ["fig", "pear", "apple"]

This sort operation modifiesself. See#sort_by(&block : T -> _) for a non-modifying option that allocates a new instance.

If stability is expendable,#unstable_sort_by!(&block : T -> _) provides a performance advantage over stable sort.

See#sort!(&block : T -> _) for details on the sorting mechanism.

RaisesArgumentError if the comparison between any two comparison values returnsnil.

Appends a string representation of this static array to the givenIO.

array = StaticArray(Int32, 3).new { |i| i + 1 }
array.to_s # => "StaticArray[1, 2, 3]"

Returns a slice that points to the elements of this static array. Changes made to the returned slice also affect this static array.

array = StaticArray(Int32, 3).new(2)
slice = array.to_slice # => Slice[2, 2, 2]
slice[0] = 3
array # => StaticArray[3, 2, 2]

Returns a pointer to this static array's data.

ary = StaticArray(Int32, 3).new(42)
ary.to_unsafe[0] # => 42

Returns the element at the givenindex, without doing any bounds check.

Indexable makes sure to invoke this method withindex in0...size, so converting negative indices to positive ones is not needed here.

Clients never invoke this method directly. Instead, they access elements with#[](index) 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.

Sets the element at the givenindex tovalue, without doing any bounds check.

Indexable::Mutable makes sure to invoke this method withindex in 0...size, so converting negative indices to positive ones is not needed here.

Clients never invoke this method directly. Instead, they modify elements with#[]=(index, value).

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 new instance with all elements sorted based on the return value of their comparison methodT#<=> (seeComparable#<=>), using an unstable sort algorithm.

a = StaticArray[3, 1, 2]
a.unstable_sort # => StaticArray[1, 2, 3]
a               # => StaticArray[3, 1, 2]

SeeIndexable::Mutable#unstable_sort! for details on the sorting mechanism.

RaisesArgumentError if the comparison between any two elements returnsnil.

Returns a new instance with all elements sorted based on the comparator in the given block, using an unstable sort algorithm.

a = StaticArray[3, 1, 2]
b = a.unstable_sort { |a, b| b <=> a }

b # => StaticArray[3, 2, 1]
a # => StaticArray[3, 1, 2]

SeeIndexable::Mutable#unstable_sort!(&block : T, T -> U) for details on the sorting mechanism.

RaisesArgumentError if for any two elements the block returnsnil.

Sorts all elements inself based on the return value of the comparison methodT#<=> (seeComparable#<=>), using an unstable sort algorithm.

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

This sort operation modifiesself. See#unstable_sort for a non-modifying option that allocates a new instance.

SeeSlice#unstable_sort! for details on the implementation.

RaisesArgumentError if the comparison between any two elements returnsnil.

Sorts all elements inself based on the comparator in the given block, using an unstable sort algorithm.

The block must implement a comparison between two elementsa andb, wherea < b returns-1,a == b returns0, anda > b returns1. The comparison operator<=> can be used for this.

a = [3, 1, 2]
# This is a reverse sort (forward sort would be `a <=> b`)
a.unstable_sort! { |a, b| b <=> a }
a # => [3, 2, 1]

This sort operation modifiesself. See#unstable_sort(&block : T, T -> U) for a non-modifying option that allocates a new instance.

SeeSlice#unstable_sort!(&block : T, T -> U) for details on the implementation.

RaisesArgumentError if for any two elements the block returnsnil.

Returns a new instance with all elements sorted by the output value of the block. The output values are compared via the comparison method#<=> (seeComparable#<=>), using an unstable sort algorithm.

a = StaticArray["apple", "pear", "fig"]
b = a.unstable_sort_by { |word| word.size }
b # => StaticArray["fig", "pear", "apple"]
a # => StaticArray["apple", "pear", "fig"]

If stability is necessary, use#sort_by(&block : T -> _) instead.

SeeIndexable::Mutable#unstable_sort!(&block : T -> _) for details on the sorting mechanism.

RaisesArgumentError if the comparison between any two comparison values returnsnil.

Sorts all elements inself by the output value of the block. The output values are compared via the comparison method#<=> (seeComparable#<=>), using an unstable sort algorithm.

a = %w(apple pear fig)
a.unstable_sort_by! { |word| word.size }
a # => ["fig", "pear", "apple"]

This sort operation modifiesself. See#unstable_sort_by(&block : T -> _) for a non-modifying option that allocates a new instance.

If stability is necessary, use#sort_by!(&block : T -> _) instead.

See#unstable_sort!(&block : T -> _) for details on the sorting mechanism.

RaisesArgumentError if the comparison between any two comparison values returnsnil.