2.18. 元组

元组是创建无名数据结构的简洁语法:

tuple ::= tuple < element_list >
element_list ::= nameless_element_list | named_element_list
nameless_element_list ::= type | nameless_element_list ',' type
named_element_list := name : type | named_element_list ',' name : type

如果两个 元组 声明具有相同的类型数，并且它们各自的类型相同，则它们是相同的:

var a : tuple<int, float>
var b : tuple<i:int, f:float>
a = b

元组 元素可以通过无名字段访问，即 _ 后跟 0 基字段索引:

a._0 = 1
a._1 = 2.0

命名元组元素可以通过 name 和 nameless field 访问:

b.i = 1         // same as _0
b.f = 2.0       // same as _1
b._1 = 2.0      // _1 is also available

元组遵循与结构相同的对齐规则(参阅 Structures).

元组别名类型的构造方式与结构相同。例如:

tuple Foo {
    a : int
    b : float
}

它与以下相同:

typedef Foo = tuple<a:int,b:float>

可以使用 元组 构造函数构造 元组，例如:

var a = (1,2.0,"3")
var b = tuple(1, 2.0, "3")

可以通过 元组 构造函数为 元组 元素分配名称:

var a = tuple<a:int,b:float,c:string>(a=1, b=2.0, c="3")

两者都可以使用 auto a full 类型规范来构造 Tuples。 可以使用类似的语法构造元组数组，以逗号作为分隔符:

let H : array<Tup> <- array tuple<Tup>((a = 1, b = 2., c = "3"), (a = 4, b = 5., c = "6"))

元组可以在变量声明时进行扩展，例如:

var (a, b, c) = (1, 2.0, "3")

在这种情况下，只创建一个变量，以及 assume 表达式。即:

var a`b`c = (1, 2.0, "3")
assume a  = a`b`c._0
assume b  = a`b`c._1
assume c  = a`b`c._2

迭代器和容器可以以类似的方式在 for 循环中扩展:

var H <- [(1, 2.0, "3"), (4, 5.0, "6")]
for ( (a, b, c) in H ) {
    assert(a == 1)
    assert(b == 2.0)
    assert(c == "3")
}