rearrange builtins

builtins/args.go

@@ -0,0 +1,12 @@
+package builtins
+
+import "monkey/object"
+
+// Args  ...
+func Args(args ...object.Object) object.Object {
+	elements := make([]object.Object, len(object.Arguments))
+	for i, arg := range object.Arguments {
+		elements[i] = &object.String{Value: arg}
+	}
+	return &object.Array{Elements: elements}
+}

builtins/assert.go

@@ -0,0 +1,31 @@
+package builtins
+
+import "monkey/object"
+
+import (
+	"fmt"
+	"os"
+)
+
+// Assert ...
+func Assert(args ...object.Object) object.Object {
+	if len(args) != 2 {
+		return newError("wrong number of arguments. got=%d, want=2",
+			len(args))
+	}
+	if args[0].Type() != object.BOOLEAN_OBJ {
+		return newError("argument #1 to `assert` must be BOOLEAN, got %s",
+			args[0].Type())
+	}
+	if args[1].Type() != object.STRING_OBJ {
+		return newError("argument #2 to `assert` must be STRING, got %s",
+			args[0].Type())
+	}
+
+	if !args[0].(*object.Boolean).Value {
+		fmt.Printf("Assertion Error: %s", args[1].(*object.String).Value)
+		os.Exit(1)
+	}
+
+	return nil
+}

builtins/bool.go

@@ -0,0 +1,40 @@
+package builtins
+
+import "monkey/object"
+
+// Bool ...
+func Bool(args ...object.Object) object.Object {
+	if len(args) != 1 {
+		return newError("wrong number of arguments. got=%d, want=1", len(args))
+	}
+
+	switch arg := args[0].(type) {
+	case *object.Null:
+		return &object.Boolean{Value: false}
+	case *object.Boolean:
+		return arg
+	case *object.Integer:
+		if arg.Value == 0 {
+			return &object.Boolean{Value: false}
+		}
+		return &object.Boolean{Value: true}
+	case *object.String:
+		if len(arg.Value) > 0 {
+			return &object.Boolean{Value: true}
+		}
+		return &object.Boolean{Value: false}
+	case *object.Array:
+		if len(arg.Elements) > 0 {
+			return &object.Boolean{Value: true}
+		}
+		return &object.Boolean{Value: false}
+	case *object.Hash:
+		if len(arg.Pairs) > 0 {
+			return &object.Boolean{Value: true}
+		}
+		return &object.Boolean{Value: false}
+
+	default:
+		return newError("argument to `bool` not supported, got=%s", args[0].Type())
+	}
+}

builtins/builtins.go

