Add ability to evaluate dictionaries

Author: AvicennaJr

evaluator/evaluator.go

@@ -103,6 +103,8 @@ func Eval(node ast.Node, env *object.Environment) object.Object {
 			return index
 		}
 		return evalIndexExpression(left, index)
+	case *ast.DictLiteral:
+		return evalDictLiteral(node, env)
 
 	}
 
@@ -351,6 +353,8 @@ func evalIndexExpression(left, index object.Object) object.Object {
 	switch {
 	case left.Type() == object.ARRAY_OBJ && index.Type() == object.INTEGER_OBJ:
 		return evalArrayIndexExpression(left, index)
+	case left.Type() == object.DICT_OBJ:
+		return evalDictIndexExpression(left, index)
 	default:
 		return newError("Operesheni hii haiwezekani kwa: %s", left.Type())
 	}
@@ -367,3 +371,45 @@ func evalArrayIndexExpression(array, index object.Object) object.Object {
 
 	return arrayObject.Elements[idx]
 }
+
+func evalDictLiteral(node *ast.DictLiteral, env *object.Environment) object.Object {
+	pairs := make(map[object.HashKey]object.DictPair)
+
+	for keyNode, valueNode := range node.Pairs {
+		key := Eval(keyNode, env)
+		if isError(key) {
+			return key
+		}
+
+		hashKey, ok := key.(object.Hashable)
+		if !ok {
+			return newError("Hashing imeshindikana: %s", key.Type())
+		}
+
+		value := Eval(valueNode, env)
+		if isError(value) {
+			return value
+		}
+
+		hashed := hashKey.HashKey()
+		pairs[hashed] = object.DictPair{Key: key, Value: value}
+	}
+
+	return &object.Dict{Pairs: pairs}
+}
+
+func evalDictIndexExpression(dict, index object.Object) object.Object {
+	dictObject := dict.(*object.Dict)
+
+	key, ok := index.(object.Hashable)
+	if !ok {
+		return newError("Samahani, %s haitumiki kama key", index.Type())
+	}
+
+	pair, ok := dictObject.Pairs[key.HashKey()]
+	if !ok {
+		return NULL
+	}
+
+	return pair.Value
+}

evaluator/evaluator_test.go

@@ -216,6 +216,10 @@ kama (10 > 1) {
 			`"Habari" - "Habari"`,
 			"Operesheni Haielweki: NENO - NENO",
 		},
+		{
+			`{"jina": "Avi"}[fn(x) {x}];`,
+			"Samahani, FUNCTION haitumiki kama key",
+		},
 	}
 
 	for _, tt := range tests {
@@ -337,11 +341,11 @@ func TestBuiltinFunctions(t *testing.T) {
 		input    string
 		expected interface{}
 	}{
-		{`len("")`, 0},
-		{`len("four")`, 4},
-		{`len("hello world")`, 11},
-		{`len(1)`, "Samahani, hii function haitumiki na NAMBARI"},
-		{`len("one", "two")`, "Hoja hazilingani, tunahitaji=1, tumepewa=2"},
+		{`idadi("")`, 0},
+		{`idadi("four")`, 4},
+		{`idadi("hello world")`, 11},
+		{`idadi(1)`, "Samahani, hii function haitumiki na NAMBARI"},
+		{`idadi("one", "two")`, "Hoja hazilingani, tunahitaji=1, tumepewa=2"},
 	}
 
 	for _, tt := range tests {
@@ -426,3 +430,89 @@ func TestArrayIndexExpressions(t *testing.T) {
 		}
 	}
 }
+
+func TestDictLiterals(t *testing.T) {
+	input := `acha two = "two";
+{
+	"one": 10 - 9,
+	two: 1 +1,
+	"thr" + "ee": 6 / 2,
+	4: 4,
+	kweli: 5,
+	sikweli: 6
+}`
+
+	evaluated := testEval(input)
+	result, ok := evaluated.(*object.Dict)
+	if !ok {
+		t.Fatalf("Eval didn't return a dict, got=%T(%+v)", evaluated, evaluated)
+	}
+
+	expected := map[object.HashKey]int64{
+		(&object.String{Value: "one"}).HashKey():   1,
+		(&object.String{Value: "two"}).HashKey():   2,
+		(&object.String{Value: "three"}).HashKey(): 3,
+		(&object.Integer{Value: 4}).HashKey():      4,
+		TRUE.HashKey():                             5,
+		FALSE.HashKey():                            6,
+	}
+
+	if len(result.Pairs) != len(expected) {
+		t.Fatalf("Dict has wrong number of pairs, got=%d", len(result.Pairs))
+	}
+
+	for expectedKey, expectedValue := range expected {
+		pair, ok := result.Pairs[expectedKey]
+		if !ok {
+			t.Errorf("No pair for give key")
+		}
+
+		testIntegerObject(t, pair.Value, expectedValue)
+	}
+}
+
+func TestDictIndexExpression(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected interface{}
+	}{
+		{
+			`{"foo": 5}["foo"]`,
+			5,
+		},
+		{
+			`{"foo": 5}["bar"]`,
+			nil,
+		},
+		{
+			`acha key = "foo"; {"foo": 5}[key]`,
+			5,
+		},
+		{
+			`{}["foo"]`,
+			nil,
+		},
+		{
+			`{5: 5}[5]`,
+			5,
+		},
+		{
+			`{kweli: 5}[kweli]`,
+			5,
+		},
+		{
+			`{sikweli: 5}[sikweli]`,
+			5,
+		},
+	}
+
+	for _, tt := range tests {
+		evaluated := testEval(tt.input)
+		integer, ok := tt.expected.(int)
+		if ok {
+			testIntegerObject(t, evaluated, int64(integer))
+		} else {
+			testNullObject(t, evaluated)
+		}
+	}
+}

examples/example.nr

@@ -76,3 +76,15 @@ acha salamu = fn() {
     }
 
 chapa(salamu());
+
+/*
+Multiline comment
+*/
+
+// test dictionaries
+
+chapa("Testing dictionaries...")
+
+acha watu = [{"jina": "Mojo", "kabila": "Mnyakusa"}, {"jina": "Avi", "kabila": "Mwarabu wa dubai"}]
+
+chapa(watu, watu[0], watu[0]["jina"], watu[0]["kabila"])