# struct StaticArray(T, N)

- StaticArray(T, N)
- Value
- Object

##
Overview

A fixed-size, stack allocated array.

`StaticArray` is a generic type with type argument `T` specifying the type of its elements and `N` the fixed size. For example `StaticArray(Int32, 3)` is a static array of `Int32` with three elements.

Instantiations of this static array type:

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

This type can also be expressed as `Int32[3]` (only in type grammar). A typical use case is in combination with `uninitialized`:

    ints = uninitialized Int32[3]
    ints[0] = 0
    ints[1] = 8
    ints[2] = 15

For number types there is also `Number.static_array` which can be used to initialize a static array:

    Int32.static_array(0, 8, 15) # => StaticArray[0, 8, 15]

The generic argument type `N` is a special case in the type grammar as it doesn't specify a type but a size. Its value can be an `Int32` literal or constant.

##
Included Modules

- Comparable(StaticArray(T, N))
- Indexable::Mutable(T)

##
Defined in:

json/to_json.cr
static_array.cr

##
Constructors

- .new(& : Int32 -> T)

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

- .new(value : T)

  Creates a new static array filled with the given value.

##
Macro Summary

- [](*args)

  Creates a new `StaticArray` with the given args.

##
Instance Method Summary

- #<=>(other : StaticArray)

  The comparison operator.

- #==(other : StaticArray)

  Equality.

- #==(other)

  Equality with another object.

- #clone

  Returns a new `StaticArray` where each element is cloned from elements in `self`.

- #fill(value : T, start : Int, count : Int) : self

  Replaces count or less (if there aren't enough) elements starting at the given start index with value.

- #fill(value : T, range : Range) : self

  Replaces the elements within the given range with value.

- #fill(value : T) : self

  Replaces every element in `self` with the given value.

- #index(object, offset : Int = 0)

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

- #map(&block : T -> U) : StaticArray(U, N) forall U

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

- #map_with_index(offset = 0, &block : T, Int32 -> U) : StaticArray(U, N) forall U

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

- #pretty_print(pp)
- #rotate!(n : Int = 1) : self

  Shifts all elements of `self` to the left n times.

- #size : Int32

  Returns the size of `self`

- #sort : StaticArray(T, N)

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

- #sort(&block : T, T -> U) : StaticArray(T, N) forall U

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

- #sort! : self

  Sorts all elements in `self` based on the return value of the comparison method `T#<=>` (see `Comparable#<=>`), using a stable sort algorithm.

- #sort!(&block : T, T -> U) : self forall U

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

- #sort_by(&block : T -> _) : StaticArray(T, N)

  Returns a new instance with all elements sorted by the output value of the block.

- #sort_by!(&block : T -> _) : self

  Sorts all elements in `self` by the output value of the block.

- #to_json(json : JSON::Builder) : Nil
- #to_s(io : IO) : Nil

  Appends a string representation of this static array to the given `IO`.

- #to_slice : Slice(T)

  Returns a slice that points to the elements of this static array.

- #to_unsafe : Pointer(T)

  Returns a pointer to this static array's data.

- #unsafe_fetch(index : Int) : T

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

- #unsafe_put(index : Int, value : T)

  Sets the element at the given index to value, without doing any bounds check.

- #unstable_sort : StaticArray(T, N)

  Returns a new instance with all elements sorted based on the return value of their comparison method `T#<=>` (see `Comparable#<=>`), using an unstable sort algorithm.

- #unstable_sort(&block : T, T -> U) : StaticArray(T, N) forall U

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

- #unstable_sort! : self

  Sorts all elements in `self` based on the return value of the comparison method `T#<=>` (see `Comparable#<=>`), using an unstable sort algorithm.

- #unstable_sort!(&block : T, T -> U) : self forall U

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

- #unstable_sort_by(&block : T -> _) : StaticArray(T, N)

  Returns a new instance with all elements sorted by the output value of the block.

- #unstable_sort_by!(&block : T -> _) : self

  Sorts all elements in `self` by the output value of the block.

### Instance methods inherited from module `Indexable::Mutable(T)`

[]=(index : Int, value : T) : T []=, fill(value : T, start : Int, count : Int) : self
fill(value : T, range : Range) : self
fill(value : T) : self
fill(start : Int, count : Int, & : Int32 -> T) : self
fill(range : Range, & : Int32 -> T) : self
fill(*, offset : Int = 0, & : Int32 -> T) : self fill, map!(& : T -> _) : self map!, map_with_index!(offset = 0, & : T, Int32 -> _) : self map_with_index!, reverse! : self reverse!, rotate!(n : Int = 1) : self rotate!, shuffle!(random : Random | Nil = nil) : self shuffle!, sort! : self
sort!(&block : T, T -> U) : self forall U sort!, sort_by!(&block : T -> _) : self sort_by!, swap(index0 : Int, index1 : Int) : self swap, unsafe_put(index : Int, value : T) unsafe_put, unstable_sort! : self
unstable_sort!(&block : T, T -> U) : self forall U unstable_sort!, unstable_sort_by!(&block : T -> _) : self unstable_sort_by!, update(index : Int, & : T -> _) : T update

### Instance methods inherited from module `Indexable(T)`

[](index : Int) [], []?(index : Int) []?, bsearch(& : T -> _) bsearch, bsearch_index(& : T, Int32 -> _) bsearch_index, cartesian_product(*others : Indexable) cartesian_product, combinations(size : Int = self.size) combinations, dig(index : Int, *subindexes) dig, dig?(index : Int, *subindexes) dig?, each(& : T -> )
each
each(*, start : Int, count : Int, & : T -> )
each(*, within range : Range, & : T -> ) each, each_cartesian(*others : Indexable, &)
each_cartesian(*others : Indexable) each_cartesian, each_combination(size : Int = self.size, reuse = false, &) : Nil
each_combination(size : Int = self.size, reuse = false) each_combination, each_index(& : Int32 -> ) : Nil
each_index
each_index(*, start : Int, count : Int, &) each_index, each_permutation(size : Int = self.size, reuse = false, &) : Nil
each_permutation(size : Int = self.size, reuse = false) each_permutation, each_repeated_combination(size : Int = self.size, reuse = false, &) : Nil
each_repeated_combination(size : Int = self.size, reuse = false) each_repeated_combination, empty? : Bool empty?, equals?(other : Indexable, &) : Bool
equals?(other, &) equals?, fetch(index : Int, &)
fetch(index, default) fetch, find(if_none, _offset offset : Int, & : T -> )
find(if_none = nil, *, offset : Int, & : T -> ) find, find!(offset : Int = 0, & : T -> ) find!, first(&) first, hash(hasher) hash, index(object, offset : Int = 0)
index(offset : Int = 0, & : T -> ) index, index!(obj, offset : Int = 0)
index!(offset : Int = 0, & : T -> ) index!, join(separator : String | Char | Number = "") : String join, last : T
last(&) last, last? : T | Nil last?, permutations(size : Int = self.size) : Array(Array(T)) permutations, repeated_combinations(size : Int = self.size) : Array(Array(T)) repeated_combinations, reverse_each(& : T -> ) : Nil
reverse_each reverse_each, rindex(value, offset = size - 1)
rindex(offset = size - 1, & : T -> ) rindex, rindex!(value, offset = size - 1)
rindex!(offset = size - 1, & : T -> ) rindex!, sample(n : Int, random : Random | Nil = nil) : Array(T)
sample(random : Random | Nil = nil) sample, size size, to_a(& : T -> U) : Array(U) forall U to_a, unsafe_fetch(index : Int) unsafe_fetch, values_at(*indexes : Int) values_at

### Class methods inherited from module `Indexable(T)`

cartesian_product(indexables : Indexable(Indexable)) cartesian_product, each_cartesian(indexables : Indexable(Indexable), reuse = false, &)
each_cartesian(indexables : Indexable(Indexable), reuse = false) each_cartesian

### Instance methods inherited from module `Enumerable(T)`

accumulate(initial : U) : Array(U) forall U
accumulate : Array(T)
accumulate(initial : U, &block : U, T -> U) : Array(U) forall U
accumulate(&block : T, T -> T) : Array(T) accumulate, all?(& : T -> ) : Bool
all?(pattern) : Bool
all? : Bool all?, any?(& : T -> ) : Bool
any?(pattern) : Bool
any? : Bool any?, chunks(&block : T -> U) forall U chunks, compact_map(& : T -> _) compact_map, count(& : T -> ) : Int32
count(item) : Int32 count, cycle(n, & : T -> ) : Nil
cycle(& : T -> ) : Nil cycle, each(& : T -> ) each, each_cons(count : Int, reuse = false, &) each_cons, each_cons_pair(& : T, T -> ) : Nil each_cons_pair, each_slice(count : Int, reuse = false, &) each_slice, each_step(n : Int, *, offset : Int = 0, & : T -> ) : Nil each_step, each_with_index(offset = 0, &) each_with_index, each_with_object(obj : U, & : T, U -> ) : U forall U each_with_object, empty? : Bool empty?, find(if_none = nil, & : T -> ) find, find!(& : T -> ) : T find!, find_value(if_none = nil, & : T -> ) find_value, first(&)
first(count : Int) : Array(T)
first : T first, first? : T | Nil first?, flat_map(& : T -> _) flat_map, group_by(& : 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, &) forall U in_groups_of, in_slices_of(size : Int) : Array(Array(T)) in_slices_of, includes?(obj) : Bool includes?, index(& : T -> ) : Int32 | Nil
index(obj) : Int32 | Nil index, index!(& : T -> ) : Int32
index!(obj) : Int32 index!, index_by(& : T -> U) : Hash(U, T) forall U index_by, join(io : IO, separator = "") : Nil
join(separator, io : IO) : Nil
join(separator = "") : String
join(io : IO, separator = "", & : T, IO -> )
join(separator, io : IO, &)
join(separator = "", & : T -> ) join, map(& : T -> U) : Array(U) forall U map, map_with_index(offset = 0, & : T, Int32 -> U) : Array(U) forall U map_with_index, max(count : Int) : Array(T)
max : T max, max? : T | Nil max?, max_by(& : T -> U) : T forall U max_by, max_by?(& : T -> U) : T | Nil forall U max_by?, max_of(& : T -> U) : U forall U max_of, max_of?(& : T -> U) : U | Nil forall U max_of?, min(count : Int) : Array(T)
min : T min, min? : T | Nil min?, min_by(& : T -> U) : T forall U min_by, min_by?(& : T -> U) : T | Nil forall U min_by?, min_of(& : T -> U) : U forall U min_of, min_of?(& : T -> U) : U | Nil forall U min_of?, minmax : Tuple(T, T) minmax, minmax? : Tuple(T | Nil, T | Nil) minmax?, minmax_by(& : T -> U) : Tuple(T, T) forall U minmax_by, minmax_by?(& : T -> U) : Tuple(T, T) | Tuple(Nil, Nil) forall U minmax_by?, minmax_of(& : T -> U) : Tuple(U, U) forall U minmax_of, minmax_of?(& : T -> U) : Tuple(U, U) | Tuple(Nil, Nil) forall U minmax_of?, none?(& : T -> ) : Bool
none?(pattern) : Bool
none? : Bool none?, one?(& : T -> ) : Bool
one?(pattern) : Bool
one? : Bool one?, partition(& : T -> ) : Tuple(Array(T), Array(T))
partition(type : U.class) forall U partition, present? : Bool present?, product(initial : Number)
product
product(initial : Number, & : T -> )
product(& : T -> _) product, reduce(memo, &)
reduce(&) reduce, reduce?(&) reduce?, reject(& : T -> )
reject(type : U.class) forall U
reject(pattern) : Array(T) reject, sample(n : Int, random : Random | Nil = nil) : Array(T)
sample(random : Random | Nil = nil) : T sample, select(& : T -> )
select(type : U.class) : Array(U) forall U
select(pattern) : Array(T) select, size : Int32 size, skip(count : Int) skip, skip_while(& : T -> ) : Array(T) skip_while, sum(initial)
sum
sum(initial, & : T -> )
sum(& : T -> ) sum, take_while(& : T -> ) : Array(T) take_while, tally(hash)
tally : Hash(T, Int32) tally, tally_by(hash, &)
tally_by(&block : T -> U) : Hash(U, Int32) forall U tally_by, to_a : Array(T)
to_a(& : T -> U) : Array(U) forall U to_a, to_h
to_h(& : T -> Tuple(K, V)) forall K, V to_h, to_set : Set(T)
to_set(&block : T -> U) : Set(U) forall U to_set, zip(*others : Indexable | Iterable | Iterator, &)
zip(*others : Indexable | Iterable | Iterator) zip, zip?(*others : Indexable | Iterable | Iterator, &)
zip?(*others : Indexable | Iterable | Iterator) zip?

### Class methods inherited from module `Enumerable(T)`

element_type(x) element_type

### Instance methods inherited from module `Iterable(T)`

chunk(reuse = false, &block : T -> U) forall U chunk, chunk_while(reuse : Bool | Array(T) = false, &block : T, T -> B) forall B chunk_while, cycle(n)
cycle cycle, each each, each_cons(count : Int, reuse = false) each_cons, each_cons_pair each_cons_pair, each_slice(count : Int, reuse = false) each_slice, each_step(n : Int)
each_step(n : Int, *, offset : Int) each_step, each_with_index(offset = 0) each_with_index, each_with_object(obj) each_with_object, slice_after(reuse : Bool | Array(T) = false, &block : T -> B) forall B
slice_after(pattern, reuse : Bool | Array(T) = false) slice_after, slice_before(reuse : Bool | Array(T) = false, &block : T -> B) forall B
slice_before(pattern, reuse : Bool | Array(T) = false) slice_before, slice_when(reuse : Bool | Array(T) = false, &block : T, T -> B) forall B slice_when

### Instance methods inherited from module `Comparable(StaticArray(T, N))`

<(other : T) : Bool <, <=(other : T) <=, <=>(other : T) <=>, ==(other : T) ==, >(other : T) : Bool >, >=(other : T) >=, clamp(min, max)
clamp(range : Range) clamp

### Instance methods inherited from struct `Value`

==(other : Log::Metadata::Value)
==(other : JSON::Any)
==(other : YAML::Any)
==(other) ==, dup dup

### Instance methods inherited from class `Object`

! : Bool !, !=(other) !=, !~(other) !~, ==(other) ==, ===(other : JSON::Any)
===(other : YAML::Any)
===(other) ===, =~(other) =~, as(type : Class) as, as?(type : Class) as?, class class, dup dup, hash(hasher)
hash hash, in?(collection : Object) : Bool
in?(*values : Object) : Bool in?, inspect(io : IO) : Nil
inspect : String inspect, is_a?(type : Class) : Bool is_a?, itself itself, nil? : Bool nil?, not_nil!(message)
not_nil! not_nil!, pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect, pretty_print(pp : PrettyPrint) : Nil pretty_print, responds_to?(name : Symbol) : Bool responds_to?, tap(&) tap, to_json(io : IO) : Nil
to_json : String to_json, to_pretty_json(indent : String = " ") : String
to_pretty_json(io : IO, indent : String = " ") : Nil to_pretty_json, to_s(io : IO) : Nil
to_s : String to_s, to_yaml(io : IO) : Nil
to_yaml : String to_yaml, try(&) try, unsafe_as(type : T.class) forall T unsafe_as

### Class methods inherited from class `Object`

from_json(string_or_io : String | IO, root : String)
from_json(string_or_io : String | IO) from_json, from_yaml(string_or_io : String | IO) from_yaml

### Macros inherited from class `Object`

class_getter(*names, &block) class_getter, class_getter!(*names) class_getter!, class_getter?(*names, &block) class_getter?, class_property(*names, &block) class_property, class_property!(*names) class_property!, class_property?(*names, &block) class_property?, class_setter(*names) class_setter, def_clone def_clone, def_equals(*fields) def_equals, def_equals_and_hash(*fields) def_equals_and_hash, def_hash(*fields) def_hash, delegate(*methods, to object) delegate, forward_missing_to(delegate) forward_missing_to, getter(*names, &block) getter, getter!(*names) getter!, getter?(*names, &block) getter?, property(*names, &block) property, property!(*names) property!, property?(*names, &block) property?, setter(*names) setter

##
Constructor Detail

def self.new(& : Int32 -> T) #

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]

