restructure project

internal/builtins/abs.go

@@ -0,0 +1,24 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+)
+
+// Abs  ...
+func Abs(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"abs", args,
+		typing.ExactArgs(1),
+		typing.WithTypes(object.INTEGER_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	i := args[0].(*object.Integer)
+	value := i.Value
+	if value < 0 {
+		value = value * -1
+	}
+	return &object.Integer{Value: value}
+}

internal/builtins/accept.go

@@ -0,0 +1,32 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+	"syscall"
+)
+
+// Accept  ...
+func Accept(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"accept", args,
+		typing.ExactArgs(1),
+		typing.WithTypes(object.INTEGER_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	var (
+		nfd syscall.Handle
+		err error
+	)
+
+	fd := int(args[0].(*object.Integer).Value)
+
+	nfd, _, err = syscall.Accept(syscall.Handle(fd))
+	if err != nil {
+		return newError("SocketError: %s", err)
+	}
+
+	return &object.Integer{Value: int64(nfd)}
+}

internal/builtins/args.go

@@ -0,0 +1,22 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+)
+
+// Args ...
+func Args(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"args", args,
+		typing.ExactArgs(0),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	elements := make([]object.Object, len(object.Arguments))
+	for i, arg := range object.Arguments {
+		elements[i] = &object.String{Value: arg}
+	}
+	return &object.Array{Elements: elements}
+}

internal/builtins/assert.go

@@ -0,0 +1,26 @@
+package builtins
+
+import (
+	"fmt"
+	"monkey/internal/object"
+	"monkey/internal/typing"
+	"os"
+)
+
+// Assert ...
+func Assert(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"assert", args,
+		typing.ExactArgs(2),
+		typing.WithTypes(object.BOOLEAN_OBJ, object.STRING_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	if !args[0].(*object.Boolean).Value {
+		fmt.Printf("Assertion Error: %s", args[1].(*object.String).Value)
+		os.Exit(1)
+	}
+
+	return nil
+}

internal/builtins/bin.go

@@ -0,0 +1,22 @@
+package builtins
+
+import (
+	"fmt"
+	"monkey/internal/object"
+	"monkey/internal/typing"
+	"strconv"
+)
+
+// Bin ...
+func Bin(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"bin", args,
+		typing.ExactArgs(1),
+		typing.WithTypes(object.INTEGER_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	i := args[0].(*object.Integer)
+	return &object.String{Value: fmt.Sprintf("0b%s", strconv.FormatInt(i.Value, 2))}
+}

internal/builtins/bind.go

@@ -0,0 +1,54 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+	"syscall"
+)
+
+// Bind ...
+func Bind(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"bind", args,
+		typing.ExactArgs(2),
+		typing.WithTypes(object.INTEGER_OBJ, object.INTEGER_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	var (
+		err      error
+		sockaddr syscall.Sockaddr
+	)
+
+	fd := int(args[0].(*object.Integer).Value)
+	address := args[1].(*object.String).Value
+
+	sockaddr, err = syscall.Getsockname(syscall.Handle(fd))
+	if err != nil {
+		return newError("ValueError: %s", err)
+	}
+
+	if _, ok := sockaddr.(*syscall.SockaddrInet4); ok {
+		addr, port, err := parseV4Address(address)
+		if err != nil {
+			return newError("ValueError: Invalid IPv4 address '%s': %s", address, err)
+		}
+		sockaddr = &syscall.SockaddrInet4{Addr: addr, Port: port}
+	} else if _, ok := sockaddr.(*syscall.SockaddrInet6); ok {
+		addr, port, err := parseV6Address(address)
+		if err != nil {
+			return newError("ValueError: Invalid IPv6 address '%s': %s", address, err)
+		}
+		sockaddr = &syscall.SockaddrInet6{Addr: addr, Port: port}
+	} else {
+		return newError("ValueError: Invalid socket type %T for bind '%s'", sockaddr, address)
+	}
+
+	err = syscall.Bind(syscall.Handle(fd), sockaddr)
+	if err != nil {
+		return newError("SocketError: %s", err)
+	}
+
+	return &object.Null{}
+}

internal/builtins/bool.go

@@ -0,0 +1,18 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+)
+
+// Bool ...
+func Bool(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"bool", args,
+		typing.ExactArgs(1),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	return &object.Boolean{Value: args[0].Bool()}
+}

internal/builtins/builtins.go

@@ -0,0 +1,77 @@
+package builtins
+
+import (
+	"fmt"
+	"monkey/internal/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},
+	"readfile":  {Name: "readfile", Fn: ReadFile},
+	"writefile": {Name: "writefile", Fn: WriteFile},
+	"ffi":       {Name: "ffi", Fn: FFI},
+	"abs":       {Name: "abs", Fn: Abs},
+	"bin":       {Name: "bin", Fn: Bin},
+	"hex":       {Name: "hex", Fn: Hex},
+	"ord":       {Name: "ord", Fn: Ord},
+	"chr":       {Name: "chr", Fn: Chr},
+	"divmod":    {Name: "divmod", Fn: Divmod},
+	"hash":      {Name: "hash", Fn: HashOf},
+	"id":        {Name: "id", Fn: IdOf},
+	"oct":       {Name: "oct", Fn: Oct},
+	"pow":       {Name: "pow", Fn: Pow},
+	"min":       {Name: "min", Fn: Min},
+	"max":       {Name: "max", Fn: Max},
+	"sorted":    {Name: "sorted", Fn: Sorted},
+	"reversed":  {Name: "reversed", Fn: Reversed},
+	"open":      {Name: "open", Fn: Open},
+	"close":     {Name: "close", Fn: Close},
+	"write":     {Name: "write", Fn: Write},
+	"read":      {Name: "read", Fn: Read},
+	"seek":      {Name: "seek", Fn: Seek},
+	"socket":    {Name: "socket", Fn: Socket},
+	"bind":      {Name: "bind", Fn: Bind},
+	"accept":    {Name: "accept", Fn: Accept},
+	"listen":    {Name: "listen", Fn: Listen},
+	"connect":   {Name: "connect", Fn: Connect},
+}
+
+// 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...)}
+}

internal/builtins/chr.go

@@ -0,0 +1,21 @@
+package builtins
+
+import (
+	"fmt"
+	"monkey/internal/object"
+	"monkey/internal/typing"
+)
+
+// Chr ...
+func Chr(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"chr", args,
+		typing.ExactArgs(1),
+		typing.WithTypes(object.INTEGER_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	i := args[0].(*object.Integer)
+	return &object.String{Value: fmt.Sprintf("%c", rune(i.Value))}
+}

internal/builtins/close.go

@@ -0,0 +1,27 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+	"syscall"
+)
+
+// Close  ...
+func Close(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"close", args,
+		typing.ExactArgs(1),
+		typing.WithTypes(object.INTEGER_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	fd := int(args[0].(*object.Integer).Value)
+
+	err := syscall.Close(syscall.Handle(fd))
+	if err != nil {
+		return newError("IOError: %s", err)
+	}
+
+	return &object.Null{}
+}

internal/builtins/connect.go

@@ -0,0 +1,50 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+	"syscall"
+)
+
+// Connect ...
+func Connect(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"connect", args,
+		typing.ExactArgs(2),
+		typing.WithTypes(object.INTEGER_OBJ, object.STRING_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	var sa syscall.Sockaddr
+
+	fd := int(args[0].(*object.Integer).Value)
+	address := args[1].(*object.String).Value
+
+	sockaddr, err := syscall.Getsockname(syscall.Handle(fd))
+	if err != nil {
+		return newError("ValueError: %s", err)
+	}
+
+	if _, ok := sockaddr.(*syscall.SockaddrInet4); ok {
+		addr, port, err := parseV4Address(address)
+		if err != nil {
+			return newError("ValueError: Invalid IPv4 address '%s': %s", address, err)
+		}
+		sa = &syscall.SockaddrInet4{Addr: addr, Port: port}
+	} else if _, ok := sockaddr.(*syscall.SockaddrInet6); ok {
+		addr, port, err := parseV6Address(address)
+		if err != nil {
+			return newError("ValueError: Invalid IPv6 address '%s': %s", address, err)
+		}
+		sa = &syscall.SockaddrInet6{Addr: addr, Port: port}
+	} else {
+		return newError("ValueError: Invalid socket type %T for bind '%s'", sockaddr, address)
+	}
+
+	if err = syscall.Connect(syscall.Handle(fd), sa); err != nil {
+		return newError("SocketError: %s", err)
+	}
+
+	return &object.Null{}
+}

internal/builtins/divmod.go

@@ -0,0 +1,24 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+)
+
+// Divmod ...
+func Divmod(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"divmod", args,
+		typing.ExactArgs(2),
+		typing.WithTypes(object.INTEGER_OBJ, object.INTEGER_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	a := args[0].(*object.Integer)
+	b := args[1].(*object.Integer)
+	elements := make([]object.Object, 2)
+	elements[0] = &object.Integer{Value: a.Value / b.Value}
+	elements[1] = &object.Integer{Value: a.Value % b.Value}
+	return &object.Array{Elements: elements}
+}

internal/builtins/exit.go

@@ -0,0 +1,26 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+)
+
+// Exit ...
+func Exit(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"exit", args,
+		typing.RangeOfArgs(0, 1),
+		typing.WithTypes(object.INTEGER_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	var status int
+	if len(args) == 1 {
+		status = int(args[0].(*object.Integer).Value)
+	}
+
+	object.ExitFunction(status)
+
+	return nil
+}

internal/builtins/ffi.go

@@ -0,0 +1,37 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+)
+
+import (
+	"fmt"
+	"plugin"
+)
+
+// FFI ...
+func FFI(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"ffi", args,
+		typing.ExactArgs(2),
+		typing.WithTypes(object.STRING_OBJ, object.STRING_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	name := args[0].(*object.String).Value
+	symbol := args[1].(*object.String).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.(object.BuiltinFunction)}
+}

