3.5 Evaluation (literals)

cedrickchee · cedrickchee · commit b8518212ef59 · 2020-03-29T19:42:00.000+08:00
* Boolean literals
* Null
diff --git a/evaluator/evaluator.go b/evaluator/evaluator.go
@@ -9,6 +9,20 @@ import (
 	"github.com/cedrickchee/hou/object"
 )
 
+var (
+	// TRUE is a cached Boolean object holding the `true` value.
+	TRUE = &object.Boolean{Value: true}
+
+	// FALSE is a cached Boolean object holding the `false` value.
+	FALSE = &object.Boolean{Value: false}
+
+	// NULL is a cached Null object. There should only be one reference to a
+	// null value, just as there's only one 'true' and one 'false'.
+	// No kinda-but-not-quite-null, no half-null and no
+	// basically-thesame-as-the-other-null.
+	NULL = &object.Null{}
+)
+
 // Eval evaluates the node and returns an object.
 func Eval(node ast.Node) object.Object {
 	// Traverse the AST by starting at the top of the tree, receiving an
@@ -30,6 +44,9 @@ func Eval(node ast.Node) object.Object {
 	// Expressions
 	case *ast.IntegerLiteral:
 		return &object.Integer{Value: node.Value}
+
+	case *ast.Boolean:
+		return nativeBoolToBooleanObject(node.Value)
 	}
 
 	return nil
@@ -44,3 +61,19 @@ func evalStatements(stmts []ast.Statement) object.Object {
 
 	return result
 }
+
+// Helper function to reference true or false to only two instances of
+// object.Boolean: TRUE and FALSE.
+func nativeBoolToBooleanObject(input bool) *object.Boolean {
+	// We shouldn't create a new object.Boolean every time we encounter a true
+	// or false. There is no difference between two trues. The same goes for
+	// false. We shouldn't use new instances every time. There are only two
+	// possible values, so let's reference them instead of allocating new
+	// object.Booleans (creating new ones). That is a small performance
+	// improvement we get without a lot of work.
+
+	if input {
+		return TRUE
+	}
+	return FALSE
+}
diff --git a/evaluator/evaluator_test.go b/evaluator/evaluator_test.go
@@ -23,6 +23,21 @@ func TestEvalIntegerExpression(t *testing.T) {
 	}
 }
 
+func TestEvalBooleanExpression(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected bool
+	}{
+		{"true", true},
+		{"false", false},
+	}
+
+	for _, tt := range tests {
+		evaluated := testEval(tt.input)
+		testBooleanObject(t, evaluated, tt.expected)
+	}
+}
+
 func testEval(input string) object.Object {
 	l := lexer.New(input)
 	p := parser.New(l)
@@ -45,3 +60,17 @@ func testIntegerObject(t *testing.T, obj object.Object, expected int64) bool {
 
 	return true
 }
+
+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
+}
