Creates a tuple from the given array, with elements casted to the given types.

Tuple(String, Int64).from(["world", 2_i64])       # => {"world", 2_i64}
Tuple(String, Int64).from(["world", 2_i64]).class # => Tuple(String, Int64)

See also: #from.

Creates a tuple that will contain the given values.

This method is useful in macros and generic code because with it you can create empty tuples, something that you can't do with a tuple literal.

Tuple.new(1, "hello", 'x') #=> {1, "hello", 'x'}
Tuple.new                  #=> {}

{}                         # syntax error

Returns the element type at the given index. Read the type docs to understand the difference between indexing with a number literal or a variable.

alias Foo = Tuple(Int32, String)
Foo[0]      # => Int32
Foo[0].zero # => 0
Foo[2]      # Error: index out of bounds for Tuple(Int32, String).class (2 not in -2..1)

i = 0
Foo[i]      # => Int32
Foo[i].zero # Error: undefined method 'zero' for String.class (compile-time type is (Int32.class | String.class))

i = 2
Foo[i] # raises IndexError

Returns all element types that are within the given range. range must be a range literal whose value is known at compile-time.

Negative indices count backward from the end of the tuple (-1 is the last element). Additionally, an empty tuple is returned when the starting index for an element range is at the end of the tuple.

Raises a compile-time error if range.begin is out of range.

alias Foo = Tuple(Int32, String, Char)
Foo[0..1] # => Tuple(Int32, String)
Foo[-2..] # => Tuple(String, Char)
Foo[...1] # => Tuple(Int32)
Foo[4..]  # Error: begin index out of bounds for Tuple(Int32, String, Char).class (4 not in -3..3)

i = 0
Foo[i..2] # Error: Tuple.[](Range) can only be called with range literals known at compile-time

i = 0..2
Foo[i] # Error: Tuple.[](Range) can only be called with range literals known at compile-time

Returns the element type at the given index or nil if out of bounds. Read the type docs to understand the difference between indexing with a number literal or a variable.

alias Foo = Tuple(Int32, String)
Foo[0]?         # => Int32
Foo[0]?.zero    # => 0
Foo[2]?         # => nil
typeof(Foo[2]?) # => Nil

i = 0
Foo[i]?      # => Int32
Foo[i]?.zero # Error: undefined method 'zero' for String.class (compile-time type is (Int32.class | String.class | Nil))

i = 2
Foo[i]? # => nil

Returns the types of this tuple type.

tuple = {1, "hello", 'x'}
tuple.class.types # => {Int32, String, Char}

Returns a tuple that contains self's elements followed by other's elements.

t1 = {1, 2}
t2 = {"foo", "bar"}
t3 = t1 + t2
t3         # => {1, 2, "foo", "bar"}
typeof(t3) # => Tuple(Int32, Int32, String, String)

The comparison operator.

Each object in each tuple is compared using the <=> operator.

Tuples are compared in an "element-wise" manner; the first element of this tuple is compared with the first one of other using the <=> operator, then each of the second elements, etc. As soon as the result of any such comparison is non-zero (i.e. the two corresponding elements are not equal), that result is returned for the whole tuple comparison.

If all the elements are equal, then the result is based on a comparison of the tuple sizes. Thus, two tuples are "equal" according to <=> if, and only if, they have the same size and the value of each element is equal to the value of the corresponding element in the other tuple.

{"a", "a", "c"} <=> {"a", "b", "c"} # => -1
{1, 2, 3, 4, 5, 6} <=> {1, 2}       # => 1
{1, 2} <=> {1, 2.0}                 # => 0

The comparison operator.

Each object in each tuple is compared using the <=> operator.

Tuples are compared in an "element-wise" manner; the first element of this tuple is compared with the first one of other using the <=> operator, then each of the second elements, etc. As soon as the result of any such comparison is non-zero (i.e. the two corresponding elements are not equal), that result is returned for the whole tuple comparison.

If all the elements are equal, then the result is based on a comparison of the tuple sizes. Thus, two tuples are "equal" according to <=> if, and only if, they have the same size and the value of each element is equal to the value of the corresponding element in the other tuple.

{"a", "a", "c"} <=> {"a", "b", "c"} # => -1
{1, 2, 3, 4, 5, 6} <=> {1, 2}       # => 1
{1, 2} <=> {1, 2.0}                 # => 0

Returns true if this tuple has the same size as the other tuple and their elements are equal to each other when compared with #==.

t1 = {1, "hello"}
t2 = {1.0, "hello"}
t3 = {2, "hello"}

t1 == t2 # => true
t1 == t3 # => false

Returns true if this tuple has the same size as the other tuple and their elements are equal to each other when compared with #==.

t1 = {1, "hello"}
t2 = {1.0, "hello"}
t3 = {2, "hello"}

t1 == t2 # => true
t1 == t3 # => false

Returns false.

Returns true if case equality holds for the elements in self and other.

{1, 2} === {1, 2} # => true
{1, 2} === {1, 3} # => false

See also: Object#===.

Returns true if self and other have the same size and case equality holds for the elements in self and other.

{1, 2} === {1, 2, 3}             # => false
{/o+/, "bar"} === {"foo", "bar"} # => true

See also: Object#===.

Returns the element at the given index. Read the type docs to understand the difference between indexing with a number literal or a variable.

tuple = {1, "hello", 'x'}
tuple[0]         # => 1
typeof(tuple[0]) # => Int32
tuple[3]         # Error: index out of bounds for Tuple(Int32, String, Char) (3 not in -3..2)

i = 0
tuple[i]         # => 1
typeof(tuple[i]) # => (Char | Int32 | String)

i = 3
tuple[i] # raises IndexError

Returns all elements that are within the given range. range must be a range literal whose value is known at compile-time.

Negative indices count backward from the end of the tuple (-1 is the last element). Additionally, an empty tuple is returned when the starting index for an element range is at the end of the tuple.

Raises a compile-time error if range.begin is out of range.

tuple = {1, "hello", 'x'}
tuple[0..1] # => {1, "hello"}
tuple[-2..] # => {"hello", 'x'}
tuple[...1] # => {1}
tuple[4..]  # Error: begin index out of bounds for Tuple(Int32, String, Char) (4 not in -3..3)

i = 0
tuple[i..2] # Error: Tuple#[](Range) can only be called with range literals known at compile-time

i = 0..2
tuple[i] # Error: Tuple#[](Range) can only be called with range literals known at compile-time

Returns the element at the given index or nil if out of bounds. Read the type docs to understand the difference between indexing with a number literal or a variable.

tuple = {1, "hello", 'x'}
tuple[0]?         # => 1
typeof(tuple[0]?) # => Int32
tuple[3]?         # => nil
typeof(tuple[3]?) # => Nil

i = 0
tuple[i]?         # => 1
typeof(tuple[i]?) # => (Char | Int32 | String | Nil)

i = 3
tuple[i]? # => nil

Returns the element at the given index or raises IndexError if out of bounds.

tuple = {1, "hello", 'x'}
tuple.at(0) # => 1
tuple.at(3) # raises IndexError

Returns the element at the given index or the value returned by the block if out of bounds.

tuple = {1, "hello", 'x'}
tuple.at(0) { 10 } # => 1
tuple.at(3) { 10 } # => 10

Returns a tuple containing cloned elements of this tuple using the #clone method.

Yields each of the elements in this tuple.

tuple = {1, "hello", 'x'}
tuple.each do |value|
  puts value
end

Output:

1
"hello"
'x'

Returns the first element of this tuple. Doesn't compile if the tuple is empty.

tuple = {1, 2.5}
tuple.first # => 1

Returns the first element of this tuple, or nil if this is the empty tuple.

tuple = {1, 2.5}
tuple.first? # => 1

empty = Tuple.new
empty.first? # => nil

Expects to be called on a tuple of types, creates a tuple from the given array, with types casted appropriately.

This allows you to easily pass an array as individual arguments to a method.

require "json"

def speak_about(thing : String, n : Int64)
  "I see #{n} #{thing}s"
end

data = JSON.parse(%(["world", 2])).as_a.map(&.raw)
speak_about(*{String, Int64}.from(data)) # => "I see 2 worlds"

See Object#hash(hasher)

Same as #to_s.

Returns the last element of this tuple. Doesn't compile if the tuple is empty.

tuple = {1, 2.5}
tuple.last # => 2.5

Returns the last element of this tuple, or nil if this is the empty tuple.

tuple = {1, 2.5}
tuple.last? # => 2.5

empty = Tuple.new
empty.last? # => nil

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

tuple = {1, 2.5, "a"}
tuple.map &.to_s # => {"1", "2.5", "a"}

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

tuple = {1, 2.5, "a"}
tuple.map_with_index { |e, i| "tuple[#{i}]: #{e}" } # => {"tuple[0]: 1", "tuple[1]: 2.5", "tuple[2]: a"}

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

Just like the other variant, but you can set the initial value of the accumulator.

[1, 2, 3, 4, 5].reduce(10) { |acc, i| acc + i }             # => 25
[1, 2, 3].reduce([] of Int32) { |memo, i| memo.unshift(i) } # => [3, 2, 1]

Combines all elements in the collection by applying a binary operation, specified by a block, so as to reduce them to a single value.

For each element in the collection the block is passed an accumulator value (memo) and the element. The result becomes the new value for memo. At the end of the iteration, the final value of memo is the return value for the method. The initial value for the accumulator is the first element in the collection. If the collection has only one element, that element is returned.

Raises Enumerable::EmptyError if the collection is empty.

[1, 2, 3, 4, 5].reduce { |acc, i| acc + i } # => 15
[1].reduce { |acc, i| acc + i }             # => 1
([] of Int32).reduce { |acc, i| acc + i }   # raises Enumerable::EmptyError

The block is not required to return a T, in which case the accumulator's type includes whatever the block returns.

# `acc` is an `Int32 | String`
[1, 2, 3, 4, 5].reduce { |acc, i| "#{acc}-#{i}" } # => "1-2-3-4-5"
[1].reduce { |acc, i| "#{acc}-#{i}" }             # => 1

Similar to #reduce, but instead of raising when the input is empty, return nil

([] of Int32).reduce? { |acc, i| acc + i } # => nil

Returns a new tuple where the elements are in reverse order.

tuple = {1, 2.5, "a"}
tuple.reverse # => {"a", 2.5, 1}

Yields each of the elements in this tuple in reverse order.

tuple = {1, "hello", 'x'}
tuple.reverse_each do |value|
  puts value
end

Output:

'x'
"hello"
1

Returns the number of elements in this tuple.

{'a', 'b'}.size # => 2

Returns an Array with all the elements in the tuple.

{1, 2, 3, 4, 5}.to_a # => [1, 2, 3, 4, 5]

Returns an Array with the results of running block against each element of the tuple.

{1, 2, 3, 4, 5}).to_a { |i| i * 2 } # => [2, 4, 6, 8, 10]

Appends a string representation of this tuple to the given IO.

tuple = {1, "hello"}
tuple.to_s # => "{1, \"hello\"}"

Returns a StaticArray with the same elements.

The element type is Union(*T).

{1, 'a', true}.to_static_array # => StaticArray[1, 'a', true]

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.