Tuple objects are common in Alore programs, and the type system has a rich set of types for representing tuples.
For example, consider a simple 2-tuple type (Int, Str). The first item is an integer and the second item a string. The program below defines t with type (Int, Str) and assigns a tuple value to it:
var t as (Int, Str) t = 2, 'foo'
When you access tuple items using an integer literal, the type checker infers the type precisely:
t -- Type Int t -- Type Str
You can use tuples as rvalues in multiple variable definition (and assignment). Type inference works for local variables:
def f() as void var s, i = 'foo', 1 -- Infer s to be Str and i to be Int end
Next we willl show how to give the variable types explicitly.
If you define multiple variables using var and cannot use type inference, you can define the variable types using a tuple type:
var i, s as (Int, Str) -- i has type Int, s has type Str i = 1 s = 'foo'
The same syntax also supports an initializer:
var i, s = (1, 'foo') as (Int, Str)
Note that in the above example the as (...) construct applies to the variable definition (var i, s = ...), not to the tuple expression.
You can use tuple types for multiple assignment:
var i as Int var s as Str i, s = 1, 'foo' -- Rvalue type is (Int, Str)
Note that parentheses are optional in tuple expressions, but not in tuple types.
Here is the above example spelled out with added steps for clarity:
var t as (Int, Str) -- Parentheses are required here var i as Int var s as Str t = (1, 'foo') -- Parentheses are optional here i, s = t
More generally, a tuple type (T1, T2, ...) represents a tuple that has T1 as the first item type, T2 as the second item type, etc. Empty tuples and 1-tuples are special:
- () is the empty tuple type.
- (T,) is a 1-tuple (note the extra comma).
The example programs above relied on type inference when constructing tuples. You can also give the types explicitly using the now-familiar syntax (note that the parentheses are necessary due to precedence):
t = (2, 'foo') as <Int, Str>
The runtime type of all tuples is Tuple, independent of the number of items and their types. Tuple also acts as the supertype of all tuple types. Values of type Tuple support all tuple operations, but they do not include precise tuple item type information.
All tuple items have type Object when accessed using a Tuple value:
var t as Tuple t = (1, 'x') -- Ok t -- Type Object, not Int, since accessing using type Tuple