Tuples
Tuples are a special kind of Record Types that do not give any particular names to the fields.
Tuples are particularly useful for features that return more than one value.
Fuzion provides a generic feature tuple
in its standard library
for tuples. Some syntactic sugar enables a concise notation. A similar notation
is used for record destructuring, which will be explained here as well.
Tuples Example
Imagine you want to implement a feature that takes a 32-bit integer value and
splits it into four bytes that start with the highest eight bits of the value
and go down to the lowest eight bits. One way to achieve this is to return an
instance of tuple
as follows:
In this example, feature bytes
returns a tuple
with
the actual formal generic parameters being four times i32
. The
result is set to an instance of this tuple type with the four values set to the
four bytes extracted from the argument value v
.
bytes
is then called and the result is assigned to a
field b
of the tuple
type with the same actual generic
parameters. These values are then extracted into fields b0
through b3
using the tuple
's value
field
with open generic discriminators .0
through .3
.
Simplified Tuple Syntax
Syntactic sugar greatly simplifies this code: First an expression that defines a tuple such as
x tuple T0 T1 := tuple v0 v1
is equivalent to an expression using parentheses
x := (v0, v1)
This syntax also works for an empty tuple, i.e.,
e := ()
is equivalent to
e tuple := tuple
However, to avoid confusion between expressions in parentheses and tuples, a 1-tuple cannot be defined using
e := (v1)
.
Destructuring
Note: This is called destructuring in other languages. (Javascript etc.)
Destructuring can be used to extract the values from a tuple, i.e., for
a tuple
with two values, the code
v0 := x.values.0 v1 := x.values.1or (using syntax sugar):
v0 := x.0 v1 := x.1
is equivalent to
(v0, v1) := x
Destructuring can also be used without type inference using =
as follows
(v0 T0, v1 T1) := x
or if T0
and T1
are equal
(v0, v1 T0) := x
An underscore _
can be used to ignore values:
(v0, _) := x
Simplified Example
Applying this syntactic sugar and some type inference to the previous example, the code becomes shorter and clearer:
Crazy Stuff
TBW: Does it make sense to inherit from a tuple? At least it does not compile at this point: