4.3 Built-in Functions (len)

cedrickchee · cedrickchee · commit 02b8bcf6d1bc · 2020-04-01T17:04:51.000+08:00
Add built-in functions to our interpreter.
The first built-in function we’re going to add to our interpreter
is len.
diff --git a/evaluator/builtins.go b/evaluator/builtins.go
@@ -0,0 +1,28 @@
+package evaluator
+
+import (
+	"github.com/cedrickchee/hou/object"
+)
+
+var builtins = map[string]*object.Builtin{
+	"len": &object.Builtin{
+		Fn: func(args ...object.Object) object.Object {
+			// Error checking that makes sure that we can't call this function
+			// with the wrong number of arguments.
+			if len(args) != 1 {
+				return newError("wrong number of arguments. got=%d, want=1",
+					len(args))
+			}
+
+			switch arg := args[0].(type) {
+			case *object.String:
+				return &object.Integer{Value: int64(len(arg.Value))}
+			default:
+				// Error checking that makes sure that we can't call this
+				// function with an argument of an unsupported type.
+				return newError("argument to `len` not supported, got %s",
+					args[0].Type())
+			}
+		},
+	},
+}
diff --git a/evaluator/evaluator.go b/evaluator/evaluator.go
@@ -337,12 +337,17 @@ func evalIdentifier(
 	node *ast.Identifier,
 	env *object.Environment,
 ) object.Object {
-	val, ok := env.Get(node.Value)
-	if !ok {
-		return newError("identifier not found: " + node.Value)
+	if val, ok := env.Get(node.Value); ok {
+		return val
 	}
 
-	return val
+	// Lookup built-in functions as a fallback when the given identifier is not
+	// bound to a value in the current environment.
+	if builtin, ok := builtins[node.Value]; ok {
+		return builtin
+	}
+
+	return newError("identifier not found: " + node.Value)
 }
 
 func isTruthy(obj object.Object) bool {
@@ -400,15 +405,23 @@ func evalExpressions(
 }
 
 func applyFunction(fn object.Object, args []object.Object) object.Object {
-	// Convert the fn parameter to a *object.Function reference.
-	function, ok := fn.(*object.Function)
-	if !ok {
+	switch fn := fn.(type) {
+	case *object.Function:
+		// Here, fn is the converted fn parameter to a *object.Function
+		// reference.
+		extendedEnv := extendFunctionEnv(fn, args)
+		evaluated := Eval(fn.Body, extendedEnv)
+		return unwrapReturnValue(evaluated)
+
+	case *object.Builtin:
+		// Call the object.BuiltinFunction. Note that we don’t need to
+		// unwrapReturnValue when calling a built-in function. That’s because we
+		// never return an *object.ReturnValue from these functions.
+		return fn.Fn(args...)
+
+	default:
 		return newError("not a function: %s", fn.Type())
 	}
-
-	extendedEnv := extendFunctionEnv(function, args)
-	evaluated := Eval(function.Body, extendedEnv)
-	return unwrapReturnValue(evaluated)
 }
 
 func extendFunctionEnv(
diff --git a/evaluator/evaluator_test.go b/evaluator/evaluator_test.go
@@ -363,6 +363,45 @@ func TestStringConcatenation(t *testing.T) {
 	}
 }
 
+func TestBuiltinFunctions(t *testing.T) {
+	// Test cases that run len through its paces: an empty string, a normal
+	// string and a string containing whitespace.
+	// The last two test cases are more interesting: we want to make sure that
+	// len returns an *object.Error when called with an integer or with the
+	// wrong number of arguments.
+
+	tests := []struct {
+		input    string
+		expected interface{}
+	}{
+		{`len("")`, 0},
+		{`len("four")`, 4},
+		{`len("hello world")`, 11},
+		{`len(1)`, "argument to `len` not supported, got INTEGER"},
+		{`len("one", "two")`, "wrong number of arguments. got=2, want=1"},
+	}
+
+	for _, tt := range tests {
+		evaluated := testEval(tt.input)
+
+		switch expected := tt.expected.(type) {
+		case int:
+			testIntegerObject(t, evaluated, int64(expected))
+		case string:
+			errObj, ok := evaluated.(*object.Error)
+			if !ok {
+				t.Errorf("object is not Error. got=%T (%+v)",
+					evaluated, evaluated)
+				continue
+			}
+			if errObj.Message != expected {
+				t.Errorf("wrong error message. expected=%q, got=%q",
+					expected, errObj.Message)
+			}
+		}
+	}
+}
+
 func testEval(input string) object.Object {
 	l := lexer.New(input)
 	p := parser.New(l)
diff --git a/object/object.go b/object/object.go
@@ -33,8 +33,15 @@ const (
 
 	// FUNCTION_OBJ is the Function object type.
 	FUNCTION_OBJ = "FUNCTION"
+
+	// BUILTIN_OBJ is the Builtin object type.
+	BUILTIN_OBJ = "BUILTIN"
 )
 
+// BuiltinFunction represents the builtin function type.
+// It's the type definition of a callable Go function.
+type BuiltinFunction func(args ...Object) Object
+
 // ObjectType represents the type of an object.
 type ObjectType string
 
@@ -155,3 +162,16 @@ func (s *String) Type() ObjectType { return STRING_OBJ }
 
 // Inspect returns a stringified version of the object for debugging.
 func (s *String) Inspect() string { return s.Value }
+
+// Builtin is the builtin object type that simply holds a reference to a
+// BuiltinFunction type that takes zero or more objects as arguments and returns
+// an object.
+type Builtin struct {
+	Fn BuiltinFunction
+}
+
+// Type returns the type of the object.
+func (b *Builtin) Type() ObjectType { return BUILTIN_OBJ }
+
+// Inspect returns a stringified version of the object for debugging.
+func (b *Builtin) Inspect() string { return "builtin function" }
