start removing newNumber and number types from the code.

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/buffer.go

@@ -6,8 +6,6 @@ import (
 	"fmt"
 )
 
-var one = newNumber().SetInt64(1)
-
 func ArByte(Byte byte) ArObject {
 	obj := ArObject{
 		obj: anymap{
@@ -30,7 +28,7 @@ func ArByte(Byte byte) ArObject {
 	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{
@@ -114,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",
@@ -171,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
@@ -253,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{
@@ -342,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:
@@ -358,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",
@@ -405,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:
@@ -431,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",
@@ -474,7 +469,7 @@ 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{}
 						}
 					}
 				}
@@ -523,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}

src/built-ins.go

@@ -66,7 +66,7 @@ func makeGlobal() ArObject {
 		a[0] = ArValidToAny(a[0])
 		switch x := a[0].(type) {
 		case number:
-			if x.Denom().Cmp(one.Denom()) != 0 {
+			if x.Denom().Cmp(_one_Rat.Denom()) != 0 {
 				return nil, ArErr{TYPE: "Type Error", message: "Cannot convert non-integer to hex", EXISTS: true}
 			}
 			n := x.Num().Int64()

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/number.go

@@ -577,7 +577,7 @@ func _BigInt_logic(val ArObject, CurrentNumber *big.Int) {
 				if ReceivingNumber.Cmp(_zero_Rat) == 0 {
 					return nil, ArErr{"Runtime Error", "division by zero", 0, "", "", true}
 				}
-				x := newNumber().Set(ReceivingNumber)
+				x := new(big.Rat).Set(ReceivingNumber)
 				output := new(big.Rat).SetInt(CurrentNumber)
 				x.Quo(output, x)
 				x = floor(x)
@@ -613,8 +613,8 @@ func _BigInt_logic(val ArObject, CurrentNumber *big.Int) {
 				if CurrentNumber.Cmp(_zero) == 0 {
 					return nil, ArErr{"Runtime Error", "division by zero", 0, "", "", true}
 				}
-				currentNumber_RAT := newNumber().SetInt(CurrentNumber)
-				x := newNumber().Set(currentNumber_RAT)
+				currentNumber_RAT := new(big.Rat).SetInt(CurrentNumber)
+				x := new(big.Rat).Set(currentNumber_RAT)
 				output := new(big.Rat).Set(ReceivingNumber)
 				x.Quo(output, x)
 				x = floor(x)
@@ -650,7 +650,7 @@ func _BigInt_logic(val ArObject, CurrentNumber *big.Int) {
 				if ReceivingNumber.Cmp(_zero_Rat) == 0 {
 					return nil, ArErr{"Runtime Error", "division by zero", 0, "", "", true}
 				}
-				x := newNumber().Set(ReceivingNumber)
+				x := new(big.Rat).Set(ReceivingNumber)
 				output := new(big.Rat).SetInt(CurrentNumber)
 				x.Quo(output, x)
 				x = floor(x)
@@ -685,8 +685,8 @@ func _BigInt_logic(val ArObject, CurrentNumber *big.Int) {
 				if CurrentNumber.Cmp(_zero) == 0 {
 					return nil, ArErr{"Runtime Error", "division by zero", 0, "", "", true}
 				}
-				currentNumber_RAT := newNumber().SetInt(CurrentNumber)
-				x := newNumber().Set(currentNumber_RAT)
+				currentNumber_RAT := new(big.Rat).SetInt(CurrentNumber)
+				x := new(big.Rat).Set(currentNumber_RAT)
 				output := new(big.Rat).Set(ReceivingNumber)
 				x.Quo(output, x)
 				x = floor(x)
@@ -1046,7 +1046,7 @@ func _BigRat_logic(val ArObject, CurrentNumber *big.Rat) {
 					return nil, ArErr{"Runtime Error", "division by zero", 0, "", "", true}
 				}
 				ReceivingNumber_RAT := new(big.Rat).SetInt(ReceivingNumber)
-				x := newNumber().Set(ReceivingNumber_RAT)
+				x := new(big.Rat).Set(ReceivingNumber_RAT)
 				output := new(big.Rat).Set(CurrentNumber)
 				x.Quo(output, x)
 				x = floor(x)
@@ -1058,7 +1058,7 @@ func _BigRat_logic(val ArObject, CurrentNumber *big.Rat) {
 					return nil, ArErr{"Runtime Error", "division by zero", 0, "", "", true}
 				}
 				ReceivingNumber_RAT := new(big.Rat).SetInt64(ReceivingNumber)
-				x := newNumber().Set(ReceivingNumber_RAT)
+				x := new(big.Rat).Set(ReceivingNumber_RAT)
 				output := new(big.Rat).Set(CurrentNumber)
 				x.Quo(output, x)
 				x = floor(x)
@@ -1069,7 +1069,7 @@ func _BigRat_logic(val ArObject, CurrentNumber *big.Rat) {
 				if ReceivingNumber.Cmp(_zero_Rat) == 0 {
 					return nil, ArErr{"Runtime Error", "division by zero", 0, "", "", true}
 				}
-				x := newNumber().Set(ReceivingNumber)
+				x := new(big.Rat).Set(ReceivingNumber)
 				output := new(big.Rat).Set(CurrentNumber)
 				x.Quo(output, x)
 				x = floor(x)
@@ -1096,7 +1096,7 @@ func _BigRat_logic(val ArObject, CurrentNumber *big.Rat) {
 					return nil, ArErr{"Runtime Error", "division by zero", 0, "", "", true}
 				}
 				ReceivingNumber_RAT := new(big.Rat).SetInt(ReceivingNumber)
-				x := newNumber().Set(ReceivingNumber_RAT)
+				x := new(big.Rat).Set(ReceivingNumber_RAT)
 				output := new(big.Rat).Set(CurrentNumber)
 				x.Quo(output, x)
 				x = floor(x)
@@ -1108,7 +1108,7 @@ func _BigRat_logic(val ArObject, CurrentNumber *big.Rat) {
 					return nil, ArErr{"Runtime Error", "division by zero", 0, "", "", true}
 				}
 				ReceivingNumber_RAT := new(big.Rat).SetInt64(ReceivingNumber)
-				x := newNumber().Set(ReceivingNumber_RAT)
+				x := new(big.Rat).Set(ReceivingNumber_RAT)
 				output := new(big.Rat).Set(CurrentNumber)
 				x.Quo(output, x)
 				x = floor(x)
@@ -1119,7 +1119,7 @@ func _BigRat_logic(val ArObject, CurrentNumber *big.Rat) {
 				if CurrentNumber.Cmp(_zero_Rat) == 0 {
 					return nil, ArErr{"Runtime Error", "division by zero", 0, "", "", true}
 				}
-				x := newNumber().Set(ReceivingNumber)
+				x := new(big.Rat).Set(ReceivingNumber)
 				output := new(big.Rat).Set(CurrentNumber)
 				x.Quo(output, x)
 				x = floor(x)
@@ -1596,7 +1596,7 @@ func _int64_logic(val ArObject, CurrentNumber int64) {
 					return nil, ArErr{"Runtime Error", "division by zero", 0, "", "", true}
 				}
 				CurrentNumber_Rat := new(big.Rat).SetInt64(CurrentNumber)
-				x := newNumber().Set(ReceivingNumber)
+				x := new(big.Rat).Set(ReceivingNumber)
 				output := new(big.Rat).Set(CurrentNumber_Rat)
 				x.Quo(output, x)
 				x = floor(x)
@@ -1632,7 +1632,7 @@ func _int64_logic(val ArObject, CurrentNumber int64) {
 				if CurrentNumber == 0 {
 					return nil, ArErr{"Runtime Error", "division by zero", 0, "", "", true}
 				}
-				x := newNumber().Set(ReceivingNumber)
+				x := new(big.Rat).Set(ReceivingNumber)
 				output := new(big.Rat).SetInt64(CurrentNumber)
 				x.Quo(output, x)
 				x = floor(x)

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/typeof.go

@@ -8,8 +8,6 @@ func typeof(val any) string {
 		return "boolean"
 	case string:
 		return "string"
-	case number:
-		return "number"
 	case []any:
 		return "array"
 	case anymap: