struct StaticArray(T, N)
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
Defined in:
json/to_json.crstatic_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.
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 inself
. -
#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, ornil
if object is not inself
. -
#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#<=>
(seeComparable#<=>
), 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 methodT#<=>
(seeComparable#<=>
), 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#<=>
(seeComparable#<=>
), 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 methodT#<=>
(seeComparable#<=>
), 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.
Macro Summary
-
[](*args)
Creates a new
StaticArray
with the given args.
Instance methods inherited from module Indexable::Mutable(T)
[]=(index : Int, value : T) : T
[]=,
fill(value : T, start : Int, count : Int) : selffill(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 = Random::DEFAULT) : 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, 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 = Random::DEFAULT) : Array(T)
sample(random : Random = Random::DEFAULT) 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 Uaccumulate : 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!, 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 = Random::DEFAULT) : Array(T)
sample(random : Random = Random::DEFAULT) : 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 : 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, root : String)from_json(string_or_io) from_json, from_yaml(string_or_io : String | IO) from_yaml
Constructor Detail
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]
Instance Method Detail
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]
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
Equality with another object. Always returns false
.
array = StaticArray(Int32, 3).new 0 # => StaticArray[0, 0, 0]
array == nil # => false
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]
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]
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]
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
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 optional offset parameter, which tells it to start counting from there.
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]
Returns the size of self
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 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
.
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
.=
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
.
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
.
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
.
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
.
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]"
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 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.
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.
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
.
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
.
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
.
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
.
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
.
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
.
Macro Detail
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.