def self.new(value : T) #

Creates a new static array filled with the given value.

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

##
Macro Detail

macro [](*args) #

Creates a new `StaticArray` with the given args. The type of the static array will be the union of the type of the given args, and its size will be the number of elements in args.

    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.

##
Instance Method Detail

def <=>(other : StaticArray) #
Description copied from module Comparable(StaticArray(T, N))

The comparison operator. Returns `0` if the two objects are equal, a negative number if this object is considered less than other, a positive number if this object is considered greater than other, or `nil` 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]

def ==(other : StaticArray) #

Equality. Returns `true` if each element in `self` is equal to each corresponding element in other.

    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

def ==(other) #

Equality with another object. Always returns `false`.

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

def clone #

Returns a new `StaticArray` where each element is cloned from elements in `self`.

def fill(value : T, start : Int, count : Int) : self #

Replaces count or less (if there aren't enough) elements starting at the given start index with value. Returns `self`.

Negative values of start count from the end of the container.

Raises `IndexError` if the start index is out of range.

Raises `ArgumentError` if count is negative.

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

def fill(value : T, range : Range) : self #

Replaces the elements within the given range with value. Returns `self`.

Negative indices count backward from the end of the container.

Raises `IndexError` 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]

def fill(value : T) : self #

Replaces every element in `self` with the given value. Returns `self`.

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

