feat(types): list

Author: anhgelus

parser/types/value.go

@@ -1,5 +1,7 @@
 package types
 
+import "fmt"
+
 type Value interface {
 	Type() Type
 	Value() interface{}
@@ -8,6 +10,7 @@ type Value interface {
 type ValueContainer interface {
 	AddValues(...Value)
 	GetValues() []Value
+	CanContain(Value) bool
 }
 
 type Tuple []Value
@@ -32,6 +35,44 @@ func (t *Tuple) GetValues() []Value {
 	return *t
 }
 
+func (t *Tuple) CanContain(Value) bool {
+	return true
+}
+
+type List []Value
+
+func (l *List) Type() Type {
+	return NewListType((*l)[0].Type()) // if the list is empty, the program crashes
+}
+
+func (l *List) Value() interface{} {
+	return l.GetValues()
+}
+
+func (l *List) AddValues(v ...Value) {
+	for _, value := range v {
+		if len(*l) == 0 {
+			*l = append(*l, value)
+		} else {
+			if !value.Type().Is((*l)[0].Type()) {
+				panic(fmt.Errorf("invalid list: cannot create a non homogene list"))
+			}
+			*l = append(*l, value)
+		}
+	}
+}
+
+func (l *List) GetValues() []Value {
+	return *l
+}
+
+func (l *List) CanContain(v Value) bool {
+	if len(*l) == 0 {
+		return true
+	}
+	return v.Type().Is((*l)[0].Type())
+}
+
 type Literal struct {
 	string
 	t Type

parser/types/value_test.go

@@ -52,4 +52,63 @@ func TestTuple(t *testing.T) {
 			t.Error("Expected C, got", v)
 		}
 	}
+	if !tuple.CanContain(new(List)) {
+		t.Error("Tuple must be able to contain anything")
+	}
+}
+
+func TestList(t *testing.T) {
+	list := new(List)
+	list.AddValues(Int(1), Int(2), Int(3))
+	if !list.Type().Is(NewListType(IntType)) {
+		t.Error("Expected int, got", list.Type())
+	}
+	val := list.Value().([]Value)
+	for i, value := range list.GetValues() {
+		if val[i] != value {
+			t.Error("Expected", value, "got", val[i])
+		}
+	}
+	if len(val) != 3 {
+		t.Error("Expected 3, got", len(val))
+	}
+	if !val[0].Type().Is(IntType) {
+		t.Error("Expected string, got", val[0].Type())
+	}
+	v, ok := val[0].Value().(int)
+	if !ok {
+		t.Error("Cannot convert value to string")
+	} else {
+		if v != 1 {
+			t.Error("Expected 1, got", v)
+		}
+	}
+	if !val[1].Type().Is(IntType) {
+		t.Error("Expected int, got", val[1].Type())
+	}
+	vi, ok := val[1].Value().(int)
+	if !ok {
+		t.Error("Cannot convert value to int")
+	} else {
+		if vi != 2 {
+			t.Error("Expected 2, got", vi)
+		}
+	}
+	if !val[2].Type().Is(IntType) {
+		t.Error("Expected int, got", val[2].Type())
+	}
+	v, ok = val[2].Value().(int)
+	if !ok {
+		t.Error("Cannot convert value to string")
+	} else {
+		if v != 3 {
+			t.Error("Expected 3, got", v)
+		}
+	}
+	if !list.CanContain(Int(0)) {
+		t.Error("List must be able to contain the same type")
+	}
+	if list.CanContain(String("A")) {
+		t.Error("List must contain only values with the same type")
+	}
 }