add basic support for tuples

core/compiler.go

@@ -193,6 +193,18 @@ func (c *Compiler) compile(tree Node) error {
 		panic("compile called with nil value")
 	}
 
+	if c.optimize && c.isTreeConstant(tree) {
+		v, err := c.compute(tree)
+		if err != nil {
+			panic(err) // this shouldn't happen
+		}
+
+		c.add(InstructionConstant)
+		c.addConstant(v)
+
+		return nil
+	}
+
 	switch tree.Type() {
 	case StringNodeType:
 		n := tree.(*StringNode)
@@ -236,19 +248,23 @@ func (c *Compiler) compile(tree Node) error {
 		c.add(InstructionConstant)
 		c.addConstant(&IntegerValue{tree.(*IntegerNode).value})
 
+	case TupleNodeType:
+		n := tree.(*TupleNode)
+
+		for _, n := range n.items {
+			err := c.compile(n)
+			if err != nil {
+				return err
+			}
+		}
+		c.add(InstructionFormTuple)
+		c.addU16(uint16(len(n.items)))
+
 	case ListNodeType:
 		l := tree.(*ListNode)
 
 		if len(l.items) == 0 {
 			c.add(InstructionNewList)
-		} else if c.optimize && c.isTreeConstant(l) {
-			v, err := c.compute(l)
-			if err != nil {
-				panic(err) // this shouldn't happen
-			}
-
-			c.add(InstructionConstant)
-			c.addConstant(v)
 		} else {
 			for _, n := range l.items {
 				err := c.compile(n)
@@ -1001,6 +1017,21 @@ func (c *Compiler) deduceSignature(tree Node) (TypeSignature, error) {
 		return c.deduceSignature(n.statements[len(n.statements)-1])
 	case AssignNodeType:
 		return c.deduceSignature(tree.(*AssignNode).value)
+	case TupleNodeType:
+		n := tree.(*TupleNode)
+
+		var items []TypeSignature
+		for _, i := range n.items {
+			t, err := c.deduceSignature(i)
+			if err != nil {
+				return nil, err
+			}
+			items = append(items, t)
+		}
+
+		return &TupleSignature{
+			items,
+		}, nil
 	default:
 		return nil, c.error(fmt.Sprintf("impossible to deduce signature of %s", tree.Type()), tree)
 	}