def index(object, offset : Int = 0) #
Description copied from module Indexable(T)

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

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

def map(&block : T -> U) : StaticArray(U, N) forall U #

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

def map_with_index(offset = 0, &block : T, Int32 -> U) : StaticArray(U, N) forall U #

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

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

def pretty_print(pp) #
def rotate!(n : Int = 1) : self #

Shifts all elements of `self` to the left n times. Returns `self`.

    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]

def size : Int32 #

Returns the size of `self`

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

def sort : StaticArray(T, N) #

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

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

See `Indexable::Mutable#sort!` for details on the sorting mechanism.

Raises `ArgumentError` if the comparison between any two elements returns `nil`.

def sort(&block : T, T -> U) : StaticArray(T, N) forall U #

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]

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

Raises `ArgumentError` if for any two elements the block returns `nil`.=

def sort! : self #

Sorts all elements in `self` based on the return value of the comparison method `T#<=>` (see `Comparable#<=>`), using a stable sort algorithm.

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

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

See `Slice#sort!` for details on the implementation.

Raises `ArgumentError` if the comparison between any two elements returns `nil`.

def sort!(&block : T, T -> U) : self forall U #

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

The block must implement a comparison between two elements a and b, where `a < b` returns `-1`, `a == b` returns `0`, and `a > b` returns `1`. 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 modifies `self`. See `#sort(&block : T, T -> U)` for a non-modifying option that allocates a new instance.

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

