start implementing int64 use for numbers which can be representated as int64s

go.mod

@@ -7,7 +7,10 @@ require (
 	github.com/wadey/go-rounding v1.1.0
 )
 
-require github.com/joho/godotenv v1.5.1 // indirect
+require (
+	github.com/chzyer/readline v1.5.1 // indirect
+	github.com/joho/godotenv v1.5.1 // indirect
+)
 
 require (
 	github.com/gabriel-vasile/mimetype v1.4.2

go.sum

@@ -1,3 +1,7 @@
+github.com/chzyer/logex v1.2.1/go.mod h1:JLbx6lG2kDbNRFnfkgvh4eRJRPX1QCoOIWomwysCBrQ=
+github.com/chzyer/readline v1.5.1 h1:upd/6fQk4src78LMRzh5vItIt361/o4uq553V8B5sGI=
+github.com/chzyer/readline v1.5.1/go.mod h1:Eh+b79XXUwfKfcPLepksvw2tcLE/Ct21YObkaSkeBlk=
+github.com/chzyer/test v1.0.0/go.mod h1:2JlltgoNkt4TW/z9V/IzDdFaMTM2JPIi26O1pF38GC8=
 github.com/fatih/color v1.14.1 h1:qfhVLaG5s+nCROl1zJsZRxFeYrHLqWroPOQ8BWiNb4w=
 github.com/fatih/color v1.14.1/go.mod h1:2oHN61fhTpgcxD3TSWCgKDiH1+x4OiDVVGH8WlgGZGg=
 github.com/gabriel-vasile/mimetype v1.4.2 h1:w5qFW6JKBz9Y393Y4q372O9A7cUSequkh1Q7OhCmWKU=
@@ -19,6 +23,7 @@ golang.org/x/net v0.8.0 h1:Zrh2ngAOFYneWTAIAPethzeaQLuHwhuBkuV6ZiRnUaQ=
 golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210220050731-9a76102bfb43/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.3.0 h1:w8ZOecv6NaNa/zC8944JTU3vz4u6Lagfk4RPQxv92NQ=
 golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

server_test/app.ar

@@ -0,0 +1,9 @@
+import "http.ar" as http
+
+let server = http.server()
+
+let home(req,res) = do
+    res.send("hello world")
+server.get("/",home)
+
+server.run()

server_test/argon-package.json

@@ -0,0 +1,4 @@
+{
+	"name": "server-test",
+	"version": "1.0.0"
+}

server_test/iso-lock.json

@@ -0,0 +1 @@
+[{"Name":"http.ar","Version":"1.1.6","URL":"https://isotope.wbell.dev/isotope-download?name=http.ar\u0026version=1.1.6","Remote":"isotope.wbell.dev"}]

src/abs.go

@@ -40,38 +40,28 @@ func parseAbs(code UNPARSEcode, index int, codelines []UNPARSEcode) (any, bool,
 }
 
 func runAbs(x ABS, stack stack, stacklevel int) (any, ArErr) {
-	resp, err := runVal(x.body, stack, stacklevel+1)
+	value, err := runVal(x, stack, stacklevel+1)
 	if err.EXISTS {
 		return nil, err
 	}
-	if typeof(resp) != "number" {
-		return nil, ArErr{TYPE: "Runtime Error",
-			message: fmt.Sprintf("abs expected number, got %s", typeof(resp)),
-			EXISTS:  true,
+	switch value := value.(type) {
+	case ArObject:
+		if Callable, ok := value.obj["__abs__"]; ok {
+			return runCall(call{
+				Callable: Callable,
+				Args:     []any{},
+				Code:     x.code,
+				Line:     x.line,
+				Path:     x.path,
+			}, stack, stacklevel)
 		}
 	}
-	return abs(resp.(number)), ArErr{}
+	return nil, ArErr{
+		"TypeError",
+		fmt.Sprint("abs() not supported on ", typeof(value)),
+		x.line,
+		x.path,
+		x.code,
+		true,
+	}
 }
-
-func abs(x number) number {
-	if x.Sign() < 0 {
-		return x.Neg(x)
-	}
-	return x
-}
-
-var ArAbs = builtinFunc{"abs", func(args ...any) (any, ArErr) {
-	if len(args) != 1 {
-		return nil, ArErr{TYPE: "Runtime Error",
-			message: fmt.Sprintf("abs expected 1 argument, got %d", len(args)),
-			EXISTS:  true,
-		}
-	}
-	if typeof(args[0]) != "number" {
-		return nil, ArErr{TYPE: "Runtime Error",
-			message: fmt.Sprintf("abs expected number, got %s", typeof(args[0])),
-			EXISTS:  true,
-		}
-	}
-	return abs(args[0].(number)), ArErr{}
-}}

src/array.go

@@ -25,6 +25,48 @@ func ArArray(arr []any) ArObject {
 			"__value__": arr,
 		},
 	}
+	val.obj["__json__"] = builtinFunc{
+		"__json__",
+		func(args ...any) (any, ArErr) {
+			if len(args) != 1 {
+				return "", ArErr{
+					TYPE:    "Type Error",
+					message: "expected 1 argument, got " + fmt.Sprint(len(args)),
+					EXISTS:  true,
+				}
+			}
+			if typeof(args[0]) != "number" {
+				return "", ArErr{
+					TYPE:    "Type Error",
+					message: "expected number, got " + typeof(args[0]),
+					EXISTS:  true,
+				}
+			}
+
+			output := []string{}
+
+			level, err := numberToInt64(args[0].(ArObject))
+			if err != nil {
+				return "", ArErr{
+					TYPE:    "Runtime Error",
+					message: err.Error(),
+					EXISTS:  true,
+				}
+			}
+			for _, value := range arr {
+				str, err := jsonstringify(value, level+1)
+				if err != nil {
+					return "", ArErr{
+						TYPE:    "Runtime Error",
+						message: err.Error(),
+						EXISTS:  true,
+					}
+				}
+				output = append(output, str)
+			}
+			return "[" + strings.Join(output, ", ") + "]", ArErr{}
+		},
+	}
 	val.obj["__setindex__"] = builtinFunc{
 		"__setindex__",
 		func(a ...any) (any, ArErr) {
@@ -38,18 +80,26 @@ func ArArray(arr []any) ArObject {
 			if typeof(a[0]) != "number" {
 				return nil, ArErr{
 					TYPE:    "Type Error",
-					message: "dex must be a number",
+					message: "index must be a number",
 					EXISTS:  true,
 				}
 			}
-			if !a[0].(number).IsInt() {
+			if !isNumberInt(a[0].(ArObject)) {
 				return nil, ArErr{
 					TYPE:    "Type Error",
 					message: "index must be an integer",
 					EXISTS:  true,
 				}
 			}
-			num := int(a[0].(number).Num().Int64())
+			num64, err := numberToInt64(a[0].(ArObject))
+			if err != nil {
+				return nil, ArErr{
+					TYPE:    "Runtime Error",
+					message: err.Error(),
+					EXISTS:  true,
+				}
+			}
+			num := int(num64)
 			if num < 0 || num >= len(arr) {
 				return nil, ArErr{
 					TYPE:    "Index Error",
@@ -75,7 +125,7 @@ func ArArray(arr []any) ArObject {
 					if typeof(a[0]) == "string" {
 						var name = ArValidToAny(a[0]).(string)
 						if name == "length" {
-							return newNumber().SetInt64(int64(len(arr))), ArErr{}
+							return Number(len(arr)), ArErr{}
 						}
 					}
 				}
@@ -88,40 +138,64 @@ func ArArray(arr []any) ArObject {
 			{
 				if a[0] == nil {
 					start = 0
-				} else if typeof(a[0]) != "number" || !a[0].(number).IsInt() {
+				} else if typeof(a[0]) != "number" || !isNumberInt(a[0].(ArObject)) {
 					return "", ArErr{
 						TYPE:    "Type Error",
 						message: "slice index must be an integer",
 						EXISTS:  true,
 					}
 				} else {
-					start = int(a[0].(number).Num().Int64())
+					start64, err := numberToInt64(a[0].(ArObject))
+					if err != nil {
+						return "", ArErr{
+							TYPE:    "Runtime Error",
+							message: err.Error(),
+							EXISTS:  true,
+						}
+					}
+					start = int(start64)
 				}
 			}
 			if len(a) > 1 {
 				if a[1] == nil {
 					end = len(arr)
-				} else if typeof(a[1]) != "number" || !a[1].(number).IsInt() {
+				} else if typeof(a[1]) != "number" || !isNumberInt(a[1].(ArObject)) {
 					return "", ArErr{
 						TYPE:    "Type Error",
 						message: "slice index must be an integer",
 						EXISTS:  true,
 					}
 				} else {
-					end = int(a[1].(number).Num().Int64())
+					end64, err := numberToInt64(a[1].(ArObject))
+					if err != nil {
+						return "", ArErr{
+							TYPE:    "Runtime Error",
+							message: err.Error(),
+							EXISTS:  true,
+						}
+					}
+					end = int(end64)
 				}
 			}
 			if len(a) > 2 {
 				if a[2] == nil {
 					step = 1
-				} else if typeof(a[2]) != "number" || !a[2].(number).IsInt() {
+				} else if typeof(a[2]) != "number" || !isNumberInt(a[2].(ArObject)) {
 					return "", ArErr{
 						TYPE:    "Type Error",
 						message: "slice index must be an integer",
 						EXISTS:  true,
 					}
 				} else {
-					step = int(a[2].(number).Num().Int64())
+					step64, err := numberToInt64(a[2].(ArObject))
+					if err != nil {
+						return "", ArErr{
+							TYPE:    "Runtime Error",
+							message: err.Error(),
+							EXISTS:  true,
+						}
+					}
+					step = int(step64)
 				}
 			}
 			var ogStart = start
@@ -176,14 +250,22 @@ func ArArray(arr []any) ArObject {
 					EXISTS:  true,
 				}
 			}
-			if !args[0].(number).IsInt() {
+			if !isNumberInt(args[0].(ArObject)) {
 				return nil, ArErr{
 					TYPE:    "Type Error",
 					message: "argument must be an integer",
 					EXISTS:  true,
 				}
 			}
-			num := int(args[0].(number).Num().Int64())
+			num64, err := (numberToInt64(args[0].(ArObject)))
+			if err != nil {
+				return nil, ArErr{
+					TYPE:    "Runtime Error",
+					message: err.Error(),
+					EXISTS:  true,
+				}
+			}
+			num := int(num64)
 			if num < 0 || num >= len(arr) {
 				return nil, ArErr{
 					TYPE:    "Index Error",
@@ -227,14 +309,22 @@ func ArArray(arr []any) ArObject {
 					EXISTS:  true,
 				}
 			}
-			if !args[0].(number).IsInt() {
+			if !isNumberInt(args[0].(ArObject)) {
 				return nil, ArErr{
 					TYPE:    "Type Error",
 					message: "argument must be an integer",
 					EXISTS:  true,
 				}
 			}
-			num := int(args[0].(number).Num().Int64())
+			num64, err := numberToInt64(args[0].(ArObject))
+			if err != nil {
+				return nil, ArErr{
+					TYPE:    "Runtime Error",
+					message: err.Error(),
+					EXISTS:  true,
+				}
+			}
+			num := int(num64)
 			if num < 0 || num > len(arr) {
 				return nil, ArErr{
 					TYPE:    "Index Error",
@@ -265,14 +355,22 @@ func ArArray(arr []any) ArObject {
 						EXISTS:  true,
 					}
 				}
-				if !args[0].(number).IsInt() {
+				if !isNumberInt(args[0].(ArObject)) {
 					return nil, ArErr{
 						TYPE:    "Type Error",
 						message: "argument must be an integer",
 						EXISTS:  true,
 					}
 				}
-				num := int(args[0].(number).Num().Int64())
+				num64, err := (numberToInt64(args[0].(ArObject)))
+				if err != nil {
+					return nil, ArErr{
+						TYPE:    "Runtime Error",
+						message: err.Error(),
+						EXISTS:  true,
+					}
+				}
+				num := int(num64)
 				if num < 0 || num >= len(arr) {
 					return nil, ArErr{
 						TYPE:    "Index Error",

src/arvalid.go

@@ -1,5 +1,7 @@
 package main
 
+import "math/big"
+
 func AnyToArValid(arr any) any {
 	switch arr := arr.(type) {
 	case []any:
@@ -12,6 +14,8 @@ func AnyToArValid(arr any) any {
 		return ArBuffer(arr)
 	case byte:
 		return ArByte(arr)
+	case int, int64, float64, float32, *big.Rat, *big.Int:
+		return Number(arr)
 	default:
 		return arr
 	}
@@ -26,20 +30,3 @@ func ArValidToAny(a any) any {
 	}
 	return a
 }
-
-func ArValidToHash(a any) (any, ArErr) {
-	switch a := a.(type) {
-	case ArObject:
-		if callable, ok := a.obj["__hash__"]; ok {
-			value, err := runCall(call{
-				Callable: callable,
-				Args:     []any{},
-			}, stack{}, 0)
-			if err.EXISTS {
-				return nil, err
-			}
-			return value, ArErr{}
-		}
-	}
-	return a, ArErr{}
-}

src/boolean.go

@@ -8,8 +8,6 @@ func anyToBool(x any) bool {
 	switch x := x.(type) {
 	case string:
 		return x != ""
-	case number:
-		return x.Cmp(newNumber()) != 0
 	case bool:
 		return x
 	case nil:

src/buffer.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"bytes"
+	"encoding/hex"
 	"fmt"
 )
 
@@ -15,19 +16,19 @@ func ArByte(Byte byte) ArObject {
 	obj.obj["__string__"] = builtinFunc{
 		"__string__",
 		func(a ...any) (any, ArErr) {
-			return "<byte>", ArErr{}
+			return ArString("0x" + hex.EncodeToString([]byte{Byte})), ArErr{}
 		},
 	}
 	obj.obj["__repr__"] = builtinFunc{
 		"__repr__",
 		func(a ...any) (any, ArErr) {
-			return "<byte>", ArErr{}
+			return ArString("<byte 0x" + hex.EncodeToString([]byte{Byte}) + ">"), ArErr{}
 		},
 	}
 	obj.obj["number"] = builtinFunc{
 		"number",
 		func(a ...any) (any, ArErr) {
-			return newNumber().SetInt64(int64(Byte)), ArErr{}
+			return Number(int64(Byte)), ArErr{}
 		},
 	}
 	obj.obj["from"] = builtinFunc{
@@ -42,23 +43,15 @@ func ArByte(Byte byte) ArObject {
 			}
 			a[0] = ArValidToAny(a[0])
 			switch x := a[0].(type) {
-			case number:
-				if x.Denom().Cmp(one.Denom()) != 0 {
-					return nil, ArErr{
-						TYPE:    "Type Error",
-						message: "expected integer, got " + fmt.Sprint(x),
-						EXISTS:  true,
-					}
-				}
-				n := x.Num().Int64()
-				if n > 255 || n < 0 {
+			case int64:
+				if x > 255 || x < 0 {
 					return nil, ArErr{
 						TYPE:    "ValueError",
-						message: "expected number between 0 and 255, got " + fmt.Sprint(floor(x).Num().Int64()),
+						message: "expected number between 0 and 255, got " + fmt.Sprint(x),
 						EXISTS:  true,
 					}
 				}
-				Byte = byte(n)
+				Byte = byte(x)
 			case string:
 				if len(x) != 1 {
 					return nil, ArErr{
@@ -91,13 +84,13 @@ func ArBuffer(buf []byte) ArObject {
 	obj.obj["__string__"] = builtinFunc{
 		"__string__",
 		func(a ...any) (any, ArErr) {
-			return "<buffer>", ArErr{}
+			return ArString("<buffer length=" + fmt.Sprint(len(buf)) + ">"), ArErr{}
 		},
 	}
 	obj.obj["__repr__"] = builtinFunc{
 		"__repr__",
 		func(a ...any) (any, ArErr) {
-			return "<buffer>", ArErr{}
+			return ArString("<buffer length=" + fmt.Sprint(len(buf)) + ">"), ArErr{}
 		},
 	}
 	obj.obj["from"] = builtinFunc{
@@ -119,16 +112,17 @@ func ArBuffer(buf []byte) ArObject {
 			case []any:
 				outputbuf := []byte{}
 				for _, v := range x {
-					switch y := v.(type) {
-					case number:
-						if y.Denom().Cmp(one.Denom()) != 0 {
+					V := ArValidToAny(v)
+					switch y := V.(type) {
+					case int64:
+						if y > 255 || y < 0 {
 							return nil, ArErr{
-								TYPE:    "Type Error",
-								message: "Cannot convert non-integer to byte",
+								TYPE:    "ValueError",
+								message: "expected number between 0 and 255, got " + fmt.Sprint(y),
 								EXISTS:  true,
 							}
 						}
-						outputbuf = append(outputbuf, byte(y.Num().Int64()))
+						outputbuf = append(outputbuf, byte(y))
 					default:
 						return nil, ArErr{
 							TYPE:    "Type Error",
@@ -176,15 +170,14 @@ func ArBuffer(buf []byte) ArObject {
 					EXISTS:  true,
 				}
 			}
-			nNum := nVal.(number)
-			if nNum.Denom().Cmp(one.Denom()) != 0 {
+			n, err := numberToInt64(nVal.(ArObject))
+			if err != nil {
 				return nil, ArErr{
 					TYPE:    "Type Error",
-					message: "expected integer, got " + fmt.Sprint(nNum),
+					message: err.Error(),
 					EXISTS:  true,
 				}
 			}
-			n := nNum.Num().Int64()
 			var result [][]byte
 			start := 0
 			var i int64
@@ -258,39 +251,37 @@ func ArBuffer(buf []byte) ArObject {
 					EXISTS:  true,
 				}
 			}
-			startVal := ArValidToAny(a[0])
-			if typeof(startVal) != "number" {
+			if typeof(a[0]) != "number" || typeof(a[1]) != "number" {
 				return nil, ArErr{
 					TYPE:    "Type Error",
-					message: "expected number, got " + typeof(startVal),
+					message: "expected number, got " + typeof(a[0]) + " and " + typeof(a[1]),
 					EXISTS:  true,
 				}
 			}
-			start := startVal.(number)
-			if start.Denom().Cmp(one.Denom()) != 0 {
+			start, err := numberToInt64(ArValidToAny(a[0]).(ArObject))
+			if err != nil {
 				return nil, ArErr{
 					TYPE:    "Type Error",
-					message: "expected integer, got " + fmt.Sprint(start),
+					message: err.Error(),
 					EXISTS:  true,
 				}
 			}
-			endVal := ArValidToAny(a[1])
-			if typeof(endVal) != "number" {
+			end, err := numberToInt64(ArValidToAny(a[1]).(ArObject))
+			if err != nil {
 				return nil, ArErr{
 					TYPE:    "Type Error",
-					message: "expected number, got " + typeof(endVal),
+					message: err.Error(),
 					EXISTS:  true,
 				}
 			}
-			end := endVal.(number)
-			if end.Denom().Cmp(one.Denom()) != 0 {
+			if start < 0 || end < 0 || start > int64(len(buf)) || end > int64(len(buf)) {
 				return nil, ArErr{
-					TYPE:    "Type Error",
-					message: "expected integer, got " + fmt.Sprint(end),
+					TYPE:    "Index Error",
+					message: "index out of range",
 					EXISTS:  true,
 				}
 			}
-			return ArBuffer(buf[floor(start).Num().Int64():floor(end).Num().Int64()]), ArErr{}
+			return ArBuffer(buf[start:end]), ArErr{}
 		},
 	}
 	obj.obj["to"] = builtinFunc{
@@ -323,7 +314,7 @@ func ArBuffer(buf []byte) ArObject {
 			case "array":
 				output := []any{}
 				for _, v := range buf {
-					output = append(output, newNumber().SetInt64(int64(v)))
+					output = append(output, Number(int64(v)))
 				}
 				return ArArray(output), ArErr{}
 			default:
@@ -347,15 +338,15 @@ func ArBuffer(buf []byte) ArObject {
 			}
 			a[0] = ArValidToAny(a[0])
 			switch x := a[0].(type) {
-			case number:
-				if x.Denom().Cmp(one.Denom()) != 0 {
+			case int64:
+				if x > 255 || x < 0 {
 					return nil, ArErr{
-						TYPE:    "Type Error",
-						message: "Cannot convert non-integer to byte",
+						TYPE:    "ValueError",
+						message: "expected number between 0 and 255, got " + fmt.Sprint(x),
 						EXISTS:  true,
 					}
 				}
-				buf = append(buf, byte(x.Num().Int64()))
+				buf = append(buf, byte(x))
 			case string:
 				buf = append(buf, []byte(x)...)
 			case []byte:
@@ -363,15 +354,15 @@ func ArBuffer(buf []byte) ArObject {
 			case []any:
 				for _, v := range x {
 					switch y := v.(type) {
-					case number:
-						if y.Denom().Cmp(one.Denom()) != 0 {
+					case int64:
+						if y > 255 || y < 0 {
 							return nil, ArErr{
-								TYPE:    "Type Error",
-								message: "Cannot convert non-integer to byte",
+								TYPE:    "ValueError",
+								message: "expected number between 0 and 255, got " + fmt.Sprint(y),
 								EXISTS:  true,
 							}
 						}
-						buf = append(buf, byte(y.Num().Int64()))
+						buf = append(buf, byte(y))
 					default:
 						return nil, ArErr{
 							TYPE:    "Type Error",
@@ -410,25 +401,24 @@ func ArBuffer(buf []byte) ArObject {
 					EXISTS:  true,
 				}
 			}
-			pos := poss.(number)
-			if pos.Denom().Cmp(one.Denom()) != 0 {
+			posNum, err := numberToInt64(poss.(ArObject))
+			if err != nil {
 				return nil, ArErr{
 					TYPE:    "Type Error",
-					message: "position must be an integer",
+					message: err.Error(),
 					EXISTS:  true,
 				}
 			}
-			posNum := pos.Num().Int64()
 			switch x := values.(type) {
-			case number:
-				if x.Denom().Cmp(one.Denom()) != 0 {
+			case int64:
+				if x > 255 || x < 0 {
 					return nil, ArErr{
-						TYPE:    "Type Error",
-						message: "Cannot convert non-integer to byte",
+						TYPE:    "ValueError",
+						message: "expected number between 0 and 255, got " + fmt.Sprint(x),
 						EXISTS:  true,
 					}
 				}
-				buf = append(buf[:posNum], append([]byte{byte(x.Num().Int64())}, buf[posNum:]...)...)
+				buf = append(buf[:posNum], append([]byte{byte(x)}, buf[posNum:]...)...)
 			case string:
 				buf = append(buf[:posNum], append([]byte(x), buf[posNum:]...)...)
 			case []byte:
@@ -436,15 +426,15 @@ func ArBuffer(buf []byte) ArObject {
 			case []any:
 				for _, v := range x {
 					switch y := v.(type) {
-					case number:
-						if y.Denom().Cmp(one.Denom()) != 0 {
+					case int64:
+						if y > 255 || y < 0 {
 							return nil, ArErr{
-								TYPE:    "Type Error",
-								message: "Cannot convert non-integer to byte",
+								TYPE:    "ValueError",
+								message: "expected number between 0 and 255, got " + fmt.Sprint(y),
 								EXISTS:  true,
 							}
 						}
-						buf = append(buf[:posNum], append([]byte{byte(y.Num().Int64())}, buf[posNum:]...)...)
+						buf = append(buf[:posNum], append([]byte{byte(y)}, buf[posNum:]...)...)
 					default:
 						return nil, ArErr{
 							TYPE:    "Type Error",
@@ -479,12 +469,12 @@ func ArBuffer(buf []byte) ArObject {
 					if typeof(a[0]) == "string" {
 						var name = ArValidToAny(a[0]).(string)
 						if name == "length" {
-							return newNumber().SetInt64(int64(len(buf))), ArErr{}
+							return Number(len(buf)), ArErr{}
 						}
 					}
 				}
 			}
-			poss := ArValidToAny(a[0])
+			poss := a[0]
 			if typeof(poss) != "number" {
 				return nil, ArErr{
 					TYPE:    "Type Error",
@@ -492,15 +482,14 @@ func ArBuffer(buf []byte) ArObject {
 					EXISTS:  true,
 				}
 			}
-			pos := poss.(number)
-			if pos.Denom().Cmp(one.Denom()) != 0 {
+			posNum, err := numberToInt64(poss.(ArObject))
+			if err != nil {
 				return nil, ArErr{
 					TYPE:    "Type Error",
-					message: "position must be an integer",
+					message: err.Error(),
 					EXISTS:  true,
 				}
 			}
-			posNum := pos.Num().Int64()
 			if posNum < 0 || posNum >= int64(len(buf)) {
 				return nil, ArErr{
 					TYPE:    "Index Error",
@@ -529,15 +518,21 @@ func ArBuffer(buf []byte) ArObject {
 					EXISTS:  true,
 				}
 			}
-			pos := poss.(number)
-			if pos.Denom().Cmp(one.Denom()) != 0 {
+			posNum, err := numberToInt64(poss.(ArObject))
+			if err != nil {
 				return nil, ArErr{
 					TYPE:    "Type Error",
-					message: "position must be an integer",
+					message: err.Error(),
+					EXISTS:  true,
+				}
+			}
+			if posNum < 0 || posNum >= int64(len(buf)) {
+				return nil, ArErr{
+					TYPE:    "Index Error",
+					message: "index out of range",
 					EXISTS:  true,
 				}
 			}
-			posNum := pos.Num().Int64()
 			buf = append(buf[:posNum], buf[posNum+1:]...)
 			obj.obj["__value__"] = buf
 			return obj, ArErr{}

src/built-in-functions.go

@@ -19,7 +19,7 @@ func ArgonString(args ...any) (any, ArErr) {
 
 func ArgonNumber(args ...any) (any, ArErr) {
 	if len(args) == 0 {
-		return newNumber(), ArErr{}
+		return _zero_Number, ArErr{}
 	}
 	args[0] = ArValidToAny(args[0])
 	switch x := args[0].(type) {
@@ -27,17 +27,17 @@ func ArgonNumber(args ...any) (any, ArErr) {
 		if !isNumber(UNPARSEcode{code: x}) {
 			return nil, ArErr{TYPE: "Conversion Error", message: "Cannot convert " + anyToArgon(x, true, true, 3, 0, false, 0) + " to a number", EXISTS: true}
 		}
-		N, _ := newNumber().SetString(x)
+		N := Number(x)
 		return N, ArErr{}
-	case number:
-		return x, ArErr{}
+	case int64, *big.Int, *big.Rat:
+		return Number(x), ArErr{}
 	case bool:
 		if x {
-			return newNumber().SetInt64(1), ArErr{}
+			return _one_Number, ArErr{}
 		}
-		return newNumber(), ArErr{}
+		return _zero_Number, ArErr{}
 	case nil:
-		return newNumber(), ArErr{}
+		return _zero_Number, ArErr{}
 	}
 
 	return nil, ArErr{TYPE: "Number Error", message: "Cannot convert " + typeof(args[0]) + " to a number", EXISTS: true}
@@ -48,26 +48,12 @@ func ArgonSqrt(a ...any) (any, ArErr) {
 		return nil, ArErr{TYPE: "Runtime Error", message: "sqrt takes 1 argument",
 			EXISTS: true}
 	}
-	if typeof(a[0]) != "number" {
-		return nil, ArErr{TYPE: "Runtime Error", message: "sqrt takes a number not a '" + typeof(a[0]) + "'",
+	if _, ok := a[0].(ArObject); !ok {
+		return nil, ArErr{TYPE: "Runtime Error", message: "can't sqrt type '" + typeof(a[0]) + "'",
 			EXISTS: true}
 	}
-
-	r := a[0].(number)
-
-	if r.Sign() < 0 {
-		return nil, ArErr{TYPE: "Runtime Error", message: "sqrt takes a positive number",
-			EXISTS: true}
+	if sqrt_method, ok := a[0].(ArObject).obj["__sqrt__"]; ok {
+		return builtinCall(sqrt_method, []any{})
 	}
-
-	var x big.Float
-	x.SetPrec(30)
-	x.SetRat(r)
-
-	var s big.Float
-	s.SetPrec(15)
-	s.Sqrt(&x)
-
-	r, _ = s.Rat(nil)
-	return r, ArErr{}
+	return nil, ArErr{TYPE: "Runtime Error", message: "can't sqrt type '" + typeof(a[0]) + "'"}
 }

src/built-ins.go

@@ -11,14 +11,13 @@ func makeGlobal() ArObject {
 	vars["env"] = env
 	vars["term"] = ArTerm
 	vars["ArgonVersion"] = ArString(VERSION)
-	vars["ArgonVersionNumber"] = newNumber().SetInt64(VERSION_NUM)
+	vars["ArgonVersionNumber"] = Number(VERSION_NUM)
 	vars["number"] = builtinFunc{"number", ArgonNumber}
 	vars["string"] = builtinFunc{"string", ArgonString}
 	vars["socket"] = Map(anymap{
 		"server": builtinFunc{"server", ArSocketServer},
 		"client": builtinFunc{"client", ArSocketClient},
 	})
-	vars["infinity"] = infinity
 	vars["eval"] = builtinFunc{"eval", AReval}
 	vars["map"] = builtinFunc{"map", func(a ...any) (any, ArErr) {
 		if len(a) == 0 {
@@ -66,12 +65,8 @@ func makeGlobal() ArObject {
 		}
 		a[0] = ArValidToAny(a[0])
 		switch x := a[0].(type) {
-		case number:
-			if x.Denom().Cmp(one.Denom()) != 0 {
-				return nil, ArErr{TYPE: "Type Error", message: "Cannot convert non-integer to hex", EXISTS: true}
-			}
-			n := x.Num().Int64()
-			return ArString(fmt.Sprintf("%x", n)), ArErr{}
+		case int64:
+			return ArString(fmt.Sprintf("%x", x)), ArErr{}
 		}
 		return nil, ArErr{TYPE: "Type Error", message: "Cannot convert '" + typeof(a[0]) + "' to hex", EXISTS: true}
 	}}
@@ -132,22 +127,21 @@ func makeGlobal() ArObject {
 			return nil, ArErr{TYPE: "round", message: "round takes 1 argument",
 				EXISTS: true}
 		}
-		precision := newNumber()
+		var precision int64 = 0
 		if len(a) > 1 {
+			a[1] = ArValidToAny(a[1])
 			switch x := a[1].(type) {
-			case number:
-				if !x.IsInt() {
-					return nil, ArErr{TYPE: "Type Error", message: "Cannot round to '" + typeof(a[1]) + "'", EXISTS: true}
-				}
+			case int64:
 				precision = x
 			default:
 				return nil, ArErr{TYPE: "Type Error", message: "Cannot round to '" + typeof(a[1]) + "'", EXISTS: true}
 			}
 		}
-
 		switch x := a[0].(type) {
-		case number:
-			return round(newNumber().Set(x), int(precision.Num().Int64())), ArErr{}
+		case ArObject:
+			if round_method, ok := x.obj["__round__"]; ok {
+				return builtinCall(round_method, []any{Number(precision)})
+			}
 		}
 		return nil, ArErr{TYPE: "Type Error", message: "Cannot round '" + typeof(a[0]) + "'", EXISTS: true}
 	}}
@@ -157,8 +151,10 @@ func makeGlobal() ArObject {
 				EXISTS: true}
 		}
 		switch x := a[0].(type) {
-		case number:
-			return floor(x), ArErr{}
+		case ArObject:
+			if floor_method, ok := x.obj["__floor__"]; ok {
+				return builtinCall(floor_method, []any{})
+			}
 		}
 		return nil, ArErr{TYPE: "Type Error", message: "Cannot floor '" + typeof(a[0]) + "'", EXISTS: true}
 	}}
@@ -167,10 +163,11 @@ func makeGlobal() ArObject {
 			return nil, ArErr{TYPE: "ceil", message: "ceil takes 1 argument",
 				EXISTS: true}
 		}
-
 		switch x := a[0].(type) {
-		case number:
-			return ceil(x), ArErr{}
+		case ArObject:
+			if ceil_method, ok := x.obj["__ceil__"]; ok {
+				return builtinCall(ceil_method, []any{})
+			}
 		}
 		return nil, ArErr{TYPE: "Type Error", message: "Cannot ceil '" + typeof(a[0]) + "'", EXISTS: true}
 	}}
@@ -193,15 +190,12 @@ func makeGlobal() ArObject {
 	vars["todeg"] = ArToDeg
 	vars["colour"] = ArColour
 	vars["torad"] = ArToRad
-	vars["abs"] = ArAbs
 	vars["fraction"] = builtinFunc{"fraction", func(a ...any) (any, ArErr) {
 		if len(a) == 0 {
 			return nil, ArErr{TYPE: "fraction", message: "fraction takes 1 argument",
 				EXISTS: true}
 		}
 		switch x := a[0].(type) {
-		case number:
-			return ArString(x.String()), ArErr{}
 		case ArObject:
 			if callable, ok := x.obj["__fraction__"]; ok {
 				resp, err := runCall(
@@ -229,7 +223,7 @@ func makeGlobal() ArObject {
 		case ArObject:
 			newarray := []any{}
 			for key := range x.obj {
-				newarray = append(newarray, key)
+				newarray = append(newarray, AnyToArValid(key))
 			}
 			return ArArray(newarray), ArErr{}
 		}
@@ -241,9 +235,11 @@ func makeGlobal() ArObject {
 		if len(a) == 0 {
 			os.Exit(0)
 		}
+		a[0] = ArValidToAny(a[0])
 		switch x := a[0].(type) {
-		case number:
-			os.Exit(int(floor(x).Num().Int64()))
+		case int64:
+			os.Exit(int(x))
+			return nil, ArErr{}
 		}
 		os.Exit(0)
 		return nil, ArErr{}
@@ -252,9 +248,10 @@ func makeGlobal() ArObject {
 		if len(a) != 1 {
 			return nil, ArErr{TYPE: "chr", message: "chr takes 1 argument, got " + fmt.Sprint(len(a)), EXISTS: true}
 		}
+		a[0] = ArValidToAny(a[0])
 		switch x := a[0].(type) {
-		case number:
-			return string([]rune{rune(floor(x).Num().Int64())}), ArErr{}
+		case int64:
+			return string([]rune{rune(x)}), ArErr{}
 		}
 		return nil, ArErr{TYPE: "Type Error", message: "Cannot convert '" + typeof(a[0]) + "' to string", EXISTS: true}
 	}}
@@ -268,7 +265,7 @@ func makeGlobal() ArObject {
 			if len(x) != 1 {
 				return nil, ArErr{TYPE: "ord", message: "ord takes a string with only one character, got " + fmt.Sprint(len(a)), EXISTS: true}
 			}
-			return floor(newNumber().SetInt64(int64([]rune(x)[0]))), ArErr{}
+			return Number(int64([]rune(x)[0])), ArErr{}
 		}
 		return nil, ArErr{TYPE: "Type Error", message: "Cannot convert '" + typeof(a[0]) + "' to string", EXISTS: true}
 	}}
@@ -282,15 +279,27 @@ func makeGlobal() ArObject {
 			if len(x) == 0 {
 				return nil, ArErr{TYPE: "runtime Error", message: "max takes a non-empty array", EXISTS: true}
 			}
-			var max number
+			var max ArObject
 			for i, v := range x {
-				switch m := v.(type) {
-				case number:
+				switch x := v.(type) {
+				case ArObject:
 					if i == 0 {
-						max = m
+						max = x
 					} else {
-						if m.Cmp(max) == 1 {
-							max = m
+						compared, err := CompareObjects(max, x)
+
+						if err.EXISTS {
+							return nil, err
+						}
+
+						compared_int, Err := numberToInt64(compared)
+
+						if Err != nil {
+							return nil, ArErr{TYPE: "Type Error", message: Err.Error(), EXISTS: true}
+						}
+
+						if compared_int == 1 {
+							max = x
 						}
 					}
 				}
@@ -309,15 +318,27 @@ func makeGlobal() ArObject {
 			if len(x) == 0 {
 				return nil, ArErr{TYPE: "runtime Error", message: "max takes a non-empty array", EXISTS: true}
 			}
-			var max number
+			var max ArObject
 			for i, v := range x {
-				switch m := v.(type) {
-				case number:
+				switch x := v.(type) {
+				case ArObject:
 					if i == 0 {
-						max = m
+						max = x
 					} else {
-						if m.Cmp(max) == -1 {
-							max = m
+						compared, err := CompareObjects(max, x)
+
+						if err.EXISTS {
+							return nil, err
+						}
+
+						compared_int, Err := numberToInt64(compared)
+
+						if Err != nil {
+							return nil, ArErr{TYPE: "Type Error", message: Err.Error(), EXISTS: true}
+						}
+
+						if compared_int == -1 {
+							max = x
 						}
 					}
 				}

src/colour.go

@@ -19,8 +19,16 @@ var ArColour = Map(
 			}
 			var c *color.Color
 			var s string
-			if x, ok := a[0].(number); ok {
-				c = color.Set(color.Attribute(x.Num().Int64()))
+			if x, ok := a[0].(ArObject); ok {
+				colour_int64, err := numberToInt64(x)
+				if err != nil {
+					return nil, ArErr{
+						TYPE:    "Type Error",
+						message: err.Error(),
+						EXISTS:  true,
+					}
+				}
+				c = color.New(color.Attribute(colour_int64))
 			} else {
 				return nil, ArErr{
 					TYPE:    "Type Error",
@@ -45,52 +53,52 @@ var ArColour = Map(
 		}},
 		"bg": Map(
 			anymap{
-				"black":     newNumber().SetInt64(int64(color.BgBlack)),
-				"red":       newNumber().SetInt64(int64(color.BgRed)),
-				"green":     newNumber().SetInt64(int64(color.BgGreen)),
-				"yellow":    newNumber().SetInt64(int64(color.BgYellow)),
-				"blue":      newNumber().SetInt64(int64(color.BgBlue)),
-				"magenta":   newNumber().SetInt64(int64(color.BgMagenta)),
-				"cyan":      newNumber().SetInt64(int64(color.BgCyan)),
-				"white":     newNumber().SetInt64(int64(color.BgWhite)),
-				"hiBlack":   newNumber().SetInt64(int64(color.BgHiBlack)),
-				"hiRed":     newNumber().SetInt64(int64(color.BgHiRed)),
-				"hiGreen":   newNumber().SetInt64(int64(color.BgHiGreen)),
-				"hiYellow":  newNumber().SetInt64(int64(color.BgHiYellow)),
-				"hiBlue":    newNumber().SetInt64(int64(color.BgHiBlue)),
-				"hiMagenta": newNumber().SetInt64(int64(color.BgHiMagenta)),
-				"hiCyan":    newNumber().SetInt64(int64(color.BgHiCyan)),
-				"hiWhite":   newNumber().SetInt64(int64(color.BgHiWhite)),
+				"black":     Number(int64(color.BgBlack)),
+				"red":       Number(int64(color.BgRed)),
+				"green":     Number(int64(color.BgGreen)),
+				"yellow":    Number(int64(color.BgYellow)),
+				"blue":      Number(int64(color.BgBlue)),
+				"magenta":   Number(int64(color.BgMagenta)),
+				"cyan":      Number(int64(color.BgCyan)),
+				"white":     Number(int64(color.BgWhite)),
+				"hiBlack":   Number(int64(color.BgHiBlack)),
+				"hiRed":     Number(int64(color.BgHiRed)),
+				"hiGreen":   Number(int64(color.BgHiGreen)),
+				"hiYellow":  Number(int64(color.BgHiYellow)),
+				"hiBlue":    Number(int64(color.BgHiBlue)),
+				"hiMagenta": Number(int64(color.BgHiMagenta)),
+				"hiCyan":    Number(int64(color.BgHiCyan)),
+				"hiWhite":   Number(int64(color.BgHiWhite)),
 			},
 		),
 		"fg": Map(
 			anymap{
-				"black":     newNumber().SetInt64(int64(color.FgBlack)),
-				"red":       newNumber().SetInt64(int64(color.FgRed)),
-				"green":     newNumber().SetInt64(int64(color.FgGreen)),
-				"yellow":    newNumber().SetInt64(int64(color.FgYellow)),
-				"blue":      newNumber().SetInt64(int64(color.FgBlue)),
-				"magenta":   newNumber().SetInt64(int64(color.FgMagenta)),
-				"cyan":      newNumber().SetInt64(int64(color.FgCyan)),
-				"white":     newNumber().SetInt64(int64(color.FgWhite)),
-				"hiBlack":   newNumber().SetInt64(int64(color.FgHiBlack)),
-				"hiRed":     newNumber().SetInt64(int64(color.FgHiRed)),
-				"hiGreen":   newNumber().SetInt64(int64(color.FgHiGreen)),
-				"hiYellow":  newNumber().SetInt64(int64(color.FgHiYellow)),
-				"hiBlue":    newNumber().SetInt64(int64(color.FgHiBlue)),
-				"hiMagenta": newNumber().SetInt64(int64(color.FgHiMagenta)),
-				"hiCyan":    newNumber().SetInt64(int64(color.FgHiCyan)),
-				"hiWhite":   newNumber().SetInt64(int64(color.FgHiWhite)),
+				"black":     Number(int64(color.FgBlack)),
+				"red":       Number(int64(color.FgRed)),
+				"green":     Number(int64(color.FgGreen)),
+				"yellow":    Number(int64(color.FgYellow)),
+				"blue":      Number(int64(color.FgBlue)),
+				"magenta":   Number(int64(color.FgMagenta)),
+				"cyan":      Number(int64(color.FgCyan)),
+				"white":     Number(int64(color.FgWhite)),
+				"hiBlack":   Number(int64(color.FgHiBlack)),
+				"hiRed":     Number(int64(color.FgHiRed)),
+				"hiGreen":   Number(int64(color.FgHiGreen)),
+				"hiYellow":  Number(int64(color.FgHiYellow)),
+				"hiBlue":    Number(int64(color.FgHiBlue)),
+				"hiMagenta": Number(int64(color.FgHiMagenta)),
+				"hiCyan":    Number(int64(color.FgHiCyan)),
+				"hiWhite":   Number(int64(color.FgHiWhite)),
 			},
 		),
-		"reset":        newNumber().SetInt64(int64(color.Reset)),
-		"bold":         newNumber().SetInt64(int64(color.Bold)),
-		"faint":        newNumber().SetInt64(int64(color.Faint)),
-		"italic":       newNumber().SetInt64(int64(color.Italic)),
-		"underline":    newNumber().SetInt64(int64(color.Underline)),
-		"blinkSlow":    newNumber().SetInt64(int64(color.BlinkSlow)),
-		"blinkRapid":   newNumber().SetInt64(int64(color.BlinkRapid)),
-		"reverseVideo": newNumber().SetInt64(int64(color.ReverseVideo)),
-		"concealed":    newNumber().SetInt64(int64(color.Concealed)),
-		"crossedOut":   newNumber().SetInt64(int64(color.CrossedOut)),
+		"reset":        Number(int64(color.Reset)),
+		"bold":         Number(int64(color.Bold)),
+		"faint":        Number(int64(color.Faint)),
+		"italic":       Number(int64(color.Italic)),
+		"underline":    Number(int64(color.Underline)),
+		"blinkSlow":    Number(int64(color.BlinkSlow)),
+		"blinkRapid":   Number(int64(color.BlinkRapid)),
+		"reverseVideo": Number(int64(color.ReverseVideo)),
+		"concealed":    Number(int64(color.Concealed)),
+		"crossedOut":   Number(int64(color.CrossedOut)),
 	})

src/debug.go

@@ -35,7 +35,8 @@ func debugInit() {
 }
 
 func debugPrintln(a ...any) {
-	if debug {
+	switch debug {
+	case true:
 		__debugPrintsLock.Lock()
 		__debugPrints = append(__debugPrints, a)
 		__debugPrintsLock.Unlock()

src/factorial.go

@@ -28,36 +28,26 @@ func isFactorial(code UNPARSEcode) bool {
 	return factorialCompiled.MatchString(code.code)
 }
 
-func fact(n number) number {
-	if n.Cmp(newNumber().SetInt64(1000)) >= 0 {
-		return infinity
-	} else if n.Cmp(newNumber().SetInt64(0)) == -1 {
-		return newNumber().SetInt64(0)
-	} else if n.Cmp(newNumber().SetInt64(0)) == 0 {
-		return newNumber().SetInt64(1)
-	}
-	result := newNumber().SetInt64(1)
-	for i := newNumber().SetInt64(2); i.Cmp(n) <= 0; i.Add(i, newNumber().SetInt64(1)) {
-		result.Mul(result, i)
-	}
-	return result
-}
-
 func runFactorial(f factorial, stack stack, stacklevel int) (any, ArErr) {
 	val, err := runVal(f.value, stack, stacklevel+1)
 	if err.EXISTS {
 		return nil, err
 	}
-	switch x := val.(type) {
-	case number:
-		if !x.IsInt() {
-			return nil, ArErr{"Runtime Error", "cannot use factorial on non-integer", f.line, f.path, f.code, true}
+	switch val := val.(type) {
+	case ArObject:
+		if callable, ok := val.obj["__factorial__"]; ok {
+			return runCall(call{
+				Callable: callable,
+				Args:     []any{},
+				Code:     f.code,
+				Line:     f.line,
+				Path:     f.path,
+			}, stack, stacklevel)
 		}
-		if x.Cmp(newNumber().SetInt64(0)) == -1 {
-			return nil, ArErr{"Runtime Error", "cannot use factorial on negative number", f.line, f.path, f.code, true}
 	}
-		return fact(x), ArErr{}
-	default:
-		return nil, ArErr{"Runtime Error", "cannot use factorial on non-number of type '" + typeof(val) + "'", f.line, f.path, f.code, true}
+	return nil, ArErr{
+		TYPE:    "TypeError",
+		message: "factorial not defined for type",
+		EXISTS:  true,
 	}
 }

src/file.go

@@ -153,11 +153,11 @@ func ArRead(args ...any) (any, ArErr) {
 				if typeof(args[0]) != "number" {
 					return ArObject{}, ArErr{TYPE: "Runtime Error", message: "buffer takes a number not type '" + typeof(args[0]) + "'", EXISTS: true}
 				}
-				size := args[0].(number)
-				if size.Denom().Int64() != 1 {
-					return ArObject{}, ArErr{TYPE: "Runtime Error", message: "buffer takes an integer not type '" + typeof(args[0]) + "'", EXISTS: true}
+				size, err := numberToInt64(args[0].(ArObject))
+				if err != nil {
+					return ArObject{}, ArErr{TYPE: "Runtime Error", message: err.Error(), EXISTS: true}
 				}
-				buf := make([]byte, size.Num().Int64())
+				buf := make([]byte, size)
 				n, err := file.Read(buf)
 				if err != nil {
 					return ArObject{}, ArErr{TYPE: "Runtime Error", message: err.Error(), EXISTS: true}
@@ -177,11 +177,11 @@ func ArRead(args ...any) (any, ArErr) {
 			if typeof(args[0]) != "number" {
 				return ArObject{}, ArErr{TYPE: "Runtime Error", message: "seek takes a number not type '" + typeof(args[0]) + "'", EXISTS: true}
 			}
-			offset := args[0].(number)
-			if offset.Denom().Int64() != 1 {
-				return ArObject{}, ArErr{TYPE: "Runtime Error", message: "seek takes an integer not type '" + typeof(args[0]) + "'", EXISTS: true}
+			offset, Err := numberToInt64(args[0].(ArObject))
+			if Err != nil {
+				return ArObject{}, ArErr{TYPE: "Runtime Error", message: Err.Error(), EXISTS: true}
 			}
-			_, err := file.Seek(offset.Num().Int64(), io.SeekStart)
+			_, err := file.Seek(offset, io.SeekStart)
 			if err != nil {
 				return ArObject{}, ArErr{TYPE: "Runtime Error", message: err.Error(), EXISTS: true}
 			}
@@ -192,7 +192,7 @@ func ArRead(args ...any) (any, ArErr) {
 			if err != nil {
 				return ArObject{}, ArErr{TYPE: "Runtime Error", message: err.Error(), EXISTS: true}
 			}
-			return newNumber().SetInt64(info.Size()), ArErr{}
+			return Number(info.Size()), ArErr{}
 		}},
 		"ModTime": builtinFunc{"ModTime", func(...any) (any, ArErr) {
 			info, err := file.Stat()

src/forloop.go

@@ -51,7 +51,7 @@ func parseForLoop(code UNPARSEcode, index int, codelines []UNPARSEcode) (forLoop
 			innertotalstep += stepstep - 1
 			stepval = stepval_
 		} else {
-			stepval = newNumber().SetInt64(1)
+			stepval = _one_Number
 		}
 		to := strings.TrimSpace(valsplit[0])
 		toval, worked, err, tostep := translateVal(UNPARSEcode{code: to, realcode: code.realcode, line: code.line, path: code.path}, index, codelines, 0)
@@ -83,7 +83,7 @@ func runForLoop(loop forLoop, stack stack, stacklevel int) (any, ArErr) {
 	if typeof(fromval) != "number" {
 		return nil, ArErr{"Type Error", "for loop from value must be a number", loop.line, loop.path, loop.code, true}
 	}
-	from := fromval.(number)
+	from := fromval.(ArObject)
 	toval, err := runVal(loop.to, stack, stacklevel+1)
 	if err.EXISTS {
 		return nil, err
@@ -91,7 +91,7 @@ func runForLoop(loop forLoop, stack stack, stacklevel int) (any, ArErr) {
 	if typeof(toval) != "number" {
 		return nil, ArErr{"Type Error", "for loop to value must be a number", loop.line, loop.path, loop.code, true}
 	}
-	to := toval.(number)
+	to := toval.(ArObject)
 	stepval, err := runVal(loop.step, stack, stacklevel+1)
 	if err.EXISTS {
 		return nil, err
@@ -99,11 +99,16 @@ func runForLoop(loop forLoop, stack stack, stacklevel int) (any, ArErr) {
 	if typeof(stepval) != "number" {
 		return nil, ArErr{"Type Error", "for loop step value must be a number", loop.line, loop.path, loop.code, true}
 	}
-	step := stepval.(number)
-	for i := newNumber().Set(from); i.Cmp(to) == -1; i = i.Add(i, step) {
-		resp, err := runVal(loop.body, append(stack, Map(anymap{
-			loop.variable: newNumber().Set(i),
-		})), stacklevel+1)
+	step := stepval.(ArObject)
+	if isNumberInt64(from) && isNumberInt64(to) && isNumberInt64(step) {
+		i, _ := numberToInt64(from)
+		to_, _ := numberToInt64(to)
+		step_, _ := numberToInt64(step)
+		layer := anymap{}
+		stacks := append(stack, Map(layer))
+		for i < to_ {
+			layer[loop.variable] = Number(i)
+			resp, err := runVal(loop.body, stacks, stacklevel+1)
 			if err.EXISTS {
 				return nil, err
 			}
@@ -113,7 +118,58 @@ func runForLoop(loop forLoop, stack stack, stacklevel int) (any, ArErr) {
 			case Break:
 				return nil, ArErr{}
 			case Continue:
-			continue
+			}
+			i += step_
+		}
+		return nil, ArErr{}
+	}
+	i := from
+	direction_obj, err := CompareObjects(step, _zero_Number)
+	if err.EXISTS {
+		return nil, err
+	}
+	currentDirection_obj, err := CompareObjects(to, i)
+	if err.EXISTS {
+		return nil, err
+	}
+	currentDirection, error := numberToInt64(currentDirection_obj)
+	if error != nil {
+		return nil, ArErr{"Type Error", error.Error(), loop.line, loop.path, loop.code, true}
+	}
+	direction, error := numberToInt64(direction_obj)
+	if error != nil {
+		return nil, ArErr{"Type Error", error.Error(), loop.line, loop.path, loop.code, true}
+	}
+	layer := anymap{}
+	stacks := append(stack, Map(layer))
+	for currentDirection == direction {
+		layer[loop.variable] = i
+		resp, err := runVal(loop.body, stacks, stacklevel+1)
+		if err.EXISTS {
+			return nil, err
+		}
+		switch x := resp.(type) {
+		case Return:
+			return x, ArErr{}
+		case Break:
+			return nil, ArErr{}
+		case Continue:
+		}
+		i, err = AddObjects(i, step)
+		if err.EXISTS {
+			return nil, err
+		}
+		currentDirection_obj, err = CompareObjects(to, i)
+		if err.EXISTS {
+			return nil, err
+		}
+		currentDirection, error = numberToInt64(currentDirection_obj)
+		if error != nil {
+			return nil, ArErr{"Type Error", error.Error(), loop.line, loop.path, loop.code, true}
+		}
+		direction, error = numberToInt64(direction_obj)
+		if error != nil {
+			return nil, ArErr{"Type Error", error.Error(), loop.line, loop.path, loop.code, true}
 		}
 	}
 	return nil, ArErr{}

src/getIndex.go

@@ -123,19 +123,10 @@ func indexGetParse(code UNPARSEcode, index int, codelines []UNPARSEcode) (ArMapG
 	}, 1
 }
 
-var hashabletypes = []string{
-	"number",
-	"string",
-	"bool",
-	"null",
-}
-
 func isUnhashable(val any) bool {
-	keytype := typeof(val)
-	for _, v := range hashabletypes {
-		if v == keytype {
+	switch val.(type) {
+	case int64, float64, string, bool, nil:
 		return false
 	}
-	}
 	return true
 }

src/input.go

@@ -1,23 +1,36 @@
 package main
 
 import (
-	"bufio"
 	"fmt"
+	"log"
 	"os"
 
+	"github.com/chzyer/readline"
 	"golang.org/x/term"
 )
 
-func input(args ...any) string {
+var tempFilePath = os.TempDir() + "/argon_input_history.tmp"
+
+func input(args ...any) (string, error) {
 	output := []any{}
 	for i := 0; i < len(args); i++ {
 		output = append(output, anyToArgon(args[i], false, true, 3, 0, true, 0))
 	}
-	fmt.Print(output...)
-	scanner := bufio.NewScanner(os.Stdin)
-	scanner.Scan()
-	input := scanner.Text()
-	return input
+	message := fmt.Sprint(output...)
+	rl, err := readline.NewEx(&readline.Config{
+		Prompt:            message,
+		HistoryFile:       tempFilePath,
+		HistorySearchFold: true,
+	})
+	if err != nil {
+		log.Fatalf("Failed to create readline instance: %v", err)
+	}
+	defer rl.Close()
+	line, err := rl.Readline()
+	if err != nil { // io.EOF or other error
+		return "", err
+	}
+	return line, nil
 }
 
 func getPassword(args ...any) (string, error) {
@@ -25,38 +38,21 @@ func getPassword(args ...any) (string, error) {
 	for i := 0; i < len(args); i++ {
 		output = append(output, anyToArgon(args[i], false, true, 3, 0, true, 0))
 	}
-	fmt.Print(output...)
-	password := []byte{}
-
-	oldState, err := term.MakeRaw(int(os.Stdin.Fd()))
+	message := fmt.Sprint(output...)
+	rl, err := readline.NewEx(&readline.Config{
+		Prompt:     message,
+		MaskRune:   '*',
+		EnableMask: true,
+	})
 	if err != nil {
-		panic(err)
+		log.Fatalf("Failed to create readline instance: %v", err)
 	}
-	defer term.Restore(int(os.Stdin.Fd()), oldState)
-
-	for {
-		char := make([]byte, 1)
-		_, err := os.Stdin.Read(char)
-		if err != nil {
+	defer rl.Close()
+	line, err := rl.Readline()
+	if err != nil { // io.EOF or other error
 		return "", err
 	}
-		if char[0] == 3 || char[0] == 4 {
-			return "", fmt.Errorf("keyboard interupt")
-		} else if char[0] == '\r' || char[0] == '\n' {
-			fmt.Println()
-			break
-		} else if char[0] == '\b' || char[0] == 127 {
-			if len(password) > 0 {
-				password = password[:len(password)-1]
-				fmt.Print("\b \b")
-			}
-		} else {
-			password = append(password, char[0])
-			fmt.Print("*")
-		}
-	}
-	fmt.Print("\r")
-	return string(password), nil
+	return line, nil
 }
 
 func pause() {

src/json.go

@@ -3,9 +3,7 @@ package main
 import (
 	"encoding/json"
 	"errors"
-	"math"
 	"strconv"
-	"strings"
 )
 
 func convertToArgon(obj any) any {
@@ -24,7 +22,7 @@ func convertToArgon(obj any) any {
 	case string:
 		return ArString(x)
 	case float64:
-		return newNumber().SetFloat64(x)
+		return Number(x)
 	case bool:
 		return x
 	case nil:
@@ -36,43 +34,37 @@ func convertToArgon(obj any) any {
 func jsonparse(str string) (any, ArErr) {
 	var jsonMap any
 	var err = json.Unmarshal([]byte(str), &jsonMap)
-	if err != nil {return nil, ArErr{TYPE: "Runtime Error", message: err.Error(), EXISTS: true}}
+	if err != nil {
+		return nil, ArErr{TYPE: "Runtime Error", message: err.Error(), EXISTS: true}
+	}
 	return convertToArgon(jsonMap), ArErr{}
 }
 
-func jsonstringify(obj any, level int) (string, error) {
+func jsonstringify(obj any, level int64) (string, error) {
 	if level > 100 {
 		return "", errors.New("json stringify error: too many levels")
 	}
-	output := []string{}
-	obj = ArValidToAny(obj)
 	switch x := obj.(type) {
-	case anymap:
-		for key, value := range x {
-			str, err := jsonstringify(value, level+1)
-			if err != nil {
-				return "", err
+	case ArObject:
+		if callable, ok := x.obj["__json__"]; ok {
+			val, err := runCall(
+				call{
+					Callable: callable,
+					Args:     []any{Int64ToNumber(level)},
+				},
+				stack{},
+				0,
+			)
+			if err.EXISTS {
+				return "", errors.New(err.message)
 			}
-			output = append(output, ""+strconv.Quote(anyToArgon(key, false, true, 3, 0, false, 0))+": "+str)
+			val = ArValidToAny(val)
+			if x, ok := val.(string); ok {
+				return x, nil
+			} else {
+				return "", errors.New("json stringify error: __json__ must return a string")
 			}
-		return "{" + strings.Join(output, ", ") + "}", nil
-	case []any:
-		for _, value := range x {
-			str, err := jsonstringify(value, level+1)
-			if err != nil {
-				return "", err
 		}
-			output = append(output, str)
-		}
-		return "[" + strings.Join(output, ", ") + "]", nil
-	case string:
-		return strconv.Quote(x), nil
-	case number:
-		num, _ := x.Float64()
-		if math.IsNaN(num) || math.IsInf(num, 0) {
-			return "null", nil
-		}
-		return numberToString(x, false), nil
 	case bool:
 		return strconv.FormatBool(x), nil
 	case nil:
@@ -94,10 +86,21 @@ var ArJSON = Map(anymap{
 		return jsonparse(args[0].(string))
 	}},
 	"stringify": builtinFunc{"stringify", func(args ...any) (any, ArErr) {
-		if len(args) == 0 {
-			return nil, ArErr{TYPE: "Runtime Error", message: "stringify takes 1 argument", EXISTS: true}
+		if len(args) != 1 && len(args) != 2 {
+			return nil, ArErr{TYPE: "Runtime Error", message: "stringify takes 1 or 2 arguments", EXISTS: true}
 		}
-		str, err := jsonstringify(args[0], 0)
+		var level int64 = 0
+		if len(args) == 2 {
+			if typeof(args[1]) != "number" {
+				return nil, ArErr{TYPE: "Runtime Error", message: "stringify takes a number not a '" + typeof(args[1]) + "'", EXISTS: true}
+			}
+			var err error
+			level, err = numberToInt64(args[1].(ArObject))
+			if err != nil {
+				return nil, ArErr{TYPE: "Runtime Error", message: err.Error(), EXISTS: true}
+			}
+		}
+		str, err := jsonstringify(args[0], level)
 		if err != nil {
 			return nil, ArErr{TYPE: "Runtime Error", message: err.Error(), EXISTS: true}
 		}

src/logarithms.go

@@ -5,19 +5,26 @@ import (
 	"math"
 )
 
-var N = newNumber().SetInt64(1e6)
+var N = Number(1e6)
 
-func Ln(x number) number {
-	output := newNumber()
-	output.SetInt64(1)
-	output.Quo(output, N)
+func Ln(x ArObject) (any, ArErr) {
+	var output any = Number(1)
+	var err ArErr
+	output, err = runOperation(
+		operationType{
+			operation: 15,
+			values:    []any{x},
+		},
+		stack{},
+		0,
+	)
+	if err.EXISTS {
+		return nil, err
+	}
 
-	n1, _ := x.Float64()
+	n1, _ := x_rational.Float64()
 	n2, _ := output.Float64()
 	output = newNumber().SetFloat64(math.Pow(n1, n2))
-	if output == nil {
-		output = infinity
-	}
 	output.Sub(output, newNumber().SetInt64(1))
 	output.Mul(output, N)
 	return output
@@ -37,10 +44,11 @@ func ArgonLn(a ...any) (any, ArErr) {
 		return nil, ArErr{TYPE: "Runtime Error", message: "ln takes a positive number",
 			EXISTS: true}
 	}
-	return Ln(x), ArErr{}
+	return Ln(x)
+	
 }
 
-var __ln10 = Ln(newNumber().SetInt64(10))
+var __ln10, _ = Ln(Number(10))
 
 func ArgonLog(a ...any) (any, ArErr) {
 	if len(a) != 1 {
@@ -56,7 +64,7 @@ func ArgonLog(a ...any) (any, ArErr) {
 		return nil, ArErr{TYPE: "Runtime Error", message: "log takes a positive number",
 			EXISTS: true}
 	}
-	return Ln(x).Quo(Ln(x), __ln10), ArErr{}
+	return Ln(x).Quo(Ln(x), __ln10)
 }
 
 func ArgonLogN(a ...any) (any, ArErr) {

src/main.go

@@ -10,8 +10,8 @@ var Args = os.Args[1:]
 
 type stack = []ArObject
 
-const VERSION = "3.0.8"
-const VERSION_NUM = 6
+const VERSION = "3.1.0 oop numbers beta 1"
+const VERSION_NUM = 7
 
 func newscope() ArObject {
 	return Map(anymap{})
@@ -23,7 +23,7 @@ func main() {
 	if !debug {
 		defer func() {
 			if r := recover(); r != nil {
-				fmt.Println("There was a fundamental error in argon v3 that caused it to crash.")
+				fmt.Println("There was a fundamental error in argon v" + VERSION + " that caused it to crash.")
 				fmt.Println()
 				fmt.Println("website:", website)
 				fmt.Println("docs:", docs)
@@ -45,7 +45,6 @@ func main() {
 			}
 		}()
 	}
-	initRandom()
 	garbageCollect()
 	global := makeGlobal()
 	if len(Args) == 0 {

src/map.go

@@ -245,6 +245,7 @@ func Map(m anymap) ArObject {
 							EXISTS:  true,
 						}
 					}
+					args[0] = ArValidToAny(args[0])
 					if isUnhashable(args[0]) {
 						return nil, ArErr{
 							TYPE:    "Runtime Error",

src/maths constants.go

@@ -1,5 +1,13 @@
 package main
 
-var PI, _ = newNumber().SetString("3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989")
-var e, _ = newNumber().SetString("2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785251664274274663919320030599218174135966290435729003342952605956307381323286279434907632338298807531952510190115738341879307021540891499348841675092447614606680822648001684774118537423454424371075390777449920695517027618386062613313845830007520449338265602976067371132007093287091274437470472306969772093101416928368190255151086574637721112523897844250569536967707854499699679468644549059879316368892300987931277361782154249992295763514822082698951936680331825288693984964651058209392398294887933203625094431173012381970684161403970198376793206832823764648042953118023287825098194558153017567173613320698112509961818815930416903515988885193458072738667385894228792284998920868058257492796104841984443634632449684875602336248270419786232090021609902353043699418491463140934317381436405462531520961836908887070167683964243781405927145635490613031072085103837505101157477041718986106873969655212671546889570350354")
-var infinity, _ = newNumber().SetString("1e1000")
+import "math/big"
+
+var PI_RAT, _ = new(big.Rat).SetString("3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989")
+var PI ArObject
+var e_RAT, _ = new(big.Rat).SetString("2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785251664274274663919320030599218174135966290435729003342952605956307381323286279434907632338298807531952510190115738341879307021540891499348841675092447614606680822648001684774118537423454424371075390777449920695517027618386062613313845830007520449338265602976067371132007093287091274437470472306969772093101416928368190255151086574637721112523897844250569536967707854499699679468644549059879316368892300987931277361782154249992295763514822082698951936680331825288693984964651058209392398294887933203625094431173012381970684161403970198376793206832823764648042953118023287825098194558153017567173613320698112509961818815930416903515988885193458072738667385894228792284998920868058257492796104841984443634632449684875602336248270419786232090021609902353043699418491463140934317381436405462531520961836908887070167683964243781405927145635490613031072085103837505101157477041718986106873969655212671546889570350354")
+var e ArObject
+
+func init() {
+	PI = Number(PI_RAT)
+	e = Number(e_RAT)
+}

src/operations.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"fmt"
-	"math"
 	"reflect"
 	"strings"
 )
@@ -27,8 +26,6 @@ var operations = []string{
 	"^",
 }
 
-var one = newNumber().SetInt64(1)
-
 type operationType struct {
 	operation int
 	values    []any
@@ -74,7 +71,7 @@ func parseOperations(code UNPARSEcode, index int, codelines []UNPARSEcode) (oper
 					path:     code.path,
 				}, index, codelines, 0)
 			if !success || err.EXISTS {
-				return operationType{}, success, err, 0
+				continue
 			}
 			values = append(values, resp)
 			totalStep += respindex - 1
@@ -120,9 +117,7 @@ func compareValues(o operationType, stack stack, stacklevel int) (bool, ArErr) {
 	}
 	switch o.operation {
 	case 4:
-		if isAnyNumber(resp) && isAnyNumber(resp2) {
-			return resp.(number).Cmp(resp2.(number)) <= 0, ArErr{}
-		} else if x, ok := resp.(ArObject); ok {
+		if x, ok := resp.(ArObject); ok {
 			if y, ok := x.obj["__LessThanEqual__"]; ok {
 				val, err := runCall(
 					call{
@@ -147,9 +142,7 @@ func compareValues(o operationType, stack stack, stacklevel int) (bool, ArErr) {
 			true,
 		}
 	case 5:
-		if isAnyNumber(resp) && isAnyNumber(resp2) {
-			return resp.(number).Cmp(resp2.(number)) >= 0, ArErr{}
-		} else if x, ok := resp.(ArObject); ok {
+		if x, ok := resp.(ArObject); ok {
 			if y, ok := x.obj["__GreaterThanEqual__"]; ok {
 				val, err := runCall(
 					call{
@@ -174,9 +167,7 @@ func compareValues(o operationType, stack stack, stacklevel int) (bool, ArErr) {
 			true,
 		}
 	case 6:
-		if isAnyNumber(resp) && isAnyNumber(resp2) {
-			return resp.(number).Cmp(resp2.(number)) < 0, ArErr{}
-		} else if x, ok := resp.(ArObject); ok {
+		if x, ok := resp.(ArObject); ok {
 			if y, ok := x.obj["__LessThan__"]; ok {
 				val, err := runCall(
 					call{
@@ -201,9 +192,7 @@ func compareValues(o operationType, stack stack, stacklevel int) (bool, ArErr) {
 			true,
 		}
 	case 7:
-		if isAnyNumber(resp) && isAnyNumber(resp2) {
-			return resp.(number).Cmp(resp2.(number)) > 0, ArErr{}
-		} else if x, ok := resp.(ArObject); ok {
+		if x, ok := resp.(ArObject); ok {
 			if y, ok := x.obj["__GreaterThan__"]; ok {
 				val, err := runCall(
 					call{
@@ -253,9 +242,6 @@ func calcNegative(o operationType, stack stack, stacklevel int) (any, ArErr) {
 		return nil, err
 	}
 	output := resp
-	if isAnyNumber(resp) {
-		output = newNumber().Set(resp.(number))
-	}
 	for i := 1; i < len(o.values); i++ {
 		resp, err := runVal(
 			o.values[i],
@@ -265,10 +251,7 @@ func calcNegative(o operationType, stack stack, stacklevel int) (any, ArErr) {
 		if err.EXISTS {
 			return nil, err
 		}
-		if typeof(output) == "number" && typeof(resp) == "number" {
-			output = output.(number).Sub(output.(number), resp.(number))
-			continue
-		} else if x, ok := output.(ArObject); ok {
+		if x, ok := output.(ArObject); ok {
 			if y, ok := x.obj["__Subtract__"]; ok {
 				val, err := runCall(
 					call{
@@ -309,33 +292,17 @@ func calcDivide(o operationType, stack stack, stacklevel int) (any, ArErr) {
 		return nil, err
 	}
 	output := resp
-	if isAnyNumber(resp) {
-		output = newNumber().Set(resp.(number))
-	}
 	for i := 1; i < len(o.values); i++ {
 		resp, err := runVal(
 			o.values[i],
 			stack,
 			stacklevel+1,
 		)
-		resp = ArValidToAny(resp)
+
 		if err.EXISTS {
 			return nil, err
 		}
-		if typeof(resp) == "number" && typeof(output) == "number" {
-			if resp.(number).Cmp(newNumber().SetInt64(0)) == 0 {
-				return nil, ArErr{
-					"Runtime Error",
-					"Cannot divide by zero",
-					o.line,
-					o.path,
-					o.code,
-					true,
-				}
-			}
-			output = output.(number).Quo(output.(number), resp.(number))
-			continue
-		} else if x, ok := output.(ArObject); ok {
+		if x, ok := output.(ArObject); ok {
 			if y, ok := x.obj["__Divide__"]; ok {
 				val, err := runCall(
 					call{
@@ -375,9 +342,6 @@ func calcAdd(o operationType, stack stack, stacklevel int) (any, ArErr) {
 		return nil, err
 	}
 	var output any = resp
-	if typeof(output) == "number" {
-		output = newNumber().Set(output.(number))
-	}
 	for i := 1; i < len(o.values); i++ {
 		resp, err := runVal(
 			o.values[i],
@@ -387,10 +351,7 @@ func calcAdd(o operationType, stack stack, stacklevel int) (any, ArErr) {
 		if err.EXISTS {
 			return nil, err
 		}
-		if typeof(output) == "number" && typeof(resp) == "number" {
-			output = output.(number).Add(output.(number), resp.(number))
-			continue
-		} else if x, ok := output.(ArObject); ok {
+		if x, ok := output.(ArObject); ok {
 			if y, ok := x.obj["__Add__"]; ok {
 				val, err := runCall(
 					call{
@@ -400,13 +361,28 @@ func calcAdd(o operationType, stack stack, stacklevel int) (any, ArErr) {
 						o.line,
 						o.path,
 					}, stack, stacklevel+1)
-				if err.EXISTS {
-					return nil, err
-				}
+				if !err.EXISTS {
 					output = val
 					continue
 				}
 			}
+		}
+		if x, ok := resp.(ArObject); ok {
+			if y, ok := x.obj["__PostAdd__"]; ok {
+				val, err := runCall(
+					call{
+						y,
+						[]any{output},
+						o.code,
+						o.line,
+						o.path,
+					}, stack, stacklevel+1)
+				if !err.EXISTS {
+					output = val
+					continue
+				}
+			}
+		}
 		return nil, ArErr{
 			"Runtime Error",
 			"Cannot add type '" + typeof(resp) + "' to type '" + typeof(output) + "'",
@@ -416,7 +392,7 @@ func calcAdd(o operationType, stack stack, stacklevel int) (any, ArErr) {
 			true,
 		}
 	}
-	return (output), ArErr{}
+	return output, ArErr{}
 }
 
 func calcMul(o operationType, stack stack, stacklevel int) (any, ArErr) {
@@ -430,9 +406,6 @@ func calcMul(o operationType, stack stack, stacklevel int) (any, ArErr) {
 		return nil, err
 	}
 	var output any = resp
-	if isAnyNumber(resp) {
-		output = newNumber().Set(resp.(number))
-	}
 	for i := 1; i < len(o.values); i++ {
 		resp, err := runVal(
 			o.values[i],
@@ -442,10 +415,7 @@ func calcMul(o operationType, stack stack, stacklevel int) (any, ArErr) {
 		if err.EXISTS {
 			return nil, err
 		}
-		if typeof(output) == "number" && typeof(resp) == "number" {
-			output = output.(number).Mul(output.(number), resp.(number))
-			continue
-		} else if x, ok := output.(ArObject); ok {
+		if x, ok := output.(ArObject); ok {
 			if y, ok := x.obj["__Multiply__"]; ok {
 				val, err := runCall(
 					call{
@@ -455,13 +425,28 @@ func calcMul(o operationType, stack stack, stacklevel int) (any, ArErr) {
 						o.line,
 						o.path,
 					}, stack, stacklevel+1)
-				if err.EXISTS {
-					return nil, err
-				}
+				if !err.EXISTS {
 					output = val
 					continue
 				}
 			}
+		}
+		if x, ok := resp.(ArObject); ok {
+			if y, ok := x.obj["__PostMultiply__"]; ok {
+				val, err := runCall(
+					call{
+						y,
+						[]any{output},
+						o.code,
+						o.line,
+						o.path,
+					}, stack, stacklevel+1)
+				if !err.EXISTS {
+					output = val
+					continue
+				}
+			}
+		}
 		return nil, ArErr{
 			"Runtime Error",
 			"Cannot multiply type '" + typeof(resp) + "'",
@@ -483,7 +468,7 @@ func calcAnd(o operationType, stack stack, stacklevel int) (any, ArErr) {
 			stack,
 			stacklevel+1,
 		)
-		resp = ArValidToAny(resp)
+
 		if err.EXISTS {
 			return nil, err
 		}
@@ -503,7 +488,7 @@ func calcOr(o operationType, stack stack, stacklevel int) (any, ArErr) {
 			stack,
 			stacklevel+1,
 		)
-		resp = ArValidToAny(resp)
+
 		if err.EXISTS {
 			return nil, err
 		}
@@ -539,7 +524,7 @@ func calcNotIn(o operationType, stack stack, stacklevel int) (any, ArErr) {
 		stack,
 		stacklevel+1,
 	)
-	resp = ArValidToAny(resp)
+
 	if err.EXISTS {
 		return false, err
 	}
@@ -624,9 +609,7 @@ func calcIn(o operationType, stack stack, stacklevel int) (any, ArErr) {
 	}
 }
 func notequals(a any, b any, o operationType, stack stack, stacklevel int) (bool, ArErr) {
-	if typeof(a) == "number" && typeof(b) == "number" {
-		return a.(number).Cmp(b.(number)) != 0, ArErr{}
-	} else if x, ok := a.(ArObject); ok {
+	if x, ok := a.(ArObject); ok {
 		if y, ok := x.obj["__NotEqual__"]; ok {
 			val, err := runCall(
 				call{
@@ -662,9 +645,7 @@ func notequals(a any, b any, o operationType, stack stack, stacklevel int) (bool
 
 func equals(a any, b any, o operationType, stack stack, stacklevel int) (bool, ArErr) {
 	debugPrintln("equals", a, b)
-	if typeof(a) == "number" && typeof(b) == "number" {
-		return a.(number).Cmp(b.(number)) == 0, ArErr{}
-	} else if x, ok := a.(ArObject); ok {
+	if x, ok := a.(ArObject); ok {
 		if y, ok := x.obj["__Equal__"]; ok {
 			val, err := runCall(
 				call{
@@ -708,27 +689,16 @@ func calcMod(o operationType, stack stack, stacklevel int) (any, ArErr) {
 		return nil, err
 	}
 	output := resp
-	if isAnyNumber(resp) {
-		output = newNumber().Set(resp.(number))
-	}
 	for i := 1; i < len(o.values); i++ {
 		resp, err := runVal(
 			o.values[i],
 			stack,
 			stacklevel+1,
 		)
-		resp = ArValidToAny(resp)
 		if err.EXISTS {
 			return nil, err
 		}
-		if typeof(resp) == "number" && typeof(output) == "number" {
-			x := newNumber().Set(resp.(number))
-			x.Quo(output.(number), x)
-			x = floor(x)
-			x.Mul(x, resp.(number))
-			output.(number).Sub(output.(number), x)
-			continue
-		} else if x, ok := output.(ArObject); ok {
+		if x, ok := output.(ArObject); ok {
 			if y, ok := x.obj["__Modulo__"]; ok {
 				val, err := runCall(
 					call{
@@ -767,23 +737,17 @@ func calcIntDiv(o operationType, stack stack, stacklevel int) (any, ArErr) {
 		return nil, err
 	}
 	output := resp
-	if isAnyNumber(resp) {
-		output = newNumber().Set(resp.(number))
-	}
 	for i := 1; i < len(o.values); i++ {
 		resp, err := runVal(
 			o.values[i],
 			stack,
 			stacklevel+1,
 		)
-		resp = ArValidToAny(resp)
+
 		if err.EXISTS {
 			return nil, err
 		}
-		if typeof(resp) == "number" && typeof(output) == "number" {
-			output = floor(output.(number).Quo(output.(number), resp.(number)))
-			continue
-		} else if x, ok := output.(ArObject); ok {
+		if x, ok := output.(ArObject); ok {
 			if y, ok := x.obj["__IntDivide__"]; ok {
 				val, err := runCall(
 					call{
@@ -802,7 +766,7 @@ func calcIntDiv(o operationType, stack stack, stacklevel int) (any, ArErr) {
 		}
 		return nil, ArErr{
 			"Runtime Error",
-			"Cannot divide type '" + typeof(resp) + "'",
+			"Cannot int divide type '" + typeof(resp) + "'",
 			o.line,
 			o.path,
 			o.code,
@@ -812,93 +776,142 @@ func calcIntDiv(o operationType, stack stack, stacklevel int) (any, ArErr) {
 	return output, ArErr{}
 }
 
-func calcPower(o operationType, stack stack, stacklevel int) (number, ArErr) {
+// func calcPower(o operationType, stack stack, stacklevel int) (number, ArErr) {
+// 	resp, err := runVal(
+// 		o.values[0],
+// 		stack,
+// 		stacklevel+1,
+// 	)
+//
+// 	if err.EXISTS {
+// 		return nil, err
+// 	}
+// 	if typeof(resp) != "number" {
+// 		return nil, ArErr{
+// 			"Runtime Error",
+// 			"Cannot calculate power of type '" + typeof(resp) + "'",
+// 			o.line,
+// 			o.path,
+// 			o.code,
+// 			true,
+// 		}
+// 	}
+// 	output := newNumber().Set(resp.(number))
+// 	for i := 1; i < len(o.values); i++ {
+// 		resp, err := runVal(
+// 			o.values[i],
+// 			stack,
+// 			stacklevel+1,
+// 		)
+//
+// 		if err.EXISTS {
+// 			return nil, err
+// 		}
+// 		if typeof(resp) == "number" {
+// 			n := newNumber().Set(resp.(number))
+// 			if n.Cmp(newNumber().SetInt64(10)) <= 0 {
+// 				toOut := newNumber().SetInt64(1)
+// 				clone := newNumber().Set(output)
+// 				nAbs := (abs(newNumber().Set(n)))
+// 				j := newNumber()
+// 				for ; j.Cmp(nAbs) < 0; j.Add(j, one) {
+// 					toOut.Mul(toOut, clone)
+// 				}
+
+// 				nAbs.Sub(nAbs, j)
+// 				if nAbs.Cmp(newNumber()) < 0 {
+// 					j.Sub(j, one)
+// 					n1, _ := toOut.Float64()
+// 					n2, _ := nAbs.Float64()
+// 					calculated := newNumber().SetFloat64(math.Pow(n1, n2))
+// 					if calculated == nil {
+// 						calculated = infinity
+// 					}
+// 					toOut.Mul(toOut, calculated)
+// 				}
+// 				if n.Cmp(newNumber()) < 0 {
+// 					toOut.Quo(newNumber().SetInt64(1), toOut)
+// 				}
+// 				output.Set(toOut)
+// 			} else if n.Cmp(newNumber().SetInt64(1)) != 0 {
+// 				n1, _ := output.Float64()
+// 				n2, _ := n.Float64()
+// 				calculated := newNumber().SetFloat64(math.Pow(n1, n2))
+// 				if calculated == nil {
+// 					calculated = infinity
+// 				}
+// 				output.Mul(output, calculated)
+// 			}
+
+// 			/*
+// 				n1, _ := output.Float64()
+// 				n2, _ := resp.(number).Float64()
+// 				output = newNumber().SetFloat64(math.Pow(n1, n2))
+// 				if output == nil {
+// 					output = infinity
+// 				}
+// 			*/
+// 		} else {
+// 			return nil, ArErr{
+// 				"Runtime Error",
+// 				"Cannot calculate power of type '" + typeof(resp) + "'",
+// 				o.line,
+// 				o.path,
+// 				o.code,
+// 				true,
+// 			}
+// 		}
+// 	}
+// 	return output, ArErr{}
+// }
+
+func calcPower(o operationType, stack stack, stacklevel int) (any, ArErr) {
+
 	resp, err := runVal(
 		o.values[0],
 		stack,
 		stacklevel+1,
 	)
-	resp = ArValidToAny(resp)
 	if err.EXISTS {
 		return nil, err
 	}
-	if typeof(resp) != "number" {
-		return nil, ArErr{
-			"Runtime Error",
-			"Cannot calculate power of type '" + typeof(resp) + "'",
-			o.line,
-			o.path,
-			o.code,
-			true,
-		}
-	}
-	output := newNumber().Set(resp.(number))
+	var output any = resp
 	for i := 1; i < len(o.values); i++ {
 		resp, err := runVal(
 			o.values[i],
 			stack,
 			stacklevel+1,
 		)
-		resp = ArValidToAny(resp)
 		if err.EXISTS {
 			return nil, err
 		}
-		if typeof(resp) == "number" {
-			n := newNumber().Set(resp.(number))
-			if n.Cmp(newNumber().SetInt64(10)) <= 0 {
-				toOut := newNumber().SetInt64(1)
-				clone := newNumber().Set(output)
-				nAbs := (abs(newNumber().Set(n)))
-				j := newNumber()
-				for ; j.Cmp(nAbs) < 0; j.Add(j, one) {
-					toOut.Mul(toOut, clone)
+		if x, ok := output.(ArObject); ok {
+			if y, ok := x.obj["__Power__"]; ok {
+				val, err := runCall(
+					call{
+						y,
+						[]any{resp},
+						o.code,
+						o.line,
+						o.path,
+					}, stack, stacklevel+1)
+				if err.EXISTS {
+					return nil, err
 				}
-
-				nAbs.Sub(nAbs, j)
-				if nAbs.Cmp(newNumber()) < 0 {
-					j.Sub(j, one)
-					n1, _ := toOut.Float64()
-					n2, _ := nAbs.Float64()
-					calculated := newNumber().SetFloat64(math.Pow(n1, n2))
-					if calculated == nil {
-						calculated = infinity
+				output = val
+				continue
 			}
-					toOut.Mul(toOut, calculated)
 		}
-				if n.Cmp(newNumber()) < 0 {
-					toOut.Quo(newNumber().SetInt64(1), toOut)
-				}
-				output.Set(toOut)
-			} else if n.Cmp(newNumber().SetInt64(1)) != 0 {
-				n1, _ := output.Float64()
-				n2, _ := n.Float64()
-				calculated := newNumber().SetFloat64(math.Pow(n1, n2))
-				if calculated == nil {
-					calculated = infinity
-				}
-				output.Mul(output, calculated)
-			}
-
-			/*
-				n1, _ := output.Float64()
-				n2, _ := resp.(number).Float64()
-				output = newNumber().SetFloat64(math.Pow(n1, n2))
-				if output == nil {
-					output = infinity
-				}
-			*/
-		} else {
 		return nil, ArErr{
 			"Runtime Error",
-				"Cannot calculate power of type '" + typeof(resp) + "'",
+			"Cannot power type '" + typeof(resp) + "' to type '" + typeof(output) + "'",
 			o.line,
 			o.path,
 			o.code,
 			true,
 		}
 	}
-	}
-	return output, ArErr{}
+	return (output), ArErr{}
 }
 
 func runOperation(o operationType, stack stack, stacklevel int) (any, ArErr) {

src/random.go

@@ -6,10 +6,10 @@ import (
 	"time"
 )
 
-func random() number {
-	return newNumber().SetFloat64(
-		rand.Float64(),
-	)
+var rand_source = rand.New(rand.NewSource(time.Now().UnixMicro()))
+
+func random() ArObject {
+	return Number(rand_source.Float64())
 }
 
 func randomRange(args ...any) (any, ArErr) {
@@ -33,23 +33,88 @@ func randomRange(args ...any) (any, ArErr) {
 			EXISTS:  true,
 		}
 	}
-	min := args[0].(number)
-	max := args[1].(number)
-	if min.Cmp(max) > 0 {
+	min := args[0].(ArObject)
+	max := args[1].(ArObject)
+
+	compare_num, err := CompareObjects(min, max)
+	if err.EXISTS {
+		return nil, err
+	}
+
+	compare, Err := numberToInt64(compare_num)
+	if Err != nil {
 		return nil, ArErr{
 			TYPE:    "Runtime Error",
-			message: "takes a min less than max",
+			message: Err.Error(),
 			EXISTS:  true,
 		}
 	}
-	difference := newNumber().Sub(max, min)
+
+	if compare == 1 {
+		return nil, ArErr{
+			TYPE:    "Runtime Error",
+			message: "range() num 1 must be less than or equal to num 2",
+			EXISTS:  true,
+		}
+	}
+
+	num_range, err := runOperation(
+		operationType{
+			operation: 11,
+			values:    []any{max, min},
+		},
+		stack{},
+		0,
+	)
+
+	if err.EXISTS {
+		return nil, err
+	}
+
+	if _, ok := num_range.(ArObject); !ok {
+		return nil, ArErr{
+			TYPE:    "Runtime Error",
+			message: "could not subtract the two numbers to calculate the range",
+			EXISTS:  true,
+		}
+	}
+
+	num_range_obj := num_range.(ArObject)
+
 	rand := random()
-	rand.Mul(rand, difference)
-	rand.Add(rand, min)
-	return rand, ArErr{}
+
+	multiplier, err := runOperation(
+		operationType{
+			operation: 12,
+			values:    []any{rand, num_range_obj},
+		},
+		stack{},
+		0,
+	)
+
+	if err.EXISTS {
+		return nil, err
+	}
+
+	if _, ok := multiplier.(ArObject); !ok {
+		return nil, ArErr{
+			TYPE:    "Runtime Error",
+			message: "could not multiply the random number by the range",
+			EXISTS:  true,
+		}
+	}
+
+	return runOperation(
+		operationType{
+			operation: 10,
+			values:    []any{multiplier, min},
+		},
+		stack{},
+		0,
+	)
 }
 
-var ArRandom = Map(anymap{
+var ArRandom = ArObject{anymap{
 	"__call__": builtinFunc{"random", func(args ...any) (any, ArErr) {
 		if len(args) != 0 {
 			return nil, ArErr{
@@ -83,22 +148,15 @@ var ArRandom = Map(anymap{
 				EXISTS:  true,
 			}
 		}
-		if !a[0].(number).IsInt() {
+		new_seed, err := numberToInt64(a[0].(ArObject))
+		if err != nil {
 			return nil, ArErr{
 				TYPE:    "Runtime Error",
-				message: "takes an integer not a float",
+				message: err.Error(),
 				EXISTS:  true,
 			}
 		}
-		rand.Seed(
-			a[0].(number).Num().Int64(),
-		)
+		rand_source.Seed(new_seed)
 		return nil, ArErr{}
 	}},
-})
-
-func initRandom() {
-	rand.Seed(
-		time.Now().UnixMicro(),
-	)
-}
+}}

src/run.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"fmt"
+	"math/big"
 	"reflect"
 )
 
@@ -56,30 +57,30 @@ func runVal(line any, stack stack, stacklevel int) (any, ArErr) {
 			break
 		}
 		return setVariableValue(x, stack, stacklevel+1)
-	case negative:
-		if stackoverflow {
-			linenum = x.line
-			path = x.path
-			code = x.code
-			break
-		}
-		resp, err := runVal(x.VAL, stack, stacklevel+1)
-		resp = AnyToArValid(resp)
-		if err.EXISTS {
-			return nil, err
-		}
-		switch y := resp.(type) {
-		case number:
-			if !x.sign {
-				return newNumber().Neg(y), ArErr{}
-			}
-			return y, ArErr{}
-		}
-		return nil, ArErr{
-			TYPE:    "Type Error",
-			message: "cannot negate a non-number",
-			EXISTS:  true,
-		}
+	// case negative:
+	// 	if stackoverflow {
+	// 		linenum = x.line
+	// 		path = x.path
+	// 		code = x.code
+	// 		break
+	// 	}
+	// 	resp, err := runVal(x.VAL, stack, stacklevel+1)
+	// 	resp = AnyToArValid(resp)
+	// 	if err.EXISTS {
+	// 		return nil, err
+	// 	}
+	// 	switch y := resp.(type) {
+	// 	case compiledNumber:
+	// 		if !x.sign {
+	// 			return Number(compiledNumber{new(big.Rat).Neg(y)}), ArErr{}
+	// 		}
+	// 		return y, ArErr{}
+	// 	}
+	// 	return nil, ArErr{
+	// 		TYPE:    "Type Error",
+	// 		message: "cannot negate a non-number",
+	// 		EXISTS:  true,
+	// 	}
 	case operationType:
 		if stackoverflow {
 			linenum = x.line
@@ -208,7 +209,11 @@ func runVal(line any, stack stack, stacklevel int) (any, ArErr) {
 			break
 		}
 		return runTryCatch(x, stack, stacklevel+1)
-	case bool, ArObject, number, nil, Callable, builtinFunc, anymap:
+	case compiledNumber:
+		return Number(x.value), ArErr{}
+	case int64, int, float64, float32, *big.Rat, *big.Int:
+		return Number(x), ArErr{}
+	case bool, ArObject, nil, Callable, builtinFunc, anymap:
 		return x, ArErr{}
 	}
 	if stackoverflow {
@@ -222,6 +227,7 @@ func runVal(line any, stack stack, stacklevel int) (any, ArErr) {
 		}
 	}
 	fmt.Println("unreachable", reflect.TypeOf(line))
+	fmt.Println(line)
 	panic("unreachable")
 }
 

src/shell.go

@@ -19,7 +19,7 @@ func shell(global ArObject) {
 			}
 		}
 	}()
-	fmt.Print("\x1b[32;5;240mWelcome to the Argon v3!\x1b[0m\n\n")
+	fmt.Print("\x1b[32;5;25mWelcome to the Argon v3!\x1b[25m\n\n")
 	for {
 		indent := 0
 		previous := 0
@@ -27,7 +27,12 @@ func shell(global ArObject) {
 		textBefore := ">>>"
 		for i := 1; indent > 0 || (previous != indent && indent >= 0) || i == 1; i++ {
 			indentStr := strings.Repeat("    ", indent)
-			code := indentStr + input("\x1b[38;5;240m"+textBefore+indentStr+" \x1b[0m\x1b[1;5;240m")
+			line, err := input("\x1b[38;5;240m" + textBefore + indentStr + " \x1b[0m\x1b[1;5;25m")
+			if err != nil {
+				fmt.Println("\x1b[0m\n\x1b[32;5;25mBye :)\x1b[0m")
+				os.Exit(0)
+			}
+			code := indentStr + line
 			fmt.Print("\x1b[0m")
 			totranslate = append(totranslate, UNPARSEcode{code, code, i, "<shell>"})
 			trimmed := strings.TrimSpace(code)

src/socket.go

@@ -226,15 +226,16 @@ func ArSocketServer(args ...any) (any, ArErr) {
 		}
 	}
 	networktype := ArValidToAny(args[0]).(string)
-	port := args[1].(number)
-	if port.Denom().Int64() != 1 {
+	port_num := args[1].(ArObject)
+	port, err := numberToInt64(port_num)
+	if err != nil {
 		return ArObject{}, ArErr{
 			TYPE:    "Socket Error",
-			message: "Socket port must be an integer",
+			message: err.Error(),
 			EXISTS:  true,
 		}
 	}
-	ln, err := net.Listen(networktype, ":"+fmt.Sprint(port.Num().Int64()))
+	ln, err := net.Listen(networktype, ":"+fmt.Sprint(port))
 	if err != nil {
 		return ArObject{}, ArErr{
 			TYPE:    "Socket Error",

src/sortany.go

@@ -58,9 +58,7 @@ func getkeyCache(getKey func(any) (any, ArErr), key any) (any, ArErr) {
 }
 
 func compare(a, b any) (bool, error) {
-	if isAnyNumber(a) && isAnyNumber(b) {
-		return a.(number).Cmp(b.(number)) < 0, nil
-	} else if x, ok := a.(ArObject); ok {
+	if x, ok := a.(ArObject); ok {
 		if y, ok := x.obj["__LessThan__"]; ok {
 			resp, err := runCall(
 				call{

src/string.go

@@ -5,6 +5,7 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/fatih/color"
 	"golang.org/x/text/cases"
 	"golang.org/x/text/language"
 )
@@ -68,6 +69,32 @@ func ArString(str string) ArObject {
 		},
 	}
 
+	obj.obj["__string__"] = builtinFunc{
+		"__string__",
+		func(a ...any) (any, ArErr) {
+			return str, ArErr{}
+		}}
+	obj.obj["__repr__"] = builtinFunc{
+		"__repr__",
+		func(a ...any) (any, ArErr) {
+			colored := false
+			if len(a) == 1 {
+				if typeof(a[0]) != "boolean" {
+					return nil, ArErr{"Type Error", "expected boolean, got " + typeof(a[0]), 0, "", "", true}
+				}
+				colored = a[0].(bool)
+			}
+			output := []string{}
+			quoted := strconv.Quote(str)
+			if colored {
+				output = append(output, color.New(33).Sprint(quoted))
+			} else {
+				output = append(output, quoted)
+			}
+			return ArString(strings.Join(output, "")), ArErr{}
+		},
+	}
+
 	obj.obj["__setindex__"] = builtinFunc{
 		"__setindex__",
 		func(a ...any) (any, ArErr) {
@@ -124,14 +151,12 @@ func ArString(str string) ArObject {
 			{
 				if a[0] == nil {
 					start = 0
-				} else if typeof(a[0]) != "number" || !a[0].(number).IsInt() {
-					return "", ArErr{
-						TYPE:    "Type Error",
-						message: "slice index must be an integer",
-						EXISTS:  true,
+				} else if x, ok := a[0].(ArObject); ok {
+					start64, err := numberToInt64(x)
+					if err != nil {
+						return nil, ArErr{"Type Error", err.Error(), 0, "", "", true}
 					}
-				} else {
-					start = int(a[0].(number).Num().Int64())
+					start = int(start64)
 				}
 			}
 			if len(a) > 1 {

src/term-class.go

@@ -140,7 +140,11 @@ var ArInput = Map(
 			return ArString(resp), ArErr{}
 		}},
 		"__call__": builtinFunc{"input", func(args ...any) (any, ArErr) {
-			return input(args...), ArErr{}
+			resp, err := input(args...)
+			if err != nil {
+				return nil, ArErr{TYPE: "Runtime Error", message: err.Error(), EXISTS: true}
+			}
+			return ArString(resp), ArErr{}
 		}},
 		"pause": builtinFunc{"pause", func(args ...any) (any, ArErr) {
 			pause()

src/to-argon.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"fmt"
-	"math"
 	"sort"
 	"strconv"
 	"strings"
@@ -11,7 +10,7 @@ import (
 	"github.com/jwalton/go-supportscolor"
 )
 
-func anyToArgon(x any, quote bool, simplify bool, depth int, indent int, colored bool, plain int) string {
+func anyToArgon(x any, representive bool, simplify bool, depth int, indent int, colored bool, plain int) string {
 	output := []string{}
 	maybenewline := ""
 	if plain == 1 {
@@ -29,37 +28,9 @@ func anyToArgon(x any, quote bool, simplify bool, depth int, indent int, colored
 		return strings.Join(output, "")
 	}
 	switch x := x.(type) {
-	case string:
-		if !quote {
-			output = append(output, x)
-			break
-		}
-		quoted := strconv.Quote(x)
-		if colored {
-			output = append(output, color.New(33).Sprint(quoted))
-		} else {
-			output = append(output, quoted)
-		}
-	case number:
-		if colored {
-			output = append(output, "\x1b[34;5;240m")
-		}
-		num, _ := x.Float64()
-		if math.IsNaN(num) {
-			output = append(output, "NaN")
-		} else if math.IsInf(num, 1) {
-			output = append(output, "infinity")
-		} else if math.IsInf(num, -1) {
-			output = append(output, "-infinity")
-		} else {
-			output = append(output, numberToString(x, simplify))
-		}
-		if colored {
-			output = append(output, "\x1b[0m")
-		}
 	case bool:
 		if colored {
-			output = append(output, "\x1b[35;5;240m")
+			output = append(output, "\x1b[35;5;25m")
 		}
 		output = append(output, strconv.FormatBool(x))
 		if colored {
@@ -67,14 +38,14 @@ func anyToArgon(x any, quote bool, simplify bool, depth int, indent int, colored
 		}
 	case nil:
 		if colored {
-			output = append(output, "\x1b[31;5;240m")
+			output = append(output, "\x1b[31;5;25m")
 		}
 		output = append(output, "null")
 		if colored {
 			output = append(output, "\x1b[0m")
 		}
 	case ArObject:
-		if callable, ok := x.obj["__string__"]; ok && !quote {
+		if callable, ok := x.obj["__string__"]; ok && !representive {
 			val, err := runCall(
 				call{
 					Callable: callable,
@@ -84,24 +55,24 @@ func anyToArgon(x any, quote bool, simplify bool, depth int, indent int, colored
 				0,
 			)
 			if !err.EXISTS {
-				output = append(output, anyToArgon(val, false, simplify, depth, indent, colored, plain))
+				output = append(output, fmt.Sprint(ArValidToAny(val)))
 				break
 			}
 		} else if callable, ok := x.obj["__repr__"]; ok {
 			val, err := runCall(
 				call{
 					Callable: callable,
-					Args:     []any{},
+					Args:     []any{colored},
 				},
 				stack{},
 				0,
 			)
 			if !err.EXISTS {
-				output = append(output, anyToArgon(val, false, simplify, depth, indent, colored, plain))
+				output = append(output, fmt.Sprint(ArValidToAny(val)))
 				break
 			}
 		} else if val, ok := x.obj["__value__"]; ok {
-			output = append(output, anyToArgon(val, quote, simplify, depth, indent, colored, plain))
+			output = append(output, anyToArgon(val, representive, simplify, depth, indent, colored, plain))
 			break
 		}
 		output = append(output, "<object>")
@@ -128,7 +99,7 @@ func anyToArgon(x any, quote bool, simplify bool, depth int, indent int, colored
 			} else {
 				outputkeyval := []string{}
 				if colored {
-					outputkeyval = append(outputkeyval, "\x1b[36;5;240m")
+					outputkeyval = append(outputkeyval, "\x1b[36;5;25m")
 				}
 				outputkeyval = append(outputkeyval, key.(string))
 				if colored {
@@ -148,7 +119,7 @@ func anyToArgon(x any, quote bool, simplify bool, depth int, indent int, colored
 				output = append(output, anyToArgon(item, true, true, depth-1, indent+1, colored, plain))
 			}
 			if colored {
-				output = append(output, "\x1b[38;5;240m(...)\x1b[0m")
+				output = append(output, "\x1b[38;5;25m(...)\x1b[0m")
 			} else {
 				output = append(output, "(...)")
 			}
@@ -173,7 +144,7 @@ func anyToArgon(x any, quote bool, simplify bool, depth int, indent int, colored
 		return "[" + maybenewline + (strings.Repeat("    ", (indent+1)*plain)) + strings.Join(output, ","+maybenewline+(strings.Repeat("    ", (indent+1)*plain))) + maybenewline + (strings.Repeat("    ", indent*plain)) + "]"
 	case builtinFunc:
 		if colored {
-			output = append(output, "\x1b[38;5;240m")
+			output = append(output, "\x1b[38;5;25m")
 		}
 		output = append(output, "<builtin function "+x.name+">")
 		if colored {
@@ -181,7 +152,7 @@ func anyToArgon(x any, quote bool, simplify bool, depth int, indent int, colored
 		}
 	case Callable:
 		if colored {
-			output = append(output, "\x1b[38;5;240m")
+			output = append(output, "\x1b[38;5;25m")
 		}
 		output = append(output, "<function "+x.name+">")
 		if colored {

src/translate.go

@@ -103,13 +103,6 @@ func translateVal(code UNPARSEcode, index int, codelines []UNPARSEcode, isLine i
 		}
 		QuickKnownFailures["squareroot"+code.code] = true
 	}
-	if !QuickKnownFailures["factorial"+code.code] && isFactorial(code) {
-		resp, worked, err, i = parseFactorial(code, index, codelines)
-		if worked {
-			return resp, worked, err, i
-		}
-		QuickKnownFailures["factorial"+code.code] = true
-	}
 	if isVariable(code) {
 		return parseVariable(code)
 	}
@@ -139,6 +132,13 @@ func translateVal(code UNPARSEcode, index int, codelines []UNPARSEcode, isLine i
 			return nil, worked, err, step
 		}
 	}
+	if !QuickKnownFailures["factorial"+code.code] && isFactorial(code) {
+		resp, worked, err, i = parseFactorial(code, index, codelines)
+		if worked {
+			return resp, worked, err, i
+		}
+		QuickKnownFailures["factorial"+code.code] = true
+	}
 	if !QuickKnownFailures["call"+code.code] && isCall(code) {
 		resp, worked, err, i = parseCall(code, index, codelines)
 		if worked {

src/trig.go

@@ -14,9 +14,9 @@ type sinCacheValue struct {
 
 var sinCache = []sinCacheValue{
 	{newNumber(), newNumber()},
-	{newNumber().Quo(PI, newNumber().SetInt64(2)), newNumber().SetInt64(1)},
-	{PI, newNumber()},
-	{newNumber().Add(PI, newNumber().Quo(PI, newNumber().SetInt64(2))), newNumber().SetInt64(-1)},
+	{newNumber().Quo(PI_RAT, newNumber().SetInt64(2)), newNumber().SetInt64(1)},
+	{PI_RAT, newNumber()},
+	{newNumber().Add(PI_RAT, newNumber().Quo(PI_RAT, newNumber().SetInt64(2))), newNumber().SetInt64(-1)},
 }
 
 func init() {
@@ -37,10 +37,10 @@ var ArSin = builtinFunc{"sin", func(args ...any) (any, ArErr) {
 		}
 	}
 	num := newNumber().Set(args[0].(number))
-	toTrim := newNumber().Mul(PI, newNumber().SetInt64(2))
+	toTrim := newNumber().Mul(PI_RAT, newNumber().SetInt64(2))
 	toTrim.Quo(num, toTrim)
 	toTrim = floor(toTrim)
-	toTrim.Mul(toTrim, newNumber().Mul(PI, newNumber().SetInt64(2)))
+	toTrim.Mul(toTrim, newNumber().Mul(PI_RAT, newNumber().SetInt64(2)))
 	num.Sub(num, toTrim)
 
 	for i := 0; i < len(sinCache); i++ {
@@ -49,7 +49,7 @@ var ArSin = builtinFunc{"sin", func(args ...any) (any, ArErr) {
 		}
 	}
 
-	num.Quo(num, PI)
+	num.Quo(num, PI_RAT)
 	num.Mul(num, PIFloatInaccuracy)
 	n, _ := num.Float64()
 	outputnum := newNumber().SetFloat64(math.Sin(n))
@@ -78,7 +78,7 @@ var ArArcsin = builtinFunc{"arcsin", func(args ...any) (any, ArErr) {
 	}
 	outputnum := newNumber().SetFloat64(math.Asin(n))
 	outputnum.Quo(outputnum, PIFloatInaccuracy)
-	outputnum.Mul(outputnum, PI)
+	outputnum.Mul(outputnum, PI_RAT)
 	return outputnum, ArErr{}
 }}
 
@@ -95,7 +95,7 @@ var ArCos = builtinFunc{"cos", func(args ...any) (any, ArErr) {
 			EXISTS:  true,
 		}
 	}
-	return builtinCall(ArSin, []any{newNumber().Add(args[0].(number), newNumber().Quo(PI, newNumber().SetInt64(2)))})
+	return builtinCall(ArSin, []any{newNumber().Add(args[0].(number), newNumber().Quo(PI_RAT, newNumber().SetInt64(2)))})
 }}
 var ArArccos = builtinFunc{"arccos", func(args ...any) (any, ArErr) {
 	if len(args) != 1 {
@@ -120,7 +120,7 @@ var ArArccos = builtinFunc{"arccos", func(args ...any) (any, ArErr) {
 	}
 	outputnum := newNumber().SetFloat64(math.Acos(n))
 	outputnum.Quo(outputnum, PIFloatInaccuracy)
-	outputnum.Mul(outputnum, PI)
+	outputnum.Mul(outputnum, PI_RAT)
 	return outputnum, ArErr{}
 }}
 
@@ -138,7 +138,7 @@ var ArTan = builtinFunc{"tan", func(args ...any) (any, ArErr) {
 		}
 	}
 	num := newNumber().Set(args[0].(number))
-	num.Quo(num, PI)
+	num.Quo(num, PI_RAT)
 	num.Mul(num, PIFloatInaccuracy)
 	n, _ := num.Float64()
 	outputnum := newNumber().SetFloat64(math.Tan(n))
@@ -161,7 +161,7 @@ var ArArctan = builtinFunc{"arctan", func(args ...any) (any, ArErr) {
 	n, _ := num.Float64()
 	outputnum := newNumber().SetFloat64(math.Atan(n))
 	outputnum.Quo(outputnum, PIFloatInaccuracy)
-	outputnum.Mul(outputnum, PI)
+	outputnum.Mul(outputnum, PI_RAT)
 	return outputnum, ArErr{}
 }}
 
@@ -179,7 +179,7 @@ var ArCosec = builtinFunc{"cosec", func(args ...any) (any, ArErr) {
 		}
 	}
 	num := newNumber().Set(args[0].(number))
-	num.Quo(num, PI)
+	num.Quo(num, PI_RAT)
 	num.Mul(num, PIFloatInaccuracy)
 	n, _ := num.Float64()
 	outputnum := newNumber().SetFloat64(1 / math.Sin(n))
@@ -208,7 +208,7 @@ var ArArccosec = builtinFunc{"arccosec", func(args ...any) (any, ArErr) {
 	}
 	outputnum := newNumber().SetFloat64(math.Asin(1 / n))
 	outputnum.Quo(outputnum, PIFloatInaccuracy)
-	outputnum.Mul(outputnum, PI)
+	outputnum.Mul(outputnum, PI_RAT)
 	return outputnum, ArErr{}
 }}
 
@@ -226,7 +226,7 @@ var ArSec = builtinFunc{"sec", func(args ...any) (any, ArErr) {
 		}
 	}
 	num := newNumber().Set(args[0].(number))
-	num.Quo(num, PI)
+	num.Quo(num, PI_RAT)
 	num.Mul(num, PIFloatInaccuracy)
 	n, _ := num.Float64()
 	outputnum := newNumber().SetFloat64(1 / math.Cos(n))
@@ -256,7 +256,7 @@ var ArArcsec = builtinFunc{"arcsec", func(args ...any) (any, ArErr) {
 	}
 	outputnum := newNumber().SetFloat64(math.Acos(1 / n))
 	outputnum.Quo(outputnum, PIFloatInaccuracy)
-	outputnum.Mul(outputnum, PI)
+	outputnum.Mul(outputnum, PI_RAT)
 	return outputnum, ArErr{}
 }}
 
@@ -274,7 +274,7 @@ var ArCot = builtinFunc{"cot", func(args ...any) (any, ArErr) {
 		}
 	}
 	num := newNumber().Set(args[0].(number))
-	num.Quo(num, PI)
+	num.Quo(num, PI_RAT)
 	num.Mul(num, PIFloatInaccuracy)
 	n, _ := num.Float64()
 	outputnum := newNumber().SetFloat64(1 / math.Tan(n))
@@ -298,7 +298,7 @@ var ArArccot = builtinFunc{"arccot", func(args ...any) (any, ArErr) {
 	n, _ := num.Float64()
 	outputnum := newNumber().SetFloat64(math.Atan(1 / n))
 	outputnum.Quo(outputnum, PIFloatInaccuracy)
-	outputnum.Mul(outputnum, PI)
+	outputnum.Mul(outputnum, PI_RAT)
 	return outputnum, ArErr{}
 }}
 
@@ -316,7 +316,7 @@ var ArToDeg = builtinFunc{"toDeg", func(args ...any) (any, ArErr) {
 		}
 	}
 	num := newNumber().Set(args[0].(number))
-	num.Quo(num, PI)
+	num.Quo(num, PI_RAT)
 	num.Mul(num, newNumber().SetInt64(180))
 	return num, ArErr{}
 }}
@@ -336,6 +336,6 @@ var ArToRad = builtinFunc{"toRad", func(args ...any) (any, ArErr) {
 	}
 	num := newNumber().Set(args[0].(number))
 	num.Quo(num, newNumber().SetInt64(180))
-	num.Mul(num, PI)
+	num.Mul(num, PI_RAT)
 	return num, ArErr{}
 }}

src/typeof.go

@@ -2,8 +2,6 @@ package main
 
 func typeof(val any) string {
 	switch x := val.(type) {
-	case number:
-		return "number"
 	case nil:
 		return "null"
 	case bool:

src/variable.go

@@ -76,12 +76,13 @@ func parseVariable(code UNPARSEcode) (accessVariable, bool, ArErr, int) {
 }
 
 func readVariable(v accessVariable, stack stack) (any, ArErr) {
+	name := ArString(v.Name)
 	for i := len(stack) - 1; i >= 0; i-- {
 		callable, ok := stack[i].obj["__Contains__"]
 		if !ok {
 			continue
 		}
-		contains, err := builtinCall(callable, []any{v.Name})
+		contains, err := builtinCall(callable, []any{name})
 		if err.EXISTS {
 			return nil, err
 		}
@@ -90,7 +91,7 @@ func readVariable(v accessVariable, stack stack) (any, ArErr) {
 			if !ok {
 				continue
 			}
-			return builtinCall(callable, []any{v.Name})
+			return builtinCall(callable, []any{name})
 		}
 	}
 	return nil, ArErr{"Name Error", "variable \"" + v.Name + "\" does not exist", v.Line, v.Path, v.Code, true}
@@ -159,7 +160,7 @@ func parseSetVariable(code UNPARSEcode, index int, lines []UNPARSEcode, isLine i
 		params = x.params
 		toset = x.toset
 		if toset == nil {
-			return setVariable{}, false, ArErr{"Type Error", "can't set for non variable, did you mean to put 'let' before?", code.line, code.path, code.realcode, true}, 1
+			return setVariable{}, false, ArErr{"Type Error", "can't set for non variable, did you mean '=='?", code.line, code.path, code.realcode, true}, 1
 		}
 	default:
 		return setVariable{}, false, ArErr{"Type Error", "can't set for non variable, did you mean '=='?", code.line, code.path, code.realcode, true}, 1
@@ -223,7 +224,7 @@ func parseAutoAsignVariable(code UNPARSEcode, index int, lines []UNPARSEcode, is
 			toset = x.toset
 		default:
 			if i == len(equalsplit)-1 {
-				return setVariable{}, false, ArErr{"Type Error", "can't set for non variable, did you mean to put 'let' before?", code.line, code.path, code.realcode, true}, 1
+				return setVariable{}, false, ArErr{"Type Error", "can't set for non variable, did you mean '=='?", code.line, code.path, code.realcode, true}, 1
 			}
 			continue
 		}