Allow, destructuring hashes, closes #47

evaluator/evaluator.go

@@ -82,8 +82,7 @@ func Eval(node ast.Node, env *object.Environment) object.Object {
 		return &object.Number{Token: node.Token, Value: node.Value}
 
 	case *ast.NullLiteral:
-		return &object.Null{Token: node.Token}
-		// return NULL
+		return NULL
 
 	case *ast.StringLiteral:
 		return &object.String{Token: node.Token, Value: node.Value}
@@ -321,20 +320,31 @@ func evalAssignment(as *ast.AssignStatement, env *object.Environment) object.Obj
 
 	// destructuring x, y = [1, 2]
 	if len(as.Names) > 0 {
-		if val.Type() != object.ARRAY_OBJ {
-			return newError(as.Token, "wrong assignment, expected identifier or array destructuring, got %s (%s)", val.Type(), val.Inspect())
-		}
-
-		elements := val.(*object.Array).Elements
+		switch v := val.(type) {
+		case *object.Array:
+			elements := v.Elements
+			for i, name := range as.Names {
+				if i < len(elements) {
+					env.Set(name.String(), elements[i])
+					continue
+				}
 
-		for i, name := range as.Names {
-			if i < len(elements) {
-				env.Set(name.String(), elements[i])
-				continue
+				env.Set(name.String(), NULL)
 			}
-
-			env.Set(name.String(), NULL)
+		case *object.Hash:
+			for _, name := range as.Names {
+				x, ok := v.GetPair(name.String())
+
+				if ok {
+					env.Set(name.String(), x.Value)
+				} else {
+					env.Set(name.String(), NULL)
+				}
+			}
+		default:
+			return newError(as.Token, "wrong assignment, expected identifier or array destructuring, got %s (%s)", val.Type(), val.Inspect())
 		}
+
 		return nil
 	}
 	// support assignment to indexed expressions: a[0] = 1, h["a"] = 1

evaluator/evaluator_test.go

@@ -492,7 +492,9 @@ func TestAssignStatements(t *testing.T) {
 		{"a = 5; b = a; b;", 5},
 		{"a = 5; b = a; c = a + b + 5; c;", 15},
 		{"a, b, c = [1]; a;", 1},
+		{`a, b, c = {"a": 1}; a;`, 1},
 		{"a, b, c = [1]; b;", nil},
+		{`a, b, c = {"a": 1}; b;`, nil},
 		{`a = 10 + 1 + 2
 b, c = [1, 2]; b`, 1},
 		{`a = 10 + 1 + 2

object/object.go

@@ -237,6 +237,12 @@ type Hash struct {
 }
 
 func (h *Hash) Type() ObjectType { return HASH_OBJ }
+func (h *Hash) GetPair(key string) (HashPair, bool) {
+	record, ok := h.Pairs[HashKey{Type: "STRING", Value: key}]
+
+	return record, ok
+}
+
 func (h *Hash) Inspect() string {
 	var out bytes.Buffer