.. _tuples:

=====
元组
=====

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

    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

元组遵循与结构相同的对齐规则(参阅 :ref:`Structures <structs_alignment>`).

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

    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")
    }