restructure project

2024-03-28 16:20:09 -04:00
parent 362138ff2e
commit fc6ceee02c
93 changed files with 479 additions and 194 deletions
--- a/internal/evaluator/evaluator.go
+++ b/internal/evaluator/evaluator.go
@@ -0,0 +1,685 @@
+package evaluator
+
+import (
+	"fmt"
+	"monkey/internal/ast"
+	"monkey/internal/builtins"
+	"monkey/internal/lexer"
+	"monkey/internal/object"
+	"monkey/internal/parser"
+	"monkey/internal/utils"
+	"os"
+	"strings"
+)
+
+var (
+	NULL  = &object.Null{}
+	TRUE  = &object.Boolean{Value: true}
+	FALSE = &object.Boolean{Value: false}
+)
+
+func isError(obj object.Object) bool {
+	if obj != nil {
+		return obj.Type() == object.ERROR_OBJ
+	}
+	return false
+}
+
+func Eval(node ast.Node, env *object.Environment) object.Object {
+	switch node := node.(type) {
+
+	// Statements
+	case *ast.Program:
+		return evalProgram(node, env)
+
+	case *ast.ExpressionStatement:
+		return Eval(node.Expression, env)
+
+	case *ast.BlockStatement:
+		return evalBlockStatements(node, env)
+
+	case *ast.IfExpression:
+		return evalIfExpression(node, env)
+
+	case *ast.WhileExpression:
+		return evalWhileExpression(node, env)
+
+	case *ast.ImportExpression:
+		return evalImportExpression(node, env)
+
+	case *ast.ReturnStatement:
+		val := Eval(node.ReturnValue, env)
+		if isError(val) {
+			return val
+		}
+		return &object.ReturnValue{Value: val}
+
+	case *ast.BindExpression:
+		value := Eval(node.Value, env)
+		if isError(value) {
+			return value
+		}
+
+		if ident, ok := node.Left.(*ast.Identifier); ok {
+			if immutable, ok := value.(object.Immutable); ok {
+				env.Set(ident.Value, immutable.Clone())
+			} else {
+				env.Set(ident.Value, value)
+			}
+
+			return NULL
+		}
+		return newError("expected identifier on left got=%T", node.Left)
+
+	case *ast.AssignmentExpression:
+		left := Eval(node.Left, env)
+		if isError(left) {
+			return left
+		}
+
+		value := Eval(node.Value, env)
+		if isError(value) {
+			return value
+		}
+
+		if ident, ok := node.Left.(*ast.Identifier); ok {
+			env.Set(ident.Value, value)
+		} else if ie, ok := node.Left.(*ast.IndexExpression); ok {
+			obj := Eval(ie.Left, env)
+			if isError(obj) {
+				return obj
+			}
+
+			if array, ok := obj.(*object.Array); ok {
+				index := Eval(ie.Index, env)
+				if isError(index) {
+					return index
+				}
+				if idx, ok := index.(*object.Integer); ok {
+					array.Elements[idx.Value] = value
+				} else {
+					return newError("cannot index array with %#v", index)
+				}
+			} else if hash, ok := obj.(*object.Hash); ok {
+				key := Eval(ie.Index, env)
+				if isError(key) {
+					return key
+				}
+				if hashKey, ok := key.(object.Hashable); ok {
+					hashed := hashKey.HashKey()
+					hash.Pairs[hashed] = object.HashPair{Key: key, Value: value}
+				} else {
+					return newError("cannot index hash with %T", key)
+				}
+			} else {
+				return newError("object type %T does not support item assignment", obj)
+			}
+		} else {
+			return newError("expected identifier or index expression got=%T", left)
+		}
+
+		return NULL
+
+	case *ast.Identifier:
+		return evalIdentifier(node, env)
+
+	case *ast.FunctionLiteral:
+		params := node.Parameters
+		body := node.Body
+		return &object.Function{Parameters: params, Env: env, Body: body}
+
+	// Expressions
+	case *ast.IntegerLiteral:
+		return &object.Integer{Value: node.Value}
+
+	case *ast.Boolean:
+		return nativeBoolToBooleanObject(node.Value)
+
+	case *ast.Null:
+		return NULL
+
+	case *ast.PrefixExpression:
+		right := Eval(node.Right, env)
+		if isError(right) {
+			return right
+		}
+		return evalPrefixExpression(node.Operator, right)
+
+	case *ast.InfixExpression:
+		left := Eval(node.Left, env)
+		if isError(left) {
+			return left
+		}
+		right := Eval(node.Right, env)
+		if isError(right) {
+			return right
+		}
+		return evalInfixExpression(node.Operator, left, right)
+
+	case *ast.CallExpression:
+		function := Eval(node.Function, env)
+		if isError(function) {
+			return function
+		}
+		args := evalExpressions(node.Arguments, env)
+		if len(args) == 1 && isError(args[0]) {
+			return args[0]
+		}
+
+		return applyFunction(function, args)
+
+	case *ast.StringLiteral:
+		return &object.String{Value: node.Value}
+
+	case *ast.ArrayLiteral:
+		elements := evalExpressions(node.Elements, env)
+		if len(elements) == 1 && isError(elements[0]) {
+			return elements[0]
+		}
+		return &object.Array{Elements: elements}
+
+	case *ast.IndexExpression:
+		left := Eval(node.Left, env)
+		if isError(left) {
+			return left
+		}
+		index := Eval(node.Index, env)
+		if isError(index) {
+			return index
+		}
+		return evalIndexExpression(left, index)
+
+	case *ast.HashLiteral:
+		return evalHashLiteral(node, env)
+
+	}
+
+	return nil
+}
+
+func evalImportExpression(ie *ast.ImportExpression, env *object.Environment) object.Object {
+	name := Eval(ie.Name, env)
+	if isError(name) {
+		return name
+	}
+
+	if s, ok := name.(*object.String); ok {
+		attrs := EvalModule(s.Value)
+		if isError(attrs) {
+			return attrs
+		}
+		return &object.Module{Name: s.Value, Attrs: attrs}
+	}
+	return newError("ImportError: invalid import path '%s'", name)
+}
+
+func evalWhileExpression(we *ast.WhileExpression, env *object.Environment) object.Object {
+	var result object.Object
+
+	for {
+		condition := Eval(we.Condition, env)
+		if isError(condition) {
+			return condition
+		}
+
+		if isTruthy(condition) {
+			result = Eval(we.Consequence, env)
+		} else {
+			break
+		}
+	}
+
+	if result != nil {
+		return result
+	}
+
+	return NULL
+}
+
+func evalProgram(program *ast.Program, env *object.Environment) object.Object {
+	var result object.Object
+
+	for _, statement := range program.Statements {
+		result = Eval(statement, env)
+
+		switch result := result.(type) {
+		case *object.ReturnValue:
+			return result.Value
+		case *object.Error:
+			return result
+		}
+
+	}
+
+	return result
+}
+
+func evalBlockStatements(block *ast.BlockStatement, env *object.Environment) object.Object {
+	var result object.Object
+
+	for _, statement := range block.Statements {
+		result = Eval(statement, env)
+
+		if result != nil {
+			rt := result.Type()
+			if rt == object.RETURN_VALUE_OBJ || rt == object.ERROR_OBJ {
+				return result
+			}
+		}
+	}
+
+	return result
+}
+
+func nativeBoolToBooleanObject(input bool) object.Object {
+	if input {
+		return TRUE
+	}
+	return FALSE
+}
+
+func evalPrefixExpression(operator string, right object.Object) object.Object {
+	switch operator {
+	case "!":
+		if right.Type() == object.BOOLEAN_OBJ {
+			return evalBooleanPrefixOperatorExpression(operator, right)
+		}
+		return evalIntegerPrefixOperatorExpression(operator, right)
+	case "~", "-":
+		return evalIntegerPrefixOperatorExpression(operator, right)
+	default:
+		return newError("unknown operator: %s%s", operator, right.Type())
+	}
+}
+
+func evalBooleanPrefixOperatorExpression(operator string, right object.Object) object.Object {
+	if right.Type() != object.BOOLEAN_OBJ {
+		return newError("unknown operator: %s%s", operator, right.Type())
+	}
+
+	switch right {
+	case TRUE:
+		return FALSE
+	case FALSE:
+		return TRUE
+	case NULL:
+		return TRUE
+	default:
+		return FALSE
+	}
+}
+
+func evalIntegerPrefixOperatorExpression(operator string, right object.Object) object.Object {
+	if right.Type() != object.INTEGER_OBJ {
+		return newError("unknown operator: -%s", right.Type())
+	}
+
+	value := right.(*object.Integer).Value
+	switch operator {
+	case "!":
+		return FALSE
+	case "~":
+		return &object.Integer{Value: ^value}
+	case "-":
+		return &object.Integer{Value: -value}
+	default:
+		return newError("unknown operator: %s", operator)
+	}
+}
+
+func evalInfixExpression(operator string, left, right object.Object) object.Object {
+	switch {
+
+	// {"a": 1} + {"b": 2}
+	case operator == "+" && left.Type() == object.HASH_OBJ && right.Type() == object.HASH_OBJ:
+		leftVal := left.(*object.Hash).Pairs
+		rightVal := right.(*object.Hash).Pairs
+		pairs := make(map[object.HashKey]object.HashPair)
+		for k, v := range leftVal {
+			pairs[k] = v
+		}
+		for k, v := range rightVal {
+			pairs[k] = v
+		}
+		return &object.Hash{Pairs: pairs}
+
+	// [1] + [2]
+	case operator == "+" && left.Type() == object.ARRAY_OBJ && right.Type() == object.ARRAY_OBJ:
+		leftVal := left.(*object.Array).Elements
+		rightVal := right.(*object.Array).Elements
+		elements := make([]object.Object, len(leftVal)+len(rightVal))
+		elements = append(leftVal, rightVal...)
+		return &object.Array{Elements: elements}
+
+	// [1] * 3
+	case operator == "*" && left.Type() == object.ARRAY_OBJ && right.Type() == object.INTEGER_OBJ:
+		leftVal := left.(*object.Array).Elements
+		rightVal := int(right.(*object.Integer).Value)
+		elements := leftVal
+		for i := rightVal; i > 1; i-- {
+			elements = append(elements, leftVal...)
+		}
+		return &object.Array{Elements: elements}
+
+	// 3 * [1]
+	case operator == "*" && left.Type() == object.INTEGER_OBJ && right.Type() == object.ARRAY_OBJ:
+		leftVal := int(left.(*object.Integer).Value)
+		rightVal := right.(*object.Array).Elements
+		elements := rightVal
+		for i := leftVal; i > 1; i-- {
+			elements = append(elements, rightVal...)
+		}
+		return &object.Array{Elements: elements}
+
+	// " " * 4
+	case operator == "*" && left.Type() == object.STRING_OBJ && right.Type() == object.INTEGER_OBJ:
+		leftVal := left.(*object.String).Value
+		rightVal := right.(*object.Integer).Value
+		return &object.String{Value: strings.Repeat(leftVal, int(rightVal))}
+
+	// 4 * " "
+	case operator == "*" && left.Type() == object.INTEGER_OBJ && right.Type() == object.STRING_OBJ:
+		leftVal := left.(*object.Integer).Value
+		rightVal := right.(*object.String).Value
+		return &object.String{Value: strings.Repeat(rightVal, int(leftVal))}
+
+	case operator == "==":
+		return nativeBoolToBooleanObject(left.(object.Comparable).Compare(right) == 0)
+	case operator == "!=":
+		return nativeBoolToBooleanObject(left.(object.Comparable).Compare(right) != 0)
+	case operator == "<=":
+		return nativeBoolToBooleanObject(left.(object.Comparable).Compare(right) < 1)
+	case operator == ">=":
+		return nativeBoolToBooleanObject(left.(object.Comparable).Compare(right) > -1)
+	case operator == "<":
+		return nativeBoolToBooleanObject(left.(object.Comparable).Compare(right) == -1)
+	case operator == ">":
+		return nativeBoolToBooleanObject(left.(object.Comparable).Compare(right) == 1)
+
+	case left.Type() == object.BOOLEAN_OBJ && right.Type() == object.BOOLEAN_OBJ:
+		return evalBooleanInfixExpression(operator, left, right)
+	case left.Type() == object.INTEGER_OBJ && right.Type() == object.INTEGER_OBJ:
+		return evalIntegerInfixExpression(operator, left, right)
+	case left.Type() == object.STRING_OBJ && right.Type() == object.STRING_OBJ:
+		return evalStringInfixExpression(operator, left, right)
+
+	default:
+		return newError("unknown operator: %s %s %s", left.Type(), operator, right.Type())
+	}
+}
+
+func evalBooleanInfixExpression(operator string, left, right object.Object) object.Object {
+	leftVal := left.(*object.Boolean).Value
+	rightVal := right.(*object.Boolean).Value
+
+	switch operator {
+	case "&&":
+		return nativeBoolToBooleanObject(leftVal && rightVal)
+	case "||":
+		return nativeBoolToBooleanObject(leftVal || rightVal)
+	default:
+		return newError("unknown operator: %s %s %s", left.Type(), operator, right.Type())
+	}
+}
+
+func evalStringInfixExpression(operator string, left object.Object, right object.Object) object.Object {
+	leftVal := left.(*object.String).Value
+	rightVal := right.(*object.String).Value
+
+	switch operator {
+	case "+":
+		return &object.String{Value: leftVal + rightVal}
+	default:
+		return newError("unknown operator: %s %s %s", left.Type(), operator, right.Type())
+	}
+}
+
+func evalIntegerInfixExpression(operator string, left, right object.Object) object.Object {
+	leftVal := left.(*object.Integer).Value
+	rightVal := right.(*object.Integer).Value
+
+	switch operator {
+	case "+":
+		return &object.Integer{Value: leftVal + rightVal}
+	case "-":
+		return &object.Integer{Value: leftVal - rightVal}
+	case "*":
+		return &object.Integer{Value: leftVal * rightVal}
+	case "/":
+		return &object.Integer{Value: leftVal / rightVal}
+	case "%":
+		return &object.Integer{Value: leftVal % rightVal}
+	case "|":
+		return &object.Integer{Value: leftVal | rightVal}
+	case "^":
+		return &object.Integer{Value: leftVal ^ rightVal}
+	case "&":
+		return &object.Integer{Value: leftVal & rightVal}
+	case "<<":
+		return &object.Integer{Value: leftVal << uint64(rightVal)}
+	case ">>":
+		return &object.Integer{Value: leftVal >> uint64(rightVal)}
+	case "<":
+		return nativeBoolToBooleanObject(leftVal < rightVal)
+	case "<=":
+		return nativeBoolToBooleanObject(leftVal <= rightVal)
+	case ">":
+		return nativeBoolToBooleanObject(leftVal > rightVal)
+	case ">=":
+		return nativeBoolToBooleanObject(leftVal >= rightVal)
+	case "==":
+		return nativeBoolToBooleanObject(leftVal == rightVal)
+	case "!=":
+		return nativeBoolToBooleanObject(leftVal != rightVal)
+	default:
+		return newError("unknown operator: %s %s %s", left.Type(), operator, right.Type())
+	}
+}
+
+func evalIfExpression(ie *ast.IfExpression, env *object.Environment) object.Object {
+	condition := Eval(ie.Condition, env)
+	if isError(condition) {
+		return condition
+	}
+
+	if isTruthy(condition) {
+		return Eval(ie.Consequence, env)
+	} else if ie.Alternative != nil {
+		return Eval(ie.Alternative, env)
+	} else {
+		return NULL
+	}
+}
+
+func isTruthy(obj object.Object) bool {
+	switch obj {
+	case NULL:
+		return false
+	case TRUE:
+		return true
+	case FALSE:
+		return false
+	default:
+		return true
+	}
+}
+
+func newError(format string, a ...interface{}) *object.Error {
+	return &object.Error{Message: fmt.Sprintf(format, a...)}
+}
+
+// EvalModule evaluates the named module and returns a *object.Module objec
+func EvalModule(name string) object.Object {
+	filename := utils.FindModule(name)
+
+	b, err := os.ReadFile(filename)
+	if err != nil {
+		return newError("IOError: error reading module '%s': %s", name, err)
+	}
+
+	l := lexer.New(string(b))
+	p := parser.New(l)
+
+	module := p.ParseProgram()
+	if len(p.Errors()) != 0 {
+		return newError("ParseError: %s", p.Errors())
+	}
+
+	env := object.NewEnvironment()
+	Eval(module, env)
+
+	return env.ExportedHash()
+}
+
+func evalIdentifier(node *ast.Identifier, env *object.Environment) object.Object {
+	if val, ok := env.Get(node.Value); ok {
+		return val
+	}
+
+	if builtin, ok := builtins.Builtins[node.Value]; ok {
+		return builtin
+	}
+
+	return newError("identifier not found: " + node.Value)
+}
+
+func evalExpressions(exps []ast.Expression, env *object.Environment) []object.Object {
+	var result []object.Object
+
+	for _, e := range exps {
+		evaluated := Eval(e, env)
+		if isError(evaluated) {
+			return []object.Object{evaluated}
+		}
+		result = append(result, evaluated)
+	}
+
+	return result
+}
+
+func applyFunction(fn object.Object, args []object.Object) object.Object {
+	switch fn := fn.(type) {
+
+	case *object.Function:
+		extendedEnv := extendFunctionEnv(fn, args)
+		evaluated := Eval(fn.Body, extendedEnv)
+		return unwrapReturnValue(evaluated)
+
+	case *object.Builtin:
+		if result := fn.Fn(args...); result != nil {
+			return result
+		}
+		return NULL
+
+	default:
+		return newError("not a function: %s", fn.Type())
+
+	}
+}
+
+func extendFunctionEnv(fn *object.Function, args []object.Object) *object.Environment {
+	env := object.NewEnclosedEnvironment(fn.Env)
+
+	for paramIdx, param := range fn.Parameters {
+		env.Set(param.Value, args[paramIdx])
+	}
+
+	return env
+}
+
+func unwrapReturnValue(obj object.Object) object.Object {
+	if returnValue, ok := obj.(*object.ReturnValue); ok {
+		return returnValue.Value
+	}
+
+	return obj
+}
+
+func evalIndexExpression(left, index object.Object) object.Object {
+	switch {
+	case left.Type() == object.STRING_OBJ && index.Type() == object.INTEGER_OBJ:
+		return evalStringIndexExpression(left, index)
+	case left.Type() == object.ARRAY_OBJ && index.Type() == object.INTEGER_OBJ:
+		return evalArrayIndexExpression(left, index)
+	case left.Type() == object.HASH_OBJ:
+		return evalHashIndexExpression(left, index)
+	case left.Type() == object.MODULE_OBJ:
+		return EvalModuleIndexExpression(left, index)
+	default:
+		return newError("index operator not supported: %s", left.Type())
+	}
+}
+
+func EvalModuleIndexExpression(module, index object.Object) object.Object {
+	moduleObject := module.(*object.Module)
+	return evalHashIndexExpression(moduleObject.Attrs, index)
+}
+
+func evalStringIndexExpression(str, index object.Object) object.Object {
+	stringObject := str.(*object.String)
+	idx := index.(*object.Integer).Value
+	max := int64((len(stringObject.Value)) - 1)
+
+	if idx < 0 || idx > max {
+		return &object.String{Value: ""}
+	}
+
+	return &object.String{Value: string(stringObject.Value[idx])}
+}
+
+func evalHashIndexExpression(hash, index object.Object) object.Object {
+	hashObject := hash.(*object.Hash)
+
+	key, ok := index.(object.Hashable)
+	if !ok {
+		return newError("unusable as hash key: %s", index.Type())
+	}
+
+	pair, ok := hashObject.Pairs[key.HashKey()]
+	if !ok {
+		return NULL
+	}
+
+	return pair.Value
+}
+
+func evalArrayIndexExpression(array, index object.Object) object.Object {
+	arrayObject := array.(*object.Array)
+	idx := index.(*object.Integer).Value
+	maxInx := int64(len(arrayObject.Elements) - 1)
+
+	if idx < 0 || idx > maxInx {
+		return NULL
+	}
+
+	return arrayObject.Elements[idx]
+}
+
+func evalHashLiteral(node *ast.HashLiteral, env *object.Environment) object.Object {
+	pairs := make(map[object.HashKey]object.HashPair)
+
+	for keyNode, valueNode := range node.Pairs {
+		key := Eval(keyNode, env)
+		if isError(key) {
+			return key
+		}
+
+		hashKey, ok := key.(object.Hashable)
+		if !ok {
+			return newError("unusable as hash key: %s", key.Type())
+		}
+
+		value := Eval(valueNode, env)
+		if isError(value) {
+			return value
+		}
+
+		hashed := hashKey.HashKey()
+		pairs[hashed] = object.HashPair{
+			Key:   key,
+			Value: value,
+		}
+	}
+
+	return &object.Hash{Pairs: pairs}
+}
--- a/internal/evaluator/evaluator_test.go
+++ b/internal/evaluator/evaluator_test.go
@@ -0,0 +1,964 @@
+package evaluator
+
+import (
+	"errors"
+	"github.com/stretchr/testify/assert"
+	"monkey/internal/lexer"
+	"monkey/internal/object"
+	"monkey/internal/parser"
+	"monkey/internal/utils"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+var BlacklistedExamples = map[string]bool{
+	"echoserver": true,
+}
+
+func assertEvaluated(t *testing.T, expected interface{}, actual object.Object) {
+	t.Helper()
+
+	assert := assert.New(t)
+
+	switch expected.(type) {
+	case nil:
+		if _, ok := actual.(*object.Null); ok {
+			assert.True(ok)
+		} else {
+			assert.Equal(expected, actual)
+		}
+	case int:
+		if i, ok := actual.(*object.Integer); ok {
+			assert.Equal(int64(expected.(int)), i.Value)
+		} else {
+			assert.Equal(expected, actual)
+		}
+	case error:
+		if e, ok := actual.(*object.Integer); ok {
+			assert.Equal(expected.(error).Error(), e.Value)
+		} else {
+			assert.Equal(expected, actual)
+		}
+	case string:
+		if s, ok := actual.(*object.String); ok {
+			assert.Equal(expected.(string), s.Value)
+		} else {
+			assert.Equal(expected, actual)
+		}
+	default:
+		t.Fatalf("unsupported type for expected got=%T", expected)
+	}
+}
+
+func TestEvalExpressions(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected interface{}
+	}{
+		{"5", 5},
+		{"10", 10},
+		{"-5", -5},
+		{"-10", -10},
+		{"5 + 5 + 5 + 5 - 10", 10},
+		{"2 * 2 * 2 * 2 * 2", 32},
+		{"-50 + 100 + -50", 0},
+		{"5 * 2 + 10", 20},
+		{"5 + 2 * 10", 25},
+		{"20 + 2 * -10", 0},
+		{"50 / 2 * 2 + 10", 60},
+		{"2 * (5 + 10)", 30},
+		{"3 * 3 * 3 + 10", 37},
+		{"3 * (3 * 3) + 10", 37},
+		{"(5 + 10 * 2 + 15 / 3) * 2 + -10", 50},
+		{"!1", false},
+		{"~1", -2},
+		{"5 % 2", 1},
+		{"1 | 2", 3},
+		{"2 ^ 4", 6},
+		{"3 & 6", 2},
+		{`" " * 4`, "    "},
+		{`4 * " "`, "    "},
+		{"1 << 2", 4},
+		{"4 >> 2", 1},
+	}
+
+	for _, tt := range tests {
+		evaluated := testEval(tt.input)
+		if expected, ok := tt.expected.(int64); ok {
+			testIntegerObject(t, evaluated, expected)
+		} else if expected, ok := tt.expected.(bool); ok {
+			testBooleanObject(t, evaluated, expected)
+		}
+	}
+}
+
+func TestEvalBooleanExpression(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected bool
+	}{
+		{"true", true},
+		{"false", false},
+		{"!true", false},
+		{"!false", true},
+		{"true && true", true},
+		{"false && true", false},
+		{"true && false", false},
+		{"false && false", false},
+		{"true || true", true},
+		{"false || true", true},
+		{"true || false", true},
+		{"false || false", false},
+		{"1 < 2", true},
+		{"1 > 2", false},
+		{"1 < 1", false},
+		{"1 > 1", false},
+		{"1 == 1", true},
+		{"1 != 1", false},
+		{"1 == 2", false},
+		{"1 != 2", true},
+		{"true == true", true},
+		{"false == false", true},
+		{"true == false", false},
+		{"true != false", true},
+		{"false != true", true},
+		{"(1 < 2) == true", true},
+		{"(1 < 2) == false", false},
+		{"(1 > 2) == true", false},
+		{"(1 > 2) == false", true},
+		{"(1 <= 2) == true", true},
+		{"(1 <= 2) == false", false},
+		{"(1 >= 2) == true", false},
+		{"(1 >= 2) == false", true},
+		{`"a" == "a"`, true},
+		{`"a" < "b"`, true},
+		{`"abc" == "abc"`, true},
+	}
+
+	for _, tt := range tests {
+		evaluated := testEval(tt.input)
+		testBooleanObject(t, evaluated, tt.expected)
+	}
+}
+
+func TestIfElseExpression(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected interface{}
+	}{
+		{"if (true) { 10 }", 10},
+		{"if (false) { 10 }", nil},
+		{"if (1) { 10 }", 10},
+		{"if (1 < 2) { 10 }", 10},
+		{"if (1 > 2) { 10 }", nil},
+		{"if (1 > 2) { 10 } else { 20 }", 20},
+		{"if (1 < 2) { 10 } else { 20 }", 10},
+		{"if (1 < 2) { 10 } else if (1 == 2) { 20 }", 10},
+		{"if (1 > 2) { 10 } else if (1 == 2) { 20 } else { 30 }", 30},
+	}
+
+	for _, tt := range tests {
+		t.Log(tt.input)
+		evaluated := testEval(tt.input)
+		integer, ok := tt.expected.(int)
+		if ok {
+			testIntegerObject(t, evaluated, int64(integer))
+		} else {
+			testNullObject(t, evaluated)
+		}
+	}
+}
+
+func TestReturnStatements(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected int64
+	}{
+		{"return 10;", 10},
+		{"return 10; 9;", 10},
+		{"return 2 * 5; 9;", 10},
+		{"9; return 2 * 5; 9;", 10},
+		{"if (10 > 1) { return 10; }", 10},
+		{
+			`
+				if (10 > 1) {
+				  if (10 > 1) {
+					return 10;
+				  }
+				
+				  return 1;
+				}
+				`,
+			10,
+		},
+		{
+			`
+				f := fn(x) {
+				  return x;
+				  x + 10;
+				};
+				f(10);`,
+			10,
+		},
+		{
+			`
+				f := fn(x) {
+				   result := x + 10;
+				   return result;
+				   return 10;
+				};
+				f(10);`,
+			20,
+		},
+	}
+
+	for _, tt := range tests {
+		evaluated := testEval(tt.input)
+		testIntegerObject(t, evaluated, tt.expected)
+	}
+}
+
+func TestErrorHandling(t *testing.T) {
+	tests := []struct {
+		input           string
+		expectedMessage string
+	}{
+		{
+			"5 + true;",
+			"unknown operator: int + bool",
+		},
+		{
+			"5 + true; 5;",
+			"unknown operator: int + bool",
+		},
+		{
+			"-true",
+			"unknown operator: -bool",
+		},
+		{
+			"true + false;",
+			"unknown operator: bool + bool",
+		},
+		{
+			"5; true + false; 5",
+			"unknown operator: bool + bool",
+		},
+		{
+			"if (10 > 1) { true + false; }",
+			"unknown operator: bool + bool",
+		},
+		{
+			`
+				if (10 > 1) {
+				  if (10 > 1) {
+					return true + false;
+				  }
+				
+				  return 1;
+				}
+				`,
+			"unknown operator: bool + bool",
+		},
+		{
+			"foobar",
+			"identifier not found: foobar",
+		},
+		{
+			`"Hello" - "World"`,
+			"unknown operator: str - str",
+		},
+		{
+			`{"name": "Monkey"}[fn(x) { x }];`,
+			"unusable as hash key: fn",
+		},
+	}
+
+	for _, tt := range tests {
+		evaluated := testEval(tt.input)
+
+		errObj, ok := evaluated.(*object.Error)
+		if !ok {
+			t.Errorf("no error object returned. got=%T(%+v)",
+				evaluated, evaluated)
+			continue
+		}
+
+		if errObj.Message != tt.expectedMessage {
+			t.Errorf("wrong error message. expected=%q, got=%q",
+				tt.expectedMessage, errObj.Message)
+		}
+	}
+}
+
+func TestIndexAssignmentStatements(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected int64
+	}{
+		{"xs  := [1, 2, 3]; xs[1] = 4; xs[1];", 4},
+	}
+
+	for _, tt := range tests {
+		evaluated := testEval(tt.input)
+		testIntegerObject(t, evaluated, tt.expected)
+	}
+}
+
+func TestAssignmentStatements(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected interface{}
+	}{
+		{"a := 0; a = 5;", nil},
+		{"a := 0; a = 5; a;", 5},
+		{"a := 0; a = 5 * 5;", nil},
+		{"a := 0; a = 5 * 5; a;", 25},
+		{"a := 0; a = 5; b := 0; b = a;", nil},
+		{"a := 0; a = 5; b := 0; b = a; b;", 5},
+		{"a := 0; a = 5; b := 0; b = a; c := 0; c = a + b + 5;", nil},
+		{"a := 0; a = 5; b := 0; b = a; c := 0; c = a + b + 5; c;", 15},
+		{"a := 5; b := a; a = 0;", nil},
+		{"a := 5; b := a; a = 0; b;", 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)
+		}
+	}
+}
+
+func TestBindExpressions(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected int64
+	}{
+		{"a := 5; a;", 5},
+		{"a := 5 * 5; a;", 25},
+		{"a := 5; b := a; b;", 5},
+		{"a := 5; b := a; c := a + b + 5; c;", 15},
+	}
+
+	for _, tt := range tests {
+		testIntegerObject(t, testEval(tt.input), tt.expected)
+	}
+}
+
+func TestFunctionObject(t *testing.T) {
+	input := "fn(x) { x + 2; };"
+
+	evaluated := testEval(input)
+	fn, ok := evaluated.(*object.Function)
+	if !ok {
+		t.Fatalf("object is not Function. got=%T (%+v)", evaluated, evaluated)
+	}
+
+	if len(fn.Parameters) != 1 {
+		t.Fatalf("function has wrong parameters. Parameters=%+v", fn.Parameters)
+	}
+
+	if fn.Parameters[0].String() != "x" {
+		t.Fatalf("parameter is not 'x'. got=%q", fn.Parameters[0])
+	}
+
+	expectedBody := "(x + 2)"
+
+	if fn.Body.String() != expectedBody {
+		t.Fatalf("body is not %q. got=%q", expectedBody, fn.Body.String())
+	}
+}
+
+func TestFunctionApplication(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected int64
+	}{
+		{"identity := fn(x) { x; }; identity(5);", 5},
+		{"identity := fn(x) { return x; }; identity(5);", 5},
+		{"double := fn(x) { x * 2; }; double(5);", 10},
+		{"add := fn(x, y) { x + y; }; add(5, 5);", 10},
+		{"add := fn(x, y) { x + y; }; add(5 + 5, add(5, 5));", 20},
+		{"fn(x) { x; }(5)", 5},
+	}
+
+	for _, tt := range tests {
+		testIntegerObject(t, testEval(tt.input), tt.expected)
+	}
+}
+
+func TestClosures(t *testing.T) {
+	input := `
+			newAdder := fn(x) {
+			  fn(y) { x + y };
+			};
+			
+			addTwo := newAdder(2);
+			addTwo(2);`
+
+	testIntegerObject(t, testEval(input), 4)
+}
+
+func TestStringLiteral(t *testing.T) {
+	input := `"Hello World!"`
+
+	evaluated := testEval(input)
+	str, ok := evaluated.(*object.String)
+	if !ok {
+		t.Fatalf("object is not String. got=%T (+%v)", evaluated, evaluated)
+	}
+
+	if str.Value != "Hello World!" {
+		t.Errorf("String has wrong value. got=%q", str.Value)
+	}
+}
+
+func TestStringConcatenation(t *testing.T) {
+	input := `"Hello" + " " + "World!"`
+
+	evaluated := testEval(input)
+	str, ok := evaluated.(*object.String)
+	if !ok {
+		t.Fatalf("object is not String. got=%T (+%v)", evaluated, evaluated)
+	}
+
+	if str.Value != "Hello World!" {
+		t.Errorf("String has wrong value. got=%q", str.Value)
+	}
+}
+
+func TestBuiltinFunctions(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected interface{}
+	}{
+		{`len("")`, 0},
+		{`len("four")`, 4},
+		{`len("hello world")`, 11},
+		{`len(1)`, errors.New("TypeError: object of type 'int' has no len()")},
+		{`len("one", "two")`, errors.New("TypeError: len() takes exactly 1 argument (2 given)")},
+		{`len("∑")`, 1},
+		{`len([1, 2, 3])`, 3},
+		{`len([])`, 0},
+		{`first([1, 2, 3])`, 1},
+		{`first([])`, nil},
+		{`first(1)`, errors.New("TypeError: first() expected argument #1 to be `array` got `int`")},
+		{`last([1, 2, 3])`, 3},
+		{`last([])`, nil},
+		{`last(1)`, errors.New("TypeError: last() expected argument #1 to be `array` got `int`")},
+		{`rest([1, 2, 3])`, []int{2, 3}},
+		{`rest([])`, nil},
+		{`push([], 1)`, []int{1}},
+		{`push(1, 1)`, errors.New("TypeError: push() expected argument #1 to be `array` got `int`")},
+		{`print("Hello World")`, nil},
+		{`input()`, ""},
+		{`pop([])`, errors.New("IndexError: pop from an empty array")},
+		{`pop([1])`, 1},
+		{`bool(1)`, true},
+		{`bool(0)`, false},
+		{`bool(true)`, true},
+		{`bool(false)`, false},
+		{`bool(null)`, false},
+		{`bool("")`, false},
+		{`bool("foo")`, true},
+		{`bool([])`, false},
+		{`bool([1, 2, 3])`, true},
+		{`bool({})`, false},
+		{`bool({"a": 1})`, true},
+		{`int(true)`, 1},
+		{`int(false)`, 0},
+		{`int(1)`, 1},
+		{`int("10")`, 10},
+		{`str(null)`, "null"},
+		{`str(true)`, "true"},
+		{`str(false)`, "false"},
+		{`str(10)`, "10"},
+		{`str("foo")`, "foo"},
+		{`str([1, 2, 3])`, "[1, 2, 3]"},
+		{`str({"a": 1})`, "{\"a\": 1}"},
+	}
+
+	for _, tt := range tests {
+		evaluated := testEval(tt.input)
+
+		switch expected := tt.expected.(type) {
+		case bool:
+			testBooleanObject(t, evaluated, expected)
+		case int:
+			testIntegerObject(t, evaluated, int64(expected))
+		case string:
+			testStringObject(t, evaluated, expected)
+		case error:
+			errObj, ok := evaluated.(*object.Error)
+			if !ok {
+				t.Errorf("object is not Error. got=%T (%+v)",
+					evaluated, evaluated)
+				continue
+			}
+			if errObj.Message != expected.Error() {
+				t.Errorf("wrong error message. expected=%q, got=%q",
+					expected, errObj.Message)
+			}
+		}
+	}
+}
+
+func TestArrayLiterals(t *testing.T) {
+	input := "[1, 2 * 2, 3 + 3]"
+
+	evaluated := testEval(input)
+	result, ok := evaluated.(*object.Array)
+	if !ok {
+		t.Fatalf("object is not Array. got=%T (+%v)", evaluated, evaluated)
+	}
+
+	if len(result.Elements) != 3 {
+		t.Fatalf("array has wrong num of elements. got=%d", evaluated)
+	}
+
+	testIntegerObject(t, result.Elements[0], 1)
+	testIntegerObject(t, result.Elements[1], 4)
+	testIntegerObject(t, result.Elements[2], 6)
+}
+
+func TestArrayDuplication(t *testing.T) {
+	input := "[1] * 3"
+
+	evaluated := testEval(input)
+	result, ok := evaluated.(*object.Array)
+	if !ok {
+		t.Fatalf("object is not Array. got=%T (%+v)", evaluated, evaluated)
+	}
+
+	if len(result.Elements) != 3 {
+		t.Fatalf("array has wrong num of elements. got=%d",
+			len(result.Elements))
+	}
+
+	testIntegerObject(t, result.Elements[0], 1)
+	testIntegerObject(t, result.Elements[1], 1)
+	testIntegerObject(t, result.Elements[2], 1)
+}
+
+func TestArrayMerging(t *testing.T) {
+	input := "[1] + [2]"
+
+	evaluated := testEval(input)
+	result, ok := evaluated.(*object.Array)
+	if !ok {
+		t.Fatalf("object is not Array. got=%T (%+v)", evaluated, evaluated)
+	}
+
+	if len(result.Elements) != 2 {
+		t.Fatalf("array has wrong num of elements. got=%d",
+			len(result.Elements))
+	}
+
+	testIntegerObject(t, result.Elements[0], 1)
+	testIntegerObject(t, result.Elements[1], 2)
+}
+
+func TestArrayIndexExpressions(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected interface{}
+	}{
+		{
+			"[1, 2, 3][0]",
+			1,
+		},
+		{
+			"[1, 2, 3][1]",
+			2,
+		},
+		{
+			"[1, 2, 3][2]",
+			3,
+		},
+		{
+			"i := 0; [1][i];",
+			1,
+		},
+		{
+			"[1, 2, 3][1 + 1];",
+			3,
+		},
+		{
+			"myArray := [1, 2, 3]; myArray[2];",
+			3,
+		},
+		{
+			"myArray := [1, 2, 3]; myArray[0] + myArray[1] + myArray[2];",
+			6,
+		},
+		{
+			"myArray := [1, 2, 3]; i := myArray[0]; myArray[i]",
+			2,
+		},
+		{
+			"[1, 2, 3][3]",
+			nil,
+		},
+		{
+			"[1, 2, 3][-1]",
+			nil,
+		},
+	}
+
+	for _, tt := range tests {
+		evaluated := testEval(tt.input)
+
+		integer, ok := tt.expected.(int)
+		if ok {
+			testIntegerObject(t, evaluated, int64(integer))
+		} else {
+			testNullObject(t, evaluated)
+		}
+	}
+}
+
+func TestHashLiterals(t *testing.T) {
+	input := `two := "two";
+    {
+        "one": 10 - 9,
+        two: 1 + 1,
+        "thr" + "ee": 6 / 2,
+        4: 4,
+        true: 5,
+        false: 6
+    }`
+
+	evaluated := testEval(input)
+	result, ok := evaluated.(*object.Hash)
+	if !ok {
+		t.Fatalf("Eval didn't return Hash. 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("Hash has wrong num of pair. got=%d", len(result.Pairs))
+	}
+
+	for expectedKey, expectedValue := range expected {
+		pair, ok := result.Pairs[expectedKey]
+		if !ok {
+			t.Errorf("no pair for given key in Pairs")
+		}
+
+		testIntegerObject(t, pair.Value, expectedValue)
+	}
+}
+
+func TestHashMerging(t *testing.T) {
+	input := `{"a": 1} + {"b": 2}`
+	evaluated := testEval(input)
+	result, ok := evaluated.(*object.Hash)
+	if !ok {
+		t.Fatalf("Eval didn't return Hash. got=%T (%+v)", evaluated, evaluated)
+	}
+
+	expected := map[object.HashKey]int64{
+		(&object.String{Value: "a"}).HashKey(): 1,
+		(&object.String{Value: "b"}).HashKey(): 2,
+	}
+
+	if len(result.Pairs) != len(expected) {
+		t.Fatalf("Hash has wrong num of pairs. got=%d", len(result.Pairs))
+	}
+
+	for expectedKey, expectedValue := range expected {
+		pair, ok := result.Pairs[expectedKey]
+		if !ok {
+			t.Errorf("no pair for given key in Pairs")
+		}
+
+		testIntegerObject(t, pair.Value, expectedValue)
+	}
+}
+
+func TestHashSelectorExpressions(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected interface{}
+	}{
+		{
+			`{"foo": 5}.foo`,
+			5,
+		},
+		{
+			`{"foo": 5}.bar`,
+			nil,
+		},
+		{
+			`{}.foo`,
+			nil,
+		},
+	}
+
+	for _, tt := range tests {
+		evaluated := testEval(tt.input)
+		integer, ok := tt.expected.(int)
+		if ok {
+			testIntegerObject(t, evaluated, int64(integer))
+		} else {
+			testNullObject(t, evaluated)
+		}
+	}
+}
+
+func TestHashIndexExpressions(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected interface{}
+	}{
+		{
+			`{"foo": 5}["foo"]`,
+			5,
+		},
+		{
+			`{"foo": 5}["bar"]`,
+			nil,
+		},
+		{
+			`key := "foo"; {"foo": 5}[key]`,
+			5,
+		},
+		{
+			`{}["foo"]`,
+			nil,
+		},
+		{
+			`{5: 5}[5]`,
+			5,
+		},
+		{
+			`{true: 5}[true]`,
+			5,
+		},
+		{
+			`{false: 5}[false]`,
+			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)
+		}
+	}
+}
+
+func TestWhileExpressions(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected interface{}
+	}{
+		{"while (false) { }", nil},
+		{"n := 0; while (n < 10) { n := n + 1 }; n", 10},
+		{"n := 10; while (n > 0) { n := n - 1 }; n", 0},
+		{"n := 0; while (n < 10) { n := n + 1 }", nil},
+		{"n := 10; while (n > 0) { n := n - 1 }", nil},
+		{"n := 0; while (n < 10) { n = n + 1 }; n", 10},
+		{"n := 10; while (n > 0) { n = n - 1 }; n", 0},
+		{"n := 0; while (n < 10) { n = n + 1 }", nil},
+		{"n := 10; while (n > 0) { n = n - 1 }", nil},
+	}
+
+	for _, tt := range tests {
+		evaluated := testEval(tt.input)
+		integer, ok := tt.expected.(int)
+		if ok {
+			testIntegerObject(t, evaluated, int64(integer))
+		} else {
+			testNullObject(t, evaluated)
+		}
+	}
+}
+
+func testEval(input string) object.Object {
+	l := lexer.New(input)
+	p := parser.New(l)
+	program := p.ParseProgram()
+	env := object.NewEnvironment()
+
+	return Eval(program, env)
+}
+
+func testIntegerObject(t *testing.T, obj object.Object, expected int64) bool {
+	result, ok := obj.(*object.Integer)
+	if !ok {
+		t.Errorf("object is not Integer. got=%T (%+v)", obj, obj)
+		return false
+	}
+	if result.Value != expected {
+		t.Errorf("object has wrong value. got=%d, want=%d", result.Value, expected)
+		return false
+	}
+
+	return true
+}
+
+func TestNullExpression(t *testing.T) {
+	evaluated := testEval("null")
+	testNullObject(t, evaluated)
+}
+
+func testBooleanObject(t *testing.T, obj object.Object, expected bool) bool {
+	result, ok := obj.(*object.Boolean)
+	if !ok {
+		t.Errorf("object is not Boolean. got=%T (%+v)", obj, obj)
+		return false
+	}
+	if result.Value != expected {
+		t.Errorf("object has wrong value. got=%t, want=%t", result.Value, expected)
+		return false
+	}
+
+	return true
+}
+
+func testNullObject(t *testing.T, obj object.Object) bool {
+	if obj != NULL {
+		t.Errorf("object is not NULL. got=%T (%+v)", obj, obj)
+		return false
+	}
+	return true
+}
+
+func testStringObject(t *testing.T, obj object.Object, expected string) bool {
+	result, ok := obj.(*object.String)
+	if !ok {
+		t.Errorf("object is not String. got=%T (%+v)", obj, obj)
+		return false
+	}
+	if result.Value != expected {
+		t.Errorf("object has wrong value. got=%s, want=%s",
+			result.Value, expected)
+		return false
+	}
+	return true
+}
+func TestImportExpressions(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected interface{}
+	}{
+		{`mod := import("../../testdata/mod"); mod.A`, 5},
+		{`mod := import("../../testdata/mod"); mod.Sum(2, 3)`, 5},
+		{`mod := import("../../testdata/mod"); mod.a`, nil},
+	}
+
+	for _, tt := range tests {
+		evaluated := testEval(tt.input)
+		assertEvaluated(t, tt.expected, evaluated)
+	}
+}
+
+func TestImportSearchPaths(t *testing.T) {
+	utils.AddPath("../testdata")
+
+	tests := []struct {
+		input    string
+		expected interface{}
+	}{
+		{`mod := import("mod"); mod.A`, 5},
+	}
+
+	for _, tt := range tests {
+		evaluated := testEval(tt.input)
+		assertEvaluated(t, tt.expected, evaluated)
+	}
+}
+
+func TestExamples(t *testing.T) {
+	matches, err := filepath.Glob("../../examples/*.monkey")
+	if err != nil {
+		t.Error(err)
+	}
+
+	for _, match := range matches {
+		basename := path.Base(match)
+		name := strings.TrimSuffix(basename, filepath.Ext(basename))
+
+		if BlacklistedExamples[name] {
+			t.Skipf("not testing blacklisted example %s", name)
+		}
+
+		t.Run(name, func(t *testing.T) {
+			b, err := os.ReadFile(match)
+			if err != nil {
+				t.Error(err)
+			}
+			testEval(string(b))
+		})
+	}
+}
+
+func TestStringIndexExpressions(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected interface{}
+	}{
+		{
+			`"abc"[0]`,
+			"a",
+		},
+		{
+			`"abc"[1]`,
+			"b",
+		},
+		{
+			`"abc"[2]`,
+			"c",
+		},
+		{
+			`i := 0; "abc"[i];`,
+			"a",
+		},
+		{
+			`"abc"[1 + 1];`,
+			"c",
+		},
+		{
+			`myString := "abc"; myString[0] + myString[1] + myString[2];`,
+			"abc",
+		},
+		{
+			`"abc"[3]`,
+			"",
+		},
+		{
+			`"foo"[-1]`,
+			"",
+		},
+	}
+
+	for _, tt := range tests {
+		evaluated := testEval(tt.input)
+		str, ok := tt.expected.(string)
+		if ok {
+			testStringObject(t, evaluated, string(str))
+		} else {
+			testNullObject(t, evaluated)
+		}
+	}
+}