@@ -0,0 +1,53 @@
+package builtins
+
+import (
+	"fmt"
+	"monkey/object"
+	"sort"
+)
+
+// Builtins ...
+var Builtins = map[string]*object.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},
+	"assert": {Name: "assert", Fn: Assert},
+	"bool":   {Name: "bool", Fn: Bool},
+	"int":    {Name: "int", Fn: Int},
+	"str":    {Name: "str", Fn: Str},
+	"type":   {Name: "type", Fn: TypeOf},
+	"args":   {Name: "args", Fn: Args},
+	"lower":  {Name: "lower", Fn: Lower},
+	"upper":  {Name: "upper", Fn: Upper},
+	"join":   {Name: "join", Fn: Join},
+	"split":  {Name: "split", Fn: Split},
+	"find":   {Name: "find", Fn: Find},
+	"read":   {Name: "read", Fn: Read},
+	"write":  {Name: "write", Fn: Write},
+	"ffi":    {Name: "ffi", Fn: FFI},
+}
+
+// BuiltinsIndex ...
+var BuiltinsIndex []*object.Builtin
+
+func init() {
+	var keys []string
+	for k := range Builtins {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+
+	for _, k := range keys {
+		BuiltinsIndex = append(BuiltinsIndex, Builtins[k])
+	}
+}
+
+func newError(format string, a ...interface{}) *object.Error {
+	return &object.Error{Message: fmt.Sprintf(format, a...)}
+}

builtins/exit.go

@@ -0,0 +1,19 @@
+package builtins
+
+import "monkey/object"
+
+// Exit ...
+func Exit(args ...object.Object) object.Object {
+	var status int
+	if len(args) == 1 {
+		if args[0].Type() != object.INTEGER_OBJ {
+			return newError("argument to `exit` must be INTEGER, got %s",
+				args[0].Type())
+		}
+		status = int(args[0].(*object.Integer).Value)
+	}
+
+	object.ExitFunction(status)
+
+	return nil
+}

builtins/ffi.go

@@ -0,0 +1,40 @@
+package builtins
+
+import "monkey/object"
+
+import (
+	"fmt"
+	"plugin"
+)
+
+// FFI ...
+func FFI(args ...object.Object) object.Object {
+	if len(args) != 2 {
+		return newError("wrong number of arguments. got=%d, want=2",
+			len(args))
+	}
+
+	arg, ok := args[0].(*object.String)
+	if !ok {
+		return newError("argument #1 to `ffi` expected to be `str` got=%T", args[0].Type())
+	}
+	name := arg.Value
+
+	arg, ok = args[1].(*object.String)
+	if !ok {
+		return newError("argument #2 to `ffi` expected to be `str` got=%T", args[0].Type())
+	}
+	symbol := arg.Value
+
+	p, err := plugin.Open(fmt.Sprintf("%s.so", name))
+	if err != nil {
+		return newError("error loading plugin: %s", err)
+	}
+
+	v, err := p.Lookup(symbol)
+	if err != nil {
+		return newError("error finding symbol: %s", err)
+	}
+
+	return &object.Builtin{Name: symbol, Fn: v.(func(...object.Object) object.Object)}
+}

builtins/find.go

@@ -0,0 +1,36 @@
+package builtins
+
+import "monkey/object"
+
+import (
+	"strings"
+)
+
+// Find ...
+func Find(args ...object.Object) object.Object {
+	if len(args) != 2 {
+		return newError("wrong number of arguments. got=%d, want=2",
+			len(args))
+	}
+
+	if haystack, ok := args[0].(*object.String); ok {
+		if needle, ok := args[1].(*object.String); ok {
+			index := strings.Index(haystack.Value, needle.Value)
+			return &object.Integer{Value: int64(index)}
+		} else {
+			return newError("expected arg #2 to be `str` got got=%T", args[1])
+		}
+	} else if haystack, ok := args[0].(*object.Array); ok {
+		needle := args[1]
+		index := -1
+		for i, el := range haystack.Elements {
+			if cmp, ok := el.(object.Comparable); ok && cmp.Equal(needle) {
+				index = i
+				break
+			}
+		}
+		return &object.Integer{Value: int64(index)}
+	} else {
+		return newError("expected arg #1 to be `str` or `array` got got=%T", args[0])
+	}
+}

builtins/first.go

@@ -0,0 +1,22 @@
+package builtins
+
+import "monkey/object"
+
+// First ...
+func First(args ...object.Object) object.Object {
+	if len(args) != 1 {
+		return newError("wrong number of arguments. got=%d, want=1",
+			len(args))
+	}
+	if args[0].Type() != object.ARRAY_OBJ {
+		return newError("argument to `first` must be array, got %s",
+			args[0].Type())
+	}
+
+	arr := args[0].(*object.Array)
+	if len(arr.Elements) > 0 {
+		return arr.Elements[0]
+	}
+
+	return nil
+}

builtins/input.go

@@ -0,0 +1,32 @@
+package builtins
+
+import "monkey/object"
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"os"
+)
+
+// Input ...
+func Input(args ...object.Object) object.Object {
+	if len(args) > 0 {
+		obj, ok := args[0].(*object.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 &object.String{Value: string(line)}
+}

builtins/int.go

@@ -0,0 +1,31 @@
+package builtins
+
+import "monkey/object"
+
+import "strconv"
+
+// Int ...
+func Int(args ...object.Object) object.Object {
+	if len(args) != 1 {
+		return newError("wrong number of arguments. got=%d, want=1", len(args))
+	}
+
+	switch arg := args[0].(type) {
+	case *object.Boolean:
+		if arg.Value {
+			return &object.Integer{Value: 1}
+		}
+		return &object.Integer{Value: 0}
+	case *object.Integer:
+		return arg
+	case *object.String:
+		n, err := strconv.ParseInt(arg.Value, 10, 64)
+		if err != nil {
+			return newError("could not parse string to int: %s", err)
+		}
+
+		return &object.Integer{Value: n}
+	default:
+		return newError("argument to `int` not supported, got=%s", args[0].Type())
+	}
+}

builtins/join.go

@@ -0,0 +1,29 @@
+package builtins
+
+import "monkey/object"
+
+import (
+	"strings"
+)
+
+// Join ...
+func Join(args ...object.Object) object.Object {
+	if len(args) != 2 {
+		return newError("wrong number of arguments. got=%d, want=1",
+			len(args))
+	}
+
+	if arr, ok := args[0].(*object.Array); ok {
+		if sep, ok := args[1].(*object.String); ok {
+			a := make([]string, len(arr.Elements))
+			for i, el := range arr.Elements {
+				a[i] = el.String()
+			}
+			return &object.String{Value: strings.Join(a, sep.Value)}
+		} else {
+			return newError("expected arg #2 to be `str` got got=%T", args[1])
+		}
+	} else {
+		return newError("expected arg #1 to be `array` got got=%T", args[0])
+	}
+}

builtins/last.go

@@ -0,0 +1,23 @@
+package builtins
+
+import "monkey/object"
+
+// Last ...
+func Last(args ...object.Object) object.Object {
+	if len(args) != 1 {
+		return newError("wrong number of arguments. got=%d, want=1",
+			len(args))
+	}
+	if args[0].Type() != object.ARRAY_OBJ {
+		return newError("argument to `last` must be array, got %s",
+			args[0].Type())
+	}
+
+	arr := args[0].(*object.Array)
+	length := len(arr.Elements)
+	if length > 0 {
+		return arr.Elements[length-1]
+	}
+
+	return nil
+}

builtins/len.go

@@ -0,0 +1,23 @@
+package builtins
+
+import "monkey/object"
+
+import "unicode/utf8"
+
+// Len ...
+func Len(args ...object.Object) object.Object {
+	if len(args) != 1 {
+		return newError("wrong number of arguments. got=%d, want=1",
+			len(args))
+	}
+
+	switch arg := args[0].(type) {
+	case *object.Array:
+		return &object.Integer{Value: int64(len(arg.Elements))}
+	case *object.String:
+		return &object.Integer{Value: int64(utf8.RuneCountInString(arg.Value))}
+	default:
+		return newError("argument to `len` not supported, got %s",
+			args[0].Type())
+	}
+}

builtins/lower.go

@@ -0,0 +1,18 @@
+package builtins
+
+import "monkey/object"
+
+import "strings"
+
+// Lower ...
+func Lower(args ...object.Object) object.Object {
+	if len(args) != 1 {
+		return newError("wrong number of arguments. got=%d, want=1",
+			len(args))
+	}
+
+	if str, ok := args[0].(*object.String); ok {
+		return &object.String{Value: strings.ToLower(str.Value)}
+	}
+	return newError("expected `str` argument to `lower` got=%T", args[0])
+}

builtins/pop.go

@@ -0,0 +1,27 @@
+package builtins
+
+import "monkey/object"
+
+// Pop ...
+func Pop(args ...object.Object) object.Object {
+	if len(args) != 1 {
+		return newError("wrong number of arguments. got=%d, want=1",
+			len(args))
+	}
+	if args[0].Type() != object.ARRAY_OBJ {
+		return newError("argument to `pop` must be array, got %s",
+			args[0].Type())
+	}
+
+	arr := args[0].(*object.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
+}

builtins/print.go

@@ -0,0 +1,14 @@
+package builtins
+
+import "monkey/object"
+
+import "fmt"
+
+// Print ...
+func Print(args ...object.Object) object.Object {
+	for _, arg := range args {
+		fmt.Println(arg.String())
+	}
+
+	return nil
+}

builtins/push.go

@@ -0,0 +1,28 @@
+package builtins
+
+import "monkey/object"
+
+// Push ...
+func Push(args ...object.Object) object.Object {
+	if len(args) != 2 {
+		return newError("wrong number of arguments. got=%d, want=2",
+			len(args))
+	}
+	if args[0].Type() != object.ARRAY_OBJ {
+		return newError("argument to `push` must be array, got %s",
+			args[0].Type())
+	}
+
+	arr := args[0].(*object.Array)
+	length := len(arr.Elements)
+
+	newElements := make([]object.Object, length+1)
+	copy(newElements, arr.Elements)
+	if immutable, ok := args[1].(object.Immutable); ok {
+		newElements[length] = immutable.Clone()
+	} else {
+		newElements[length] = args[1]
+	}
+
+	return &object.Array{Elements: newElements}
+}

builtins/read.go

@@ -0,0 +1,28 @@
+package builtins
+
+import "monkey/object"
+
+import (
+	"os"
+)
+
+// Read ...
+func Read(args ...object.Object) object.Object {
+	if len(args) != 1 {
+		return newError("wrong number of arguments. got=%d, want=1",
+			len(args))
+	}
+
+	arg, ok := args[0].(*object.String)
+	if !ok {
+		return newError("argument to `read` expected to be `str` got=%T", args[0].Type())
+	}
+
+	filename := arg.Value
+	data, err := os.ReadFile(filename)
+	if err != nil {
+		return newError("error reading file: %s", err)
+	}
+
+	return &object.String{Value: string(data)}
+}

builtins/rest.go

@@ -0,0 +1,25 @@
+package builtins
+
+import "monkey/object"
+
+// Rest ...
+func Rest(args ...object.Object) object.Object {
+	if len(args) != 1 {
+		return newError("wrong number of arguments. got=%d, want=1",
+			len(args))
+	}
+	if args[0].Type() != object.ARRAY_OBJ {
+		return newError("argument to `rest` must be array, got %s",
+			args[0].Type())
+	}
+
+	arr := args[0].(*object.Array)
+	length := len(arr.Elements)
+	if length > 0 {
+		newElements := make([]object.Object, length-1, length-1)
+		copy(newElements, arr.Elements[1:length])
+		return &object.Array{Elements: newElements}
+	}
+
+	return nil
+}

builtins/split.go

@@ -0,0 +1,38 @@
+package builtins
+
+import "monkey/object"
+
+import (
+	"strings"
+)
+
+// Split ...
+func Split(args ...object.Object) object.Object {
+	if len(args) < 1 {
+		return newError("wrong number of arguments. got=%d, want=1",
+			len(args))
+	}
+
+	if obj, ok := args[0].(*object.String); ok {
+		var sep string
+
+		s := obj.Value
+
+		if len(args) == 2 {
+			if obj, ok := args[1].(*object.String); ok {
+				sep = obj.Value
+			} else {
+				return newError("expected arg #2 to be `str` got=%T", args[1])
+			}
+		}
+
+		tokens := strings.Split(s, sep)
+		elements := make([]object.Object, len(tokens))
+		for i, token := range tokens {
+			elements[i] = &object.String{Value: token}
+		}
+		return &object.Array{Elements: elements}
+	} else {
+		return newError("expected arg #1 to be `str` got got=%T", args[0])
+	}
+}

builtins/str.go

@@ -0,0 +1,21 @@
+package builtins
+
+import "monkey/object"
+
+import (
+	"fmt"
+)
+
+// Str ...
+func Str(args ...object.Object) object.Object {
+	if len(args) != 1 {
+		return newError("wrong number of arguments. got=%d, want=1", len(args))
+	}
+
+	arg, ok := args[0].(fmt.Stringer)
+	if !ok {
+		return newError("argument to `str` not supported, got %s", args[0].Type())
+	}
+
+	return &object.String{Value: arg.String()}
+}

builtins/typeof.go

@@ -0,0 +1,12 @@
+package builtins
+
+import "monkey/object"
+
+// TypeOf  ...
+func TypeOf(args ...object.Object) object.Object {
+	if len(args) != 1 {
+		return newError("wrong number of arguments. got=%d, want=1", len(args))
+	}
+
+	return &object.String{Value: string(args[0].Type())}
+}

builtins/upper.go

@@ -0,0 +1,18 @@
+package builtins
+
+import "monkey/object"
+
+import "strings"
+
+// Upper ...
+func Upper(args ...object.Object) object.Object {
+	if len(args) != 1 {
+		return newError("wrong number of arguments. got=%d, want=1",
+			len(args))
+	}
+
+	if str, ok := args[0].(*object.String); ok {
+		return &object.String{Value: strings.ToUpper(str.Value)}
+	}
+	return newError("expected `str` argument to `upper` got=%T", args[0])
+}

builtins/write.go

@@ -0,0 +1,34 @@
+package builtins
+
+import "monkey/object"
+
+import (
+	"os"
+)
+
+// Write ...
+func Write(args ...object.Object) object.Object {
+	if len(args) != 2 {
+		return newError("wrong number of arguments. got=%d, want=2",
+			len(args))
+	}
+
+	arg, ok := args[0].(*object.String)
+	if !ok {
+		return newError("argument #1 to `write` expected to be `str` got=%T", args[0].Type())
+	}
+	filename := arg.Value
+
+	arg, ok = args[1].(*object.String)
+	if !ok {
+		return newError("argument #2 to `write` expected to be `str` got=%T", args[1].Type())
+	}
+	data := []byte(arg.Value)
+
+	err := os.WriteFile(filename, data, 0755)
+	if err != nil {
+		return newError("error writing file: %s", err)
+	}
+
+	return &object.Null{}
+}