clean up builtins

object/builtins.go

@@ -5,210 +5,200 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"sort"
 	"unicode/utf8"
 )
 
-var Builtins = []struct {
-	Name    string
-	Builtin *Builtin
-}{
-	{
-		"len",
-		&Builtin{Name: "len", Fn: func(args ...Object) Object {
-			if len(args) != 1 {
-				return newError("wrong number of arguments. got=%d, want=1",
-					len(args))
-			}
+var Builtins = map[string]*Builtin{
+	"len":   {Name: "len", Fn: Len},
+	"input": {Name: "input", Fn: Input},
+	"print": {Name: "print", Fn: Print},
+	"first": {Name: "first", Fn: First},
+	"last":  {Name: "last", Fn: Last},
+	"rest":  {Name: "rest", Fn: Rest},
+	"push":  {Name: "push", Fn: Push},
+	"pop":   {Name: "pop", Fn: Pop},
+	"exit":  {Name: "exit", Fn: Exit},
+}
 
-			switch arg := args[0].(type) {
-			case *Array:
-				return &Integer{Value: int64(len(arg.Elements))}
-			case *String:
-				return &Integer{Value: int64(utf8.RuneCountInString(arg.Value))}
-			default:
-				return newError("argument to `len` not supported, got %s",
-					args[0].Type())
-			}
-		},
-		},
-	},
-	{
-		"input",
-		&Builtin{Name: "input", Fn: func(args ...Object) Object {
-			if len(args) > 0 {
-				obj, ok := args[0].(*String)
-				if !ok {
-					return newError(
-						"argument to `input` not supported, got %s",
-						args[0].Type(),
-					)
-				}
-				fmt.Fprintf(os.Stdout, obj.Value)
-			}
+var BuiltinsIndex []*Builtin
 
-			buffer := bufio.NewReader(os.Stdin)
+func init() {
+	var keys []string
+	for k := range Builtins {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
 
-			line, _, err := buffer.ReadLine()
-			if err != nil && err != io.EOF {
-				return newError(fmt.Sprintf("error reading input from stdin: %s", err))
-			}
-			return &String{Value: string(line)}
-		}},
-	},
-	{
-		"print",
-		&Builtin{Name: "print", Fn: func(args ...Object) Object {
-			for _, arg := range args {
-				fmt.Println(arg.Inspect())
-			}
-
-			return nil
-		},
-		},
-	},
-	{
-		"first",
-		&Builtin{Name: "first", Fn: func(args ...Object) Object {
-			if len(args) != 1 {
-				return newError("wrong number of arguments. got=%d, want=1", len(args))
-			}
-			if args[0].Type() != ARRAY_OBJ {
-				return newError("argument to `first` must be ARRAY, got %s", args[0].Type())
-			}
-
-			arr := args[0].(*Array)
-			if len(arr.Elements) > 0 {
-				return arr.Elements[0]
-			}
-
-			return nil
-		},
-		},
-	},
-	{
-		"last",
-		&Builtin{Name: "last", Fn: func(args ...Object) Object {
-			if len(args) != 1 {
-				return newError("wrong number of arguments. got=%d, want=1", len(args))
-			}
-			if args[0].Type() != ARRAY_OBJ {
-				return newError("argument to `last` must be ARRAY, got %s", args[0].Type())
-			}
-
-			arr := args[0].(*Array)
-			length := len(arr.Elements)
-			if length > 0 {
-				return arr.Elements[length-1]
-			}
-
-			return nil
-		},
-		},
-	},
-	{
-		"rest",
-		&Builtin{Name: "rest", Fn: func(args ...Object) Object {
-			if len(args) != 1 {
-				return newError("wrong number of arguments. got=%d, want=1",
-					len(args))
-			}
-			if args[0].Type() != ARRAY_OBJ {
-				return newError("argument to `rest` must be ARRAY, got %s",
-					args[0].Type())
-			}
-
-			arr := args[0].(*Array)
-			length := len(arr.Elements)
-			if length > 0 {
-				newElements := make([]Object, length-1, length-1)
-				copy(newElements, arr.Elements[1:length])
-				return &Array{Elements: newElements}
-			}
-
-			return nil
-		},
-		},
-	},
-	{
-		"push",
-		&Builtin{Name: "push", Fn: func(args ...Object) Object {
-			if len(args) != 2 {
-				return newError("wrong number of arguments. got=%d, want=2",
-					len(args))
-			}
-			if args[0].Type() != ARRAY_OBJ {
-				return newError("argument to `push` must be ARRAY, got %s",
-					args[0].Type())
-			}
-
-			arr := args[0].(*Array)
-			length := len(arr.Elements)
-
-			newElements := make([]Object, length+1, length+1)
-			copy(newElements, arr.Elements)
-			if immutable, ok := args[1].(Immutable); ok {
-				newElements[length] = immutable.Clone()
-			} else {
-				newElements[length] = args[1]
-			}
-
-			return &Array{Elements: newElements}
-		},
-		},
-	},
-	{
-		"pop",
-		&Builtin{Name: "pop", Fn: func(args ...Object) Object {
-			if len(args) != 1 {
-				return newError("wrong number of arguments. got=%d, want=1",
-					len(args))
-			}
-			if args[0].Type() != ARRAY_OBJ {
-				return newError("argument to `pop` must be ARRAY, got %s",
-					args[0].Type())
-			}
-
-			arr := args[0].(*Array)
-			length := len(arr.Elements)
-
-			if length == 0 {
-				return newError("cannot pop from an empty array")
-			}
-
-			element := arr.Elements[length-1]
-			arr.Elements = arr.Elements[:length-1]
-
-			return element
-		},
-		},
-	},
-	{
-		"exit",
-		&Builtin{Name: "exit", Fn: func(args ...Object) Object {
-			if len(args) == 1 {
-				if args[0].Type() != INTEGER_OBJ {
-					return newError("argument to `exit` must be INTEGER, got %s",
-						args[0].Type())
-				}
-				os.Exit(int(args[0].(*Integer).Value))
-			} else {
-				os.Exit(0)
-			}
-			return nil
-		},
-		},
-	},
+	for _, k := range keys {
+		BuiltinsIndex = append(BuiltinsIndex, Builtins[k])
+	}
 }
 
 func newError(format string, a ...interface{}) *Error {
 	return &Error{Message: fmt.Sprintf(format, a...)}
 }
 
-func GetBuiltinByName(name string) *Builtin {
-	for _, def := range Builtins {
-		if def.Name == name {
-			return def.Builtin
+func Len(args ...Object) Object {
+	if len(args) != 1 {
+		return newError("wrong number of arguments. got=%d, want=1",
+			len(args))
+	}
+
+	switch arg := args[0].(type) {
+	case *Array:
+		return &Integer{Value: int64(len(arg.Elements))}
+	case *String:
+		return &Integer{Value: int64(utf8.RuneCountInString(arg.Value))}
+	default:
+		return newError("argument to `len` not supported, got %s",
+			args[0].Type())
+	}
+}
+
+func Input(args ...Object) Object {
+	if len(args) > 0 {
+		obj, ok := args[0].(*String)
+		if !ok {
+			return newError(
+				"argument to `input` not supported, got %s",
+				args[0].Type(),
+			)
 		}
+		fmt.Fprintf(os.Stdout, obj.Value)
+	}
+
+	buffer := bufio.NewReader(os.Stdin)
+
+	line, _, err := buffer.ReadLine()
+	if err != nil && err != io.EOF {
+		return newError(fmt.Sprintf("error reading input from stdin: %s", err))
+	}
+	return &String{Value: string(line)}
+}
+
+func Print(args ...Object) Object {
+	for _, arg := range args {
+		fmt.Println(arg.Inspect())
+	}
+
+	return nil
+}
+
+func First(args ...Object) Object {
+	if len(args) != 1 {
+		return newError("wrong number of arguments. got=%d, want=1",
+			len(args))
+	}
+	if args[0].Type() != ARRAY_OBJ {
+		return newError("argument to `first` must be ARRAY, got %s",
+			args[0].Type())
+	}
+
+	arr := args[0].(*Array)
+	if len(arr.Elements) > 0 {
+		return arr.Elements[0]
+	}
+
+	return nil
+}
+
+func Last(args ...Object) Object {
+	if len(args) != 1 {
+		return newError("wrong number of arguments. got=%d, want=1",
+			len(args))
+	}
+	if args[0].Type() != ARRAY_OBJ {
+		return newError("argument to `last` must be ARRAY, got %s",
+			args[0].Type())
+	}
+
+	arr := args[0].(*Array)
+	length := len(arr.Elements)
+	if length > 0 {
+		return arr.Elements[length-1]
+	}
+
+	return nil
+}
+
+func Rest(args ...Object) Object {
+	if len(args) != 1 {
+		return newError("wrong number of arguments. got=%d, want=1",
+			len(args))
+	}
+	if args[0].Type() != ARRAY_OBJ {
+		return newError("argument to `rest` must be ARRAY, got %s",
+			args[0].Type())
+	}
+
+	arr := args[0].(*Array)
+	length := len(arr.Elements)
+	if length > 0 {
+		newElements := make([]Object, length-1, length-1)
+		copy(newElements, arr.Elements[1:length])
+		return &Array{Elements: newElements}
+	}
+
+	return nil
+}
+
+func Push(args ...Object) Object {
+	if len(args) != 2 {
+		return newError("wrong number of arguments. got=%d, want=2",
+			len(args))
+	}
+	if args[0].Type() != ARRAY_OBJ {
+		return newError("argument to `push` must be ARRAY, got %s",
+			args[0].Type())
+	}
+
+	arr := args[0].(*Array)
+	length := len(arr.Elements)
+
+	newElements := make([]Object, length+1)
+	copy(newElements, arr.Elements)
+	if immutable, ok := args[1].(Immutable); ok {
+		newElements[length] = immutable.Clone()
+	} else {
+		newElements[length] = args[1]
+	}
+
+	return &Array{Elements: newElements}
+}
+
+func Pop(args ...Object) Object {
+	if len(args) != 1 {
+		return newError("wrong number of arguments. got=%d, want=1",
+			len(args))
+	}
+	if args[0].Type() != ARRAY_OBJ {
+		return newError("argument to `pop` must be ARRAY, got %s",
+			args[0].Type())
+	}
+
+	arr := args[0].(*Array)
+	length := len(arr.Elements)
+
+	if length == 0 {
+		return newError("cannot pop from an empty array")
+	}
+
+	element := arr.Elements[length-1]
+	arr.Elements = arr.Elements[:length-1]
+
+	return element
+}
+
+func Exit(args ...Object) Object {
+	if len(args) == 1 {
+		if args[0].Type() != INTEGER_OBJ {
+			return newError("argument to `exit` must be INTEGER, got %s",
+				args[0].Type())
+		}
+		os.Exit(int(args[0].(*Integer).Value))
+	} else {
+		os.Exit(0)
 	}
 	return nil
 }