internal/builtins/find.go

@@ -0,0 +1,52 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+	"sort"
+)
+
+import (
+	"strings"
+)
+
+// Find ...
+func Find(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"find", args,
+		typing.ExactArgs(2),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	// find substring in string
+	if haystack, ok := args[0].(*object.String); ok {
+		if err := typing.Check(
+			"find", args,
+			typing.WithTypes(object.STRING_OBJ, object.STRING_OBJ),
+		); err != nil {
+			return newError(err.Error())
+		}
+
+		needle := args[1].(*object.String)
+		index := strings.Index(haystack.Value, needle.Value)
+		return &object.Integer{Value: int64(index)}
+	}
+
+	// find in array
+	if haystack, ok := args[0].(*object.Array); ok {
+		needle := args[1].(object.Comparable)
+		i := sort.Search(len(haystack.Elements), func(i int) bool {
+			return needle.Compare(haystack.Elements[i]) == 0
+		})
+		if i < len(haystack.Elements) && needle.Compare(haystack.Elements[i]) == 0 {
+			return &object.Integer{Value: int64(i)}
+		}
+		return &object.Integer{Value: -1}
+	}
+
+	return newError(
+		"TypeError: find() expected argument #1 to be `array` or `str` got `%s`",
+		args[0].Type(),
+	)
+}

internal/builtins/first.go

@@ -0,0 +1,24 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+)
+
+// First ...
+func First(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"first", args,
+		typing.ExactArgs(1),
+		typing.WithTypes(object.ARRAY_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	arr := args[0].(*object.Array)
+	if len(arr.Elements) > 0 {
+		return arr.Elements[0]
+	}
+
+	return nil
+}

internal/builtins/hash.go

@@ -0,0 +1,22 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+)
+
+// HashOf ...
+func HashOf(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"hash", args,
+		typing.ExactArgs(1),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	if hash, ok := args[0].(object.Hashable); ok {
+		return &object.Integer{Value: int64(hash.HashKey().Value)}
+	}
+
+	return newError("TypeError: hash() expected argument #1 to be hashable")
+}

internal/builtins/hex.go

@@ -0,0 +1,22 @@
+package builtins
+
+import (
+	"fmt"
+	"monkey/internal/object"
+	"monkey/internal/typing"
+	"strconv"
+)
+
+// Hex ...
+func Hex(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"hex", args,
+		typing.ExactArgs(1),
+		typing.WithTypes(object.INTEGER_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	i := args[0].(*object.Integer)
+	return &object.String{Value: fmt.Sprintf("0x%s", strconv.FormatInt(i.Value, 16))}
+}

internal/builtins/id.go

@@ -0,0 +1,41 @@
+package builtins
+
+import (
+	"fmt"
+	"monkey/internal/object"
+	"monkey/internal/typing"
+)
+
+// IdOf ...
+func IdOf(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"id", args,
+		typing.ExactArgs(1),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	arg := args[0]
+
+	if n, ok := arg.(*object.Null); ok {
+		return &object.String{Value: fmt.Sprintf("%p", n)}
+	} else if b, ok := arg.(*object.Boolean); ok {
+		return &object.String{Value: fmt.Sprintf("%p", b)}
+	} else if i, ok := arg.(*object.Integer); ok {
+		return &object.String{Value: fmt.Sprintf("%p", i)}
+	} else if s, ok := arg.(*object.String); ok {
+		return &object.String{Value: fmt.Sprintf("%p", s)}
+	} else if a, ok := arg.(*object.Array); ok {
+		return &object.String{Value: fmt.Sprintf("%p", a)}
+	} else if h, ok := arg.(*object.Hash); ok {
+		return &object.String{Value: fmt.Sprintf("%p", h)}
+	} else if f, ok := arg.(*object.Function); ok {
+		return &object.String{Value: fmt.Sprintf("%p", f)}
+	} else if c, ok := arg.(*object.Closure); ok {
+		return &object.String{Value: fmt.Sprintf("%p", c)}
+	} else if b, ok := arg.(*object.Builtin); ok {
+		return &object.String{Value: fmt.Sprintf("%p", b)}
+	}
+
+	return nil
+}

internal/builtins/input.go

@@ -0,0 +1,34 @@
+package builtins
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"monkey/internal/object"
+	"monkey/internal/typing"
+	"os"
+)
+
+// Input ...
+func Input(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"input", args,
+		typing.RangeOfArgs(0, 1),
+		typing.WithTypes(object.STRING_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	if len(args) == 1 {
+		prompt := args[0].(*object.String).Value
+		fmt.Fprintf(os.Stdout, prompt)
+	}
+
+	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)}
+}

internal/builtins/int.go

@@ -0,0 +1,35 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+	"strconv"
+)
+
+// Int ...
+func Int(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"int", args,
+		typing.ExactArgs(1),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	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 &object.Integer{}
+	}
+}

internal/builtins/join.go

@@ -0,0 +1,26 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+	"strings"
+)
+
+// Join ...
+func Join(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"join", args,
+		typing.ExactArgs(2),
+		typing.WithTypes(object.ARRAY_OBJ, object.STRING_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	arr := args[0].(*object.Array)
+	sep := args[1].(*object.String)
+	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)}
+}

internal/builtins/last.go

@@ -0,0 +1,25 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+)
+
+// Last ...
+func Last(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"last", args,
+		typing.ExactArgs(1),
+		typing.WithTypes(object.ARRAY_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	arr := args[0].(*object.Array)
+	length := len(arr.Elements)
+	if length > 0 {
+		return arr.Elements[length-1]
+	}
+
+	return nil
+}

internal/builtins/len.go

@@ -0,0 +1,21 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+)
+
+// Len ...
+func Len(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"len", args,
+		typing.ExactArgs(1),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	if size, ok := args[0].(object.Sizeable); ok {
+		return &object.Integer{Value: int64(size.Len())}
+	}
+	return newError("TypeError: object of type '%s' has no len()", args[0].Type())
+}

internal/builtins/listen.go

@@ -0,0 +1,27 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+	"syscall"
+)
+
+// Listen ...
+func Listen(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"listen", args,
+		typing.ExactArgs(2),
+		typing.WithTypes(object.INTEGER_OBJ, object.INTEGER_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	fd := int(args[0].(*object.Integer).Value)
+	backlog := int(args[1].(*object.Integer).Value)
+
+	if err := syscall.Listen(syscall.Handle(fd), backlog); err != nil {
+		return newError("SocketError: %s", err)
+	}
+
+	return &object.Null{}
+}

internal/builtins/lower.go

@@ -0,0 +1,21 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+	"strings"
+)
+
+// Lower ...
+func Lower(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"lower", args,
+		typing.ExactArgs(1),
+		typing.WithTypes(object.STRING_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	str := args[0].(*object.String)
+	return &object.String{Value: strings.ToLower(str.Value)}
+}

internal/builtins/max.go

@@ -0,0 +1,31 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+	"sort"
+)
+
+// Max ...
+func Max(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"max", args,
+		typing.ExactArgs(1),
+		typing.WithTypes(object.ARRAY_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	a := args[0].(*object.Array)
+	// TODO: Make this more generic
+	xs := []int{} //make([]int, len(a.Elements))
+	for n, e := range a.Elements {
+		if i, ok := e.(*object.Integer); ok {
+			xs = append(xs, int(i.Value))
+		} else {
+			return newError("item #%d  not an `int` got=%s", n, e.Type())
+		}
+	}
+	sort.Ints(xs)
+	return &object.Integer{Value: int64(xs[len(xs)-1])}
+}

internal/builtins/min.go

@@ -0,0 +1,31 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+	"sort"
+)
+
+// Min ...
+func Min(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"min", args,
+		typing.ExactArgs(1),
+		typing.WithTypes(object.ARRAY_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	a := args[0].(*object.Array)
+	// TODO: Make this more generic
+	xs := []int{} //make([]int, len(a.Elements))
+	for n, e := range a.Elements {
+		if i, ok := e.(*object.Integer); ok {
+			xs = append(xs, int(i.Value))
+		} else {
+			return newError("item #%d  not an `int` got=%s", n, e.Type())
+		}
+	}
+	sort.Ints(xs)
+	return &object.Integer{Value: int64(xs[0])}
+}

internal/builtins/oct.go

@@ -0,0 +1,22 @@
+package builtins
+
+import (
+	"fmt"
+	"monkey/internal/object"
+	"monkey/internal/typing"
+	"strconv"
+)
+
+// Oct ...
+func Oct(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"oct", args,
+		typing.ExactArgs(1),
+		typing.WithTypes(object.INTEGER_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	i := args[0].(*object.Integer)
+	return &object.String{Value: fmt.Sprintf("0%s", strconv.FormatInt(i.Value, 8))}
+}

internal/builtins/open.go

@@ -0,0 +1,86 @@
+package builtins
+
+import (
+	"fmt"
+	"log"
+	"monkey/internal/object"
+	"monkey/internal/typing"
+	"os"
+	"syscall"
+)
+
+// Close  ...
+func parseMode(mode string) (int, error) {
+	var flag int
+	for _, c := range mode {
+		switch c {
+		case 'r':
+			if (flag & os.O_WRONLY) != 0 {
+				flag |= os.O_RDWR
+			} else {
+				log.Printf("r2")
+				flag |= os.O_RDONLY
+			}
+		case 'w':
+			if (flag & os.O_RDONLY) != 0 {
+				flag |= os.O_RDWR
+			} else {
+				flag |= os.O_WRONLY
+			}
+		case 'a':
+			flag |= os.O_APPEND
+		default:
+			return 0, fmt.Errorf("ValueError: mode string must be one of 'r', 'w', 'a', not '%c'", c)
+		}
+	}
+
+	if (flag&os.O_WRONLY) != 0 || (flag&os.O_RDWR) != 0 {
+		log.Printf("c1")
+		flag |= os.O_CREATE
+		if (flag & os.O_APPEND) == 0 {
+			log.Printf("t1")
+			flag |= os.O_TRUNC
+		}
+	}
+
+	if !((flag == os.O_RDONLY) || (flag&os.O_WRONLY != 0) || (flag&os.O_RDWR != 0)) {
+		return 0, fmt.Errorf("ValueError: mode string must be at least one of 'r', 'w', or 'rw'")
+	}
+
+	return flag, nil
+}
+
+// Open ...
+func Open(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"open", args,
+		typing.RangeOfArgs(1, 2),
+		typing.WithTypes(object.STRING_OBJ, object.STRING_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	var (
+		filename string
+		mode            = "r"
+		perm     uint32 = 0640
+	)
+
+	filename = args[0].(*object.String).Value
+
+	if len(args) == 2 {
+		mode = args[1].(*object.String).Value
+	}
+
+	flag, err := parseMode(mode)
+	if err != nil {
+		return newError(err.Error())
+	}
+
+	fd, err := syscall.Open(filename, flag, perm)
+	if err != nil {
+		return newError("IOError: %s", err)
+	}
+
+	return &object.Integer{Value: int64(fd)}
+}

internal/builtins/ord.go

@@ -0,0 +1,26 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+)
+
+// Ord ...
+func Ord(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"ord", args,
+		typing.ExactArgs(1),
+		typing.WithTypes(object.STRING_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	s := args[0].(*object.String)
+	if len(s.Value) == 1 {
+		return &object.Integer{Value: int64(s.Value[0])}
+	}
+	return newError(
+		"TypeError: ord() expected a single character `str` got=%s",
+		s.Inspect(),
+	)
+}

internal/builtins/pop.go

@@ -0,0 +1,29 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+)
+
+// Pop ...
+func Pop(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"pop", args,
+		typing.ExactArgs(1),
+		typing.WithTypes(object.ARRAY_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	arr := args[0].(*object.Array)
+	length := len(arr.Elements)
+
+	if length == 0 {
+		return newError("IndexError: pop from an empty array")
+	}
+
+	element := arr.Elements[length-1]
+	arr.Elements = arr.Elements[:length-1]
+
+	return element
+}

internal/builtins/pow.go

@@ -0,0 +1,34 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+)
+
+func pow(x, y int64) int64 {
+	p := int64(1)
+	for y > 0 {
+		if y&1 != 0 {
+			p *= x
+		}
+		y >>= 1
+		x *= x
+	}
+	return p
+}
+
+// Pow ...
+func Pow(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"pow", args,
+		typing.ExactArgs(2),
+		typing.WithTypes(object.INTEGER_OBJ, object.INTEGER_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	x := args[0].(*object.Integer)
+	y := args[1].(*object.Integer)
+	value := pow(x.Value, y.Value)
+	return &object.Integer{Value: value}
+}

internal/builtins/print.go

@@ -0,0 +1,22 @@
+package builtins
+
+import (
+	"fmt"
+	"monkey/internal/object"
+	"monkey/internal/typing"
+)
+
+// Print ...
+func Print(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"print", args,
+		typing.MinimumArgs(1),
+		typing.WithTypes(object.STRING_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	fmt.Println(args[0].String())
+
+	return nil
+}

internal/builtins/push.go

@@ -0,0 +1,22 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+)
+
+// Push ...
+func Push(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"push", args,
+		typing.ExactArgs(2),
+		typing.WithTypes(object.ARRAY_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	arr := args[0].(*object.Array)
+	newArray := arr.Copy()
+	newArray.Append(args[1])
+	return newArray
+}

internal/builtins/read.go

@@ -0,0 +1,40 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+	"syscall"
+)
+
+// DefaultBufferSize is the default buffer size
+const DefaultBufferSize = 4096
+
+// Read ...
+func Read(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"read", args,
+		typing.RangeOfArgs(1, 2),
+		typing.WithTypes(object.INTEGER_OBJ, object.INTEGER_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	var (
+		fd int
+		n  = DefaultBufferSize
+	)
+
+	fd = int(args[0].(*object.Integer).Value)
+
+	if len(args) == 2 {
+		n = int(args[1].(*object.Integer).Value)
+	}
+
+	buf := make([]byte, n)
+	n, err := syscall.Read(syscall.Handle(fd), buf)
+	if err != nil {
+		return newError("IOError: %s", err)
+	}
+
+	return &object.String{Value: string(buf[:n])}
+}

internal/builtins/readfile.go

@@ -0,0 +1,26 @@
+package builtins
+
+import (
+	"io/ioutil"
+	"monkey/internal/object"
+	"monkey/internal/typing"
+)
+
+// ReadFile ...
+func ReadFile(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"readfile", args,
+		typing.ExactArgs(1),
+		typing.WithTypes(object.STRING_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	filename := args[0].(*object.String).Value
+	data, err := ioutil.ReadFile(filename)
+	if err != nil {
+		return newError("IOError: error reading from file %s: %s", filename, err)
+	}
+
+	return &object.String{Value: string(data)}
+}

internal/builtins/rest.go

@@ -0,0 +1,22 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+)
+
+// Rest ...
+func Rest(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"rest", args,
+		typing.ExactArgs(1),
+		typing.WithTypes(object.ARRAY_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	arr := args[0].(*object.Array)
+	newArray := arr.Copy()
+	newArray.PopLeft()
+	return newArray
+}

internal/builtins/reversed.go

@@ -0,0 +1,22 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+)
+
+// Reversed ...
+func Reversed(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"reversed", args,
+		typing.ExactArgs(1),
+		typing.WithTypes(object.ARRAY_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	arr := args[0].(*object.Array)
+	newArray := arr.Copy()
+	newArray.Reverse()
+	return newArray
+}

internal/builtins/seek.go

@@ -0,0 +1,37 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+	"syscall"
+)
+
+// Seek ...
+func Seek(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"seek", args,
+		typing.RangeOfArgs(1, 3),
+		typing.WithTypes(object.INTEGER_OBJ, object.INTEGER_OBJ, object.INTEGER_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	var (
+		fd     int
+		whence = 0
+	)
+
+	fd = int(args[0].(*object.Integer).Value)
+	offset := args[1].(*object.Integer).Value
+
+	if len(args) == 3 {
+		whence = int(args[2].(*object.Integer).Value)
+	}
+
+	offset, err := syscall.Seek(syscall.Handle(fd), offset, whence)
+	if err != nil {
+		return newError("IOError: %s", err)
+	}
+
+	return &object.Integer{Value: offset}
+}

internal/builtins/socket.go

@@ -0,0 +1,65 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+	"strings"
+	"syscall"
+)
+
+// Socket ...
+func Socket(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"socket", args,
+		typing.ExactArgs(1),
+		typing.WithTypes(object.STRING_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	var (
+		domain int
+		typ    int
+		proto  int
+	)
+
+	arg := args[0].(*object.String).Value
+
+	switch strings.ToLower(arg) {
+	case "unix":
+		domain = syscall.AF_UNIX
+		typ = syscall.SOCK_STREAM
+		proto = 0
+	case "tcp4":
+		domain = syscall.AF_INET
+		typ = syscall.SOCK_STREAM
+		proto = syscall.IPPROTO_TCP
+	case "tcp6":
+		domain = syscall.AF_INET6
+		typ = syscall.SOCK_STREAM
+		proto = syscall.IPPROTO_TCP
+	case "udp4":
+		domain = syscall.AF_INET
+		typ = syscall.SOCK_DGRAM
+		proto = syscall.IPPROTO_UDP
+	case "udp6":
+		domain = syscall.AF_INET6
+		typ = syscall.SOCK_DGRAM
+		proto = syscall.IPPROTO_UDP
+	default:
+		return newError("ValueError: invalid socket type '%s'", arg)
+	}
+
+	fd, err := syscall.Socket(domain, typ, proto)
+	if err != nil {
+		return newError("SocketError: %s", err)
+	}
+
+	if domain == syscall.AF_INET || domain == syscall.AF_INET6 {
+		if err = syscall.SetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1); err != nil {
+			return newError("SocketError: cannot enable SO_REUSEADDR: %s", err)
+		}
+	}
+
+	return &object.Integer{Value: int64(fd)}
+}

internal/builtins/socket_utils.go

@@ -0,0 +1,68 @@
+package builtins
+
+import (
+	"fmt"
+	"net"
+	"strconv"
+)
+
+func parseAddress(address string) (ip net.IP, port int, err error) {
+	var (
+		h string
+		p string
+		n int64
+	)
+
+	h, p, err = net.SplitHostPort(address)
+	if err != nil {
+		return
+	}
+
+	ip = net.ParseIP(h)
+	if ip == nil {
+		var addrs []string
+		addrs, err = net.LookupHost(address)
+		if err != nil {
+			err = fmt.Errorf("error resolving host '%s'", address)
+			return
+		}
+
+		if len(addrs) == 0 {
+			err = fmt.Errorf("host not found '%s'", address)
+			return
+		}
+
+		ip = net.ParseIP(addrs[0])
+		if ip == nil {
+			err = fmt.Errorf("invalid IP address '%s'", address)
+			return
+		}
+	}
+
+	n, err = strconv.ParseInt(p, 10, 16)
+	if err != nil {
+		return
+	}
+	port = int(n)
+	return
+}
+
+func parseV4Address(address string) (addr [4]byte, port int, err error) {
+	var ip net.IP
+	ip, port, err = parseAddress(address)
+	if err != nil {
+		return
+	}
+	copy(addr[:], ip.To4()[:4])
+	return
+}
+
+func parseV6Address(address string) (addr [16]byte, port int, err error) {
+	var ip net.IP
+	ip, port, err = parseAddress(address)
+	if err != nil {
+		return
+	}
+	copy(addr[:], ip.To16()[:16])
+	return
+}

internal/builtins/sorted.go

@@ -0,0 +1,23 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+	"sort"
+)
+
+// Sorted ...
+func Sorted(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"sort", args,
+		typing.ExactArgs(1),
+		typing.WithTypes(object.ARRAY_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	arr := args[0].(*object.Array)
+	newArray := arr.Copy()
+	sort.Sort(newArray)
+	return newArray
+}

internal/builtins/split.go

@@ -0,0 +1,32 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+	"strings"
+)
+
+// Split ...
+func Split(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"split", args,
+		typing.RangeOfArgs(1, 2),
+		typing.WithTypes(object.STRING_OBJ, object.STRING_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	var sep string
+	s := args[0].(*object.String).Value
+
+	if len(args) == 2 {
+		sep = args[1].(*object.String).Value
+	}
+
+	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}
+}

internal/builtins/str.go

@@ -0,0 +1,18 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+)
+
+// Str ...
+func Str(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"str", args,
+		typing.ExactArgs(1),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	return &object.String{Value: args[0].String()}
+}

internal/builtins/typeof.go

@@ -0,0 +1,18 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+)
+
+// TypeOf ...
+func TypeOf(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"type", args,
+		typing.ExactArgs(1),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	return &object.String{Value: string(args[0].Type())}
+}

internal/builtins/upper.go

@@ -0,0 +1,20 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+	"strings"
+)
+
+// Upper ...
+func Upper(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"upper", args,
+		typing.ExactArgs(1),
+		typing.WithTypes(object.STRING_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	return &object.String{Value: strings.ToUpper(args[0].(*object.String).Value)}
+}

internal/builtins/write.go

@@ -0,0 +1,28 @@
+package builtins
+
+import (
+	"monkey/internal/object"
+	"monkey/internal/typing"
+	"syscall"
+)
+
+// Write ...
+func Write(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"write", args,
+		typing.ExactArgs(2),
+		typing.WithTypes(object.INTEGER_OBJ, object.INTEGER_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	fd := int(args[0].(*object.Integer).Value)
+	data := []byte(args[1].(*object.String).Value)
+
+	n, err := syscall.Write(syscall.Handle(fd), data)
+	if err != nil {
+		return newError("IOError: %s", err)
+	}
+
+	return &object.Integer{Value: int64(n)}
+}

internal/builtins/writefile.go

@@ -0,0 +1,28 @@
+package builtins
+
+import (
+	"io/ioutil"
+	"monkey/internal/object"
+	"monkey/internal/typing"
+)
+
+// WriteFile ...
+func WriteFile(args ...object.Object) object.Object {
+	if err := typing.Check(
+		"writefile", args,
+		typing.ExactArgs(2),
+		typing.WithTypes(object.STRING_OBJ, object.STRING_OBJ),
+	); err != nil {
+		return newError(err.Error())
+	}
+
+	filename := args[0].(*object.String).Value
+	data := []byte(args[1].(*object.String).Value)
+
+	err := ioutil.WriteFile(filename, data, 0755)
+	if err != nil {
+		return newError("IOError: error writing file %s: %s", filename, err)
+	}
+
+	return &object.Null{}
+}