Raises `ArgumentError` if for any two elements the block returns `nil`.

def sort_by(&block : T -> _) : StaticArray(T, N) #

Returns a new instance with all elements sorted by the output value of the block. The output values are compared via the comparison method `T#<=>` (see `Comparable#<=>`), 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.

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

Raises `ArgumentError` if the comparison between any two comparison values returns `nil`.

def sort_by!(&block : T -> _) : self #

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

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

This sort operation modifies `self`. 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.

Raises `ArgumentError` if the comparison between any two comparison values returns `nil`.

def to_json(json : JSON::Builder) : Nil #
def to_s(io : IO) : Nil #

Appends a string representation of this static array to the given `IO`.

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

def to_slice : Slice(T) #

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]

def to_unsafe : Pointer(T) #

Returns a pointer to this static array's data.

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

def unsafe_fetch(index : Int) : T #
Description copied from module Indexable(T)

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 `#[](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.

def unsafe_put(index : Int, value : T) #
Description copied from module Indexable::Mutable(T)

Sets the element at the given index to value, without doing any bounds check.

`Indexable::Mutable` 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 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.

def unstable_sort : StaticArray(T, N) #

Returns a new instance with all elements sorted based on the return value of their comparison method `T#<=>` (see `Comparable#<=>`), using an unstable sort algorithm.

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

See `Indexable::Mutable#unstable_sort!` for details on the sorting mechanism.

Raises `ArgumentError` if the comparison between any two elements returns `nil`.

def unstable_sort(&block : T, T -> U) : StaticArray(T, N) forall U #

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]

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

Raises `ArgumentError` if for any two elements the block returns `nil`.

def unstable_sort! : self #

Sorts all elements in `self` based on the return value of the comparison method `T#<=>` (see `Comparable#<=>`), using an unstable sort algorithm.

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

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

See `Slice#unstable_sort!` for details on the implementation.

Raises `ArgumentError` if the comparison between any two elements returns `nil`.

def unstable_sort!(&block : T, T -> U) : self forall U #

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

The block must implement a comparison between two elements a and b, where `a < b` returns `-1`, `a == b` returns `0`, and `a > b` returns `1`. 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 modifies `self`. See `#unstable_sort(&block : T, T -> U)` for a non-modifying option that allocates a new instance.

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

Raises `ArgumentError` if for any two elements the block returns `nil`.

def unstable_sort_by(&block : T -> _) : StaticArray(T, N) #

Returns a new instance with all elements sorted by the output value of the block. The output values are compared via the comparison method `#<=>` (see `Comparable#<=>`), 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.

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

Raises `ArgumentError` if the comparison between any two comparison values returns `nil`.

def unstable_sort_by!(&block : T -> _) : self #

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

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

This sort operation modifies `self`. 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.

Raises `ArgumentError` if the comparison between any two comparison values returns `nil`.