change argon version

parse imports with fixed paths before running all the code

.github/workflows/build_release.yml

@@ -0,0 +1,24 @@
+# workflow name
+name: Generate release-artifacts
+
+on:
+  release:
+    types:
+      - created
+
+# workflow tasks
+jobs:
+  generate:
+    name: Generate cross-platform builds
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout the repository
+        uses: actions/checkout@v2
+      - name: Generate build files
+        uses: thatisuday/go-cross-build@v1
+        with:
+            platforms: 'linux/amd64, darwin/amd64, windows/amd64'
+            package: 'src'
+            name: 'argon'
+            compress: 'true'
+            dest: 'bin'

.github/workflows/build_releases.yml

@@ -1,45 +0,0 @@
-name: Build and Release Go Binary
-
-on:
-  release:
-    types:
-      - created
-
-jobs:
-  build:
-    name: Build and Release
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v2
-
-      - name: Set up Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: 1.20 # Use your desired Go version
-
-      - name: Build Go project
-        run: go build -o argon ./src
-
-      - name: Create release
-        id: create_release
-        uses: actions/create-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          tag_name: ${{ github.ref }}
-          release_name: Release ${{ github.ref }}
-          draft: false
-          prerelease: false
-
-      - name: Upload binary to release
-        id: upload-release-asset
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: ./argon
-          asset_name: argon
-          asset_content_type: application/octet-stream

argon-package.json

@@ -1,4 +0,0 @@
-{
-	"name": "argon-v3",
-	"version": "3.0.1"
-}

build.bat

@@ -1,2 +1,2 @@
 @echo off
-go build -trimpath -ldflags="-s -w" -o bin/argon.exe ./src
+go build -trimpath -ldflags="-s -w" -tags WINDOWS -o bin/argon.exe ./src

debug.bat

@@ -3,4 +3,4 @@
 :: run the go run command passing the path to the main.go file, with the working directory set to the bin folder. pass in the arguments
 
 set __ARGON_DEBUG__=true
-go run ./src %*
+go run -tags WINDOWS ./src %*

go.mod

@@ -7,7 +7,15 @@ 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/go-ole/go-ole v1.2.6 // indirect
+	github.com/joho/godotenv v1.5.1 // indirect
+	github.com/shirou/gopsutil v2.21.11+incompatible // indirect
+	github.com/tklauser/go-sysconf v0.3.14 // indirect
+	github.com/tklauser/numcpus v0.8.0 // indirect
+	github.com/yusufpapurcu/wmi v1.2.4 // indirect
+)
 
 require (
 	github.com/gabriel-vasile/mimetype v1.4.2
@@ -18,7 +26,7 @@ require (
 	github.com/jwalton/go-supportscolor v1.1.0
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.17 // indirect
-	golang.org/x/sys v0.6.0 // indirect
+	golang.org/x/sys v0.19.0 // indirect
 	golang.org/x/term v0.6.0
 	golang.org/x/text v0.8.0
 )

go.sum

@@ -1,7 +1,13 @@
+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=
 github.com/gabriel-vasile/mimetype v1.4.2/go.mod h1:zApsH/mKG4w07erKIaJPFiX0Tsq9BFQgN3qGY5GnNgA=
+github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY=
+github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
 github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
 github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
 github.com/jwalton/go-supportscolor v1.1.0 h1:HsXFJdMPjRUAx8cIW6g30hVSFYaxh9yRQwEWgkAR7lQ=
@@ -11,19 +17,31 @@ github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovk
 github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.17 h1:BTarxUcIeDqL27Mc+vyvdWYSL28zpIhv3RoTdsLMPng=
 github.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/shirou/gopsutil v2.21.11+incompatible h1:lOGOyCG67a5dv2hq5Z1BLDUqqKp3HkbjPcz5j6XMS0U=
+github.com/shirou/gopsutil v2.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
+github.com/tklauser/go-sysconf v0.3.14 h1:g5vzr9iPFFz24v2KZXs/pvpvh8/V9Fw6vQK5ZZb78yU=
+github.com/tklauser/go-sysconf v0.3.14/go.mod h1:1ym4lWMLUOhuBOPGtRcJm7tEGX4SCYNEEEtghGG/8uY=
+github.com/tklauser/numcpus v0.8.0 h1:Mx4Wwe/FjZLeQsK/6kt2EOepwwSl7SmJrK5bV/dXYgY=
+github.com/tklauser/numcpus v0.8.0/go.mod h1:ZJZlAY+dmR4eut8epnzf0u/VwodKmryxR8txiloSqBE=
 github.com/wadey/go-rounding v1.1.0 h1:RAs9dMkB/uUHFv9ljlbRFC8/kBrQ5jhwt1GQq+2cciY=
 github.com/wadey/go-rounding v1.1.0/go.mod h1:/uD953tCL6Fea2Yp+LZBBp8d60QSObkMJxY6SPOJ5QE=
+github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=
+github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
 golang.org/x/crypto v0.7.0 h1:AvwMYaRytfdeVt3u6mLaxYtErKYjxA2OXjJ1HHq6t3A=
 golang.org/x/crypto v0.7.0/go.mod h1:pYwdfH91IfpZVANVyUOhSIPZaFoJGxTFbZhFTx+dXZU=
 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-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 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=
 golang.org/x/sys v0.6.0 h1:MVltZSvRTcU2ljQOhs94SXPftV6DCNnZViHeQps87pQ=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.19.0 h1:q5f1RH2jigJ1MoAWp2KTp3gm5zAGFUTarQZ5U386+4o=
+golang.org/x/sys v0.19.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d h1:SZxvLBoTP5yHO3Frd4z4vrF+DBX9vMVanchswa69toE=
 golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.6.0 h1:clScbb1cHjoCkyRbWwBEUZ5H/tIFu5TAXIqaZD0Gcjw=

iso-lock.json

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

readme.md

@@ -5,7 +5,9 @@
 <h1>Argon v3</h1>
 </div>
 
-ARGON 3 is a math-driven programming language designed to make code easy to read and write. It's not meant to be fast, as it's interpreted. This specification should be used as a guideline, and is subject to change for later versions. Later updates for Argon 3 should be backwards compatible (where possible) with code designed for older versions of the interpreter.
+[![Go](https://github.com/Open-Argon/argon-v3/actions/workflows/go.yml/badge.svg)](https://github.com/Open-Argon/argon-v3/actions/workflows/go.yml)
+
+ARGON 3 is a math-driven programming language designed to make code easy to read and write. It's not meant to be fast, as it's interpreted.
 
 ## 📚 Features
    - Easy to read and write: Argon 3 is designed with clarity of code in mind, making it easier for you and others to read and write code.
@@ -13,10 +15,14 @@ ARGON 3 is a math-driven programming language designed to make code easy to read
    - Math-driven: Designed for mathematical computations, Argon 3 uses techniques and rules set in maths. It's designed to be easy for mathematicians to write and understand algorithms in.
    - Interpreted: Argon 3 is an interpreted language, so you don't need to compile your code before running it.
    - Cross-platform: Argon 3 can be run on any platform that has an interpreter for it.
-   - Lightweight: The Argon 3 interpreter is small and doesn't require a lot of system resources to run.
 
 ## 💻 Installation
-As of now, Argon 3 does not have an installer. Feel free to clone this repo and run the `build` file for your plateform. the build will be found in `bin/argon(.exe)`.
+### Windows
+As of now, Argon 3 does not have a windows installer. Feel free to clone this repo and run the `build.bat` file. the build will be found in `bin\argon.exe`.
+If you want to also use the isotope package manager, you can find the source code [here](https://github.com/open-argon/isotope).
+
+### UNIX based (macOS and Linux)
+Unix based operating systems can use the argon installer script found at [https://argon.wbell.dev/](https://argon.wbell.dev/). The script should run on all modern linux distros, and should also work on macOS with limited support. It may also work on other Unix based operating systems such at FreeBSD, but those are untested but are supported if you have issues.
 
 ## 📖 Usage
 To use Argon 3, you can create a file with the .ar extension and write your code in it. Then, you can run your code using the interpreter. For example, if you have a file called example.ar, you can run it using the following command:

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()

src/array.go

@@ -23,7 +23,6 @@ func ArArray(arr []any) ArObject {
 		anymap{
 			"__name__":  "array",
 			"__value__": arr,
-			"length":    newNumber().SetUint64(uint64(len(arr))),
 		},
 	}
 	val.obj["__setindex__"] = builtinFunc{
@@ -31,21 +30,21 @@ func ArArray(arr []any) ArObject {
 		func(a ...any) (any, ArErr) {
 			if len(a) != 2 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected 2 arguments, got " + fmt.Sprint(len(a)),
 					EXISTS:  true,
 				}
 			}
 			if typeof(a[0]) != "number" {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "dex must be a number",
 					EXISTS:  true,
 				}
 			}
 			if !a[0].(number).IsInt() {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "index must be an integer",
 					EXISTS:  true,
 				}
@@ -53,7 +52,7 @@ func ArArray(arr []any) ArObject {
 			num := int(a[0].(number).Num().Int64())
 			if num < 0 || num >= len(arr) {
 				return nil, ArErr{
-					TYPE:    "IndexError",
+					TYPE:    "Index Error",
 					message: "index out of range",
 					EXISTS:  true,
 				}
@@ -62,14 +61,47 @@ func ArArray(arr []any) ArObject {
 			return nil, ArErr{}
 		},
 	}
+	val.obj["__Multiply__"] = builtinFunc{
+		"__Multiply__",
+		func(a ...any) (any, ArErr) {
+			if len(a) != 1 {
+				return nil, ArErr{"Type Error", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
+			}
+			if typeof(a[0]) != "number" {
+				return nil, ArErr{"Type Error", "cannot multiply array by " + typeof(a[0]), 0, "", "", true}
+			}
+			n := a[0].(number)
+			if !n.IsInt() {
+				return nil, ArErr{"Value Error", "cannot multiply array by float", 0, "", "", true}
+			}
+			if n.Sign() < 0 {
+				return nil, ArErr{"Value Error", "cannot multiply array by negative number", 0, "", "", true}
+			}
+			size := int(n.Num().Int64())
+			retval := make([]any, 0, len(arr)*size)
+			for i := 0; i < size; i++ {
+				retval = append(retval, arr...)
+			}
+			return ArArray(retval), ArErr{}
+		}}
 	val.obj["__getindex__"] = builtinFunc{
 		"__getindex__",
 		func(a ...any) (any, ArErr) {
 			// a[0] is start
 			// a[1] is end
 			// a[2] is step
-			if len(a) > 3 {
+			if len(a) > 3 || len(a) == 0 {
-				return nil, ArErr{"TypeError", "expected 1 to 3 arguments, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 1 to 3 arguments, got " + fmt.Sprint(len(a)), 0, "", "", true}
+			}
+			{
+				if len(a) == 1 {
+					if typeof(a[0]) == "string" {
+						var name = ArValidToAny(a[0]).(string)
+						if name == "length" {
+							return newNumber().SetInt64(int64(len(arr))), ArErr{}
+						}
+					}
+				}
 			}
 			var (
 				start int = 0
@@ -81,7 +113,7 @@ func ArArray(arr []any) ArObject {
 					start = 0
 				} else if typeof(a[0]) != "number" || !a[0].(number).IsInt() {
 					return "", ArErr{
-						TYPE:    "TypeError",
+						TYPE:    "Type Error",
 						message: "slice index must be an integer",
 						EXISTS:  true,
 					}
@@ -94,7 +126,7 @@ func ArArray(arr []any) ArObject {
 					end = len(arr)
 				} else if typeof(a[1]) != "number" || !a[1].(number).IsInt() {
 					return "", ArErr{
-						TYPE:    "TypeError",
+						TYPE:    "Type Error",
 						message: "slice index must be an integer",
 						EXISTS:  true,
 					}
@@ -107,7 +139,7 @@ func ArArray(arr []any) ArObject {
 					step = 1
 				} else if typeof(a[2]) != "number" || !a[2].(number).IsInt() {
 					return "", ArErr{
-						TYPE:    "TypeError",
+						TYPE:    "Type Error",
 						message: "slice index must be an integer",
 						EXISTS:  true,
 					}
@@ -127,7 +159,7 @@ func ArArray(arr []any) ArObject {
 			}
 			if start >= len(arr) || start < 0 {
 				return "", ArErr{
-					TYPE:    "IndexError",
+					TYPE:    "Index Error",
 					message: "index out of range, trying to access index " + fmt.Sprint(ogStart) + " in array of length " + fmt.Sprint(len(arr)),
 					EXISTS:  true,
 				}
@@ -155,21 +187,21 @@ func ArArray(arr []any) ArObject {
 		func(args ...any) (any, ArErr) {
 			if len(args) != 1 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "missing argument",
 					EXISTS:  true,
 				}
 			}
 			if typeof(args[0]) != "number" {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "argument must be a number",
 					EXISTS:  true,
 				}
 			}
 			if !args[0].(number).IsInt() {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "argument must be an integer",
 					EXISTS:  true,
 				}
@@ -177,13 +209,12 @@ func ArArray(arr []any) ArObject {
 			num := int(args[0].(number).Num().Int64())
 			if num < 0 || num >= len(arr) {
 				return nil, ArErr{
-					TYPE:    "IndexError",
+					TYPE:    "Index Error",
 					message: "index out of range",
 					EXISTS:  true,
 				}
 			}
 			arr = append(arr[:num], arr[num+1:]...)
-			val.obj["length"] = newNumber().SetUint64(uint64(len(arr)))
 			val.obj["__value__"] = arr
 			return nil, ArErr{}
 		}}
@@ -192,13 +223,12 @@ func ArArray(arr []any) ArObject {
 		func(args ...any) (any, ArErr) {
 			if len(args) == 0 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "missing argument",
 					EXISTS:  true,
 				}
 			}
 			arr = append(arr, args...)
-			val.obj["length"] = newNumber().SetUint64(uint64(len(arr)))
 			val.obj["__value__"] = arr
 			return nil, ArErr{}
 		},
@@ -208,21 +238,21 @@ func ArArray(arr []any) ArObject {
 		func(args ...any) (any, ArErr) {
 			if len(args) < 2 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "missing argument",
 					EXISTS:  true,
 				}
 			}
 			if typeof(args[0]) != "number" {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "argument must be a number",
 					EXISTS:  true,
 				}
 			}
 			if !args[0].(number).IsInt() {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "argument must be an integer",
 					EXISTS:  true,
 				}
@@ -230,13 +260,12 @@ func ArArray(arr []any) ArObject {
 			num := int(args[0].(number).Num().Int64())
 			if num < 0 || num > len(arr) {
 				return nil, ArErr{
-					TYPE:    "IndexError",
+					TYPE:    "Index Error",
 					message: "index out of range",
 					EXISTS:  true,
 				}
 			}
 			arr = append(arr[:num], append(args[1:], arr[num:]...)...)
-			val.obj["length"] = newNumber().SetUint64(uint64(len(arr)))
 			val.obj["__value__"] = arr
 			return nil, ArErr{}
 		},
@@ -246,7 +275,7 @@ func ArArray(arr []any) ArObject {
 		func(args ...any) (any, ArErr) {
 			if len(args) > 1 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "too many arguments",
 					EXISTS:  true,
 				}
@@ -254,14 +283,14 @@ func ArArray(arr []any) ArObject {
 			if len(args) == 1 {
 				if typeof(args[0]) != "number" {
 					return nil, ArErr{
-						TYPE:    "TypeError",
+						TYPE:    "Type Error",
 						message: "argument must be a number",
 						EXISTS:  true,
 					}
 				}
 				if !args[0].(number).IsInt() {
 					return nil, ArErr{
-						TYPE:    "TypeError",
+						TYPE:    "Type Error",
 						message: "argument must be an integer",
 						EXISTS:  true,
 					}
@@ -269,20 +298,18 @@ func ArArray(arr []any) ArObject {
 				num := int(args[0].(number).Num().Int64())
 				if num < 0 || num >= len(arr) {
 					return nil, ArErr{
-						TYPE:    "IndexError",
+						TYPE:    "Index Error",
 						message: "index out of range",
 						EXISTS:  true,
 					}
 				}
 				v := arr[num]
 				arr = append(arr[:num], arr[num+1:]...)
-				val.obj["length"] = newNumber().SetUint64(uint64(len(arr)))
 				val.obj["__value__"] = arr
 				return v, ArErr{}
 			}
 			v := arr[len(arr)-1]
 			arr = arr[:len(arr)-1]
-			val.obj["length"] = newNumber().SetUint64(uint64(len(arr)))
 			val.obj["__value__"] = arr
 			return v, ArErr{}
 		},
@@ -292,13 +319,12 @@ func ArArray(arr []any) ArObject {
 		func(args ...any) (any, ArErr) {
 			if len(args) != 0 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "too many arguments",
 					EXISTS:  true,
 				}
 			}
 			arr = []any{}
-			val.obj["length"] = newNumber().SetUint64(uint64(len(arr)))
 			val.obj["__value__"] = arr
 			return nil, ArErr{}
 		},
@@ -308,20 +334,19 @@ func ArArray(arr []any) ArObject {
 		func(args ...any) (any, ArErr) {
 			if len(args) != 1 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "missing argument",
 					EXISTS:  true,
 				}
 			}
 			if typeof(args[0]) != "array" {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "argument must be an array",
 					EXISTS:  true,
 				}
 			}
 			arr = append(arr, args[0].(ArObject).obj["__value__"].([]any)...)
-			val.obj["length"] = newNumber().SetUint64(uint64(len(arr)))
 			val.obj["__value__"] = arr
 			return nil, ArErr{}
 		},
@@ -331,7 +356,7 @@ func ArArray(arr []any) ArObject {
 		func(args ...any) (any, ArErr) {
 			if len(args) > 2 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "too many arguments",
 					EXISTS:  true,
 				}
@@ -340,7 +365,7 @@ func ArArray(arr []any) ArObject {
 			if len(args) >= 1 {
 				if typeof(args[0]) != "boolean" {
 					return nil, ArErr{
-						TYPE:    "TypeError",
+						TYPE:    "Type Error",
 						message: "argument must be a boolean",
 						EXISTS:  true,
 					}
@@ -350,7 +375,7 @@ func ArArray(arr []any) ArObject {
 			if len(args) == 2 {
 				if typeof(args[1]) != "function" {
 					return nil, ArErr{
-						TYPE:    "TypeError",
+						TYPE:    "Type Error",
 						message: "argument must be a function",
 						EXISTS:  true,
 					}
@@ -370,7 +395,6 @@ func ArArray(arr []any) ArObject {
 					}
 				}
 				arr = output
-				val.obj["length"] = newNumber().SetUint64(uint64(len(arr)))
 				val.obj["__value__"] = arr
 				return nil, ArErr{}
 			}
@@ -386,7 +410,6 @@ func ArArray(arr []any) ArObject {
 				}
 			}
 			arr = output
-			val.obj["length"] = newNumber().SetUint64(uint64(len(arr)))
 			val.obj["__value__"] = arr
 			return nil, ArErr{}
 		},
@@ -396,14 +419,14 @@ func ArArray(arr []any) ArObject {
 		func(args ...any) (any, ArErr) {
 			if len(args) != 1 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "missing argument",
 					EXISTS:  true,
 				}
 			}
 			if typeof(args[0]) != "function" {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "argument must be a function",
 					EXISTS:  true,
 				}
@@ -427,14 +450,14 @@ func ArArray(arr []any) ArObject {
 		func(args ...any) (any, ArErr) {
 			if len(args) != 1 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "missing argument",
 					EXISTS:  true,
 				}
 			}
 			if typeof(args[0]) != "function" {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "argument must be a function",
 					EXISTS:  true,
 				}
@@ -460,21 +483,21 @@ func ArArray(arr []any) ArObject {
 		func(args ...any) (any, ArErr) {
 			if len(args) != 2 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "missing argument, expected 2 got " + fmt.Sprint(len(args)),
 					EXISTS:  true,
 				}
 			}
 			if typeof(args[0]) != "function" {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "argument must be a function",
 					EXISTS:  true,
 				}
 			}
 			if len(arr) == 0 {
 				return nil, ArErr{
-					TYPE:    "ValueError",
+					TYPE:    "Value Error",
 					message: "array is empty",
 					EXISTS:  true,
 				}
@@ -498,14 +521,14 @@ func ArArray(arr []any) ArObject {
 		func(args ...any) (any, ArErr) {
 			if len(args) != 1 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "missing argument",
 					EXISTS:  true,
 				}
 			}
 			if typeof(args[0]) != "string" {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "argument must be a string",
 					EXISTS:  true,
 				}
@@ -514,7 +537,7 @@ func ArArray(arr []any) ArObject {
 			for _, v := range arr {
 				if typeof(v) != "string" {
 					return nil, ArErr{
-						TYPE:    "TypeError",
+						TYPE:    "Type Error",
 						message: "array must be an array of strings",
 						EXISTS:  true,
 					}
@@ -529,14 +552,14 @@ func ArArray(arr []any) ArObject {
 		func(args ...any) (any, ArErr) {
 			if len(args) < 1 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "missing argument(s)",
 					EXISTS:  true,
 				}
 			}
 			if typeof(args[0]) != "array" {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "argument must be an array",
 					EXISTS:  true,
 				}
@@ -550,7 +573,7 @@ func ArArray(arr []any) ArObject {
 		func(args ...any) (any, ArErr) {
 			if len(args) != 1 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "missing argument",
 					EXISTS:  true,
 				}
@@ -580,7 +603,7 @@ func ArArray(arr []any) ArObject {
 		func(args ...any) (any, ArErr) {
 			if len(args) != 1 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "missing argument",
 					EXISTS:  true,
 				}
@@ -605,7 +628,7 @@ func ArArray(arr []any) ArObject {
 		func(args ...any) (any, ArErr) {
 			if len(args) != 1 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "missing argument",
 					EXISTS:  true,
 				}

src/brackets.go

@@ -6,18 +6,11 @@ import (
 
 var bracketsCompile = makeRegex(`( *)\((.|\n)+\)( *)`)
 
-type brackets struct {
-	VAL  any
-	line int
-	code string
-	path string
-}
-
 func isBrackets(code UNPARSEcode) bool {
 	return bracketsCompile.MatchString(code.code)
 }
 
-func parseBrackets(code UNPARSEcode, index int, codeline []UNPARSEcode) (brackets, bool, ArErr, int) {
+func parseBrackets(code UNPARSEcode, index int, codeline []UNPARSEcode) (any, bool, ArErr, int) {
 	trimmed := strings.TrimSpace(code.code)
 	resp, worked, err, i := translateVal(UNPARSEcode{
 		code:     trimmed[1 : len(trimmed)-1],
@@ -25,10 +18,5 @@ func parseBrackets(code UNPARSEcode, index int, codeline []UNPARSEcode) (bracket
 		line:     code.line,
 		path:     code.path,
 	}, index, codeline, 0)
-	return brackets{
+	return resp, worked, err, i
-		VAL:  resp,
-		line: code.line,
-		code: code.realcode,
-		path: code.path,
-	}, worked, err, i
 }

src/buffer.go

@@ -35,7 +35,7 @@ func ArByte(Byte byte) ArObject {
 		func(a ...any) (any, ArErr) {
 			if len(a) == 0 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected at least 1 argument, got 0",
 					EXISTS:  true,
 				}
@@ -45,7 +45,7 @@ func ArByte(Byte byte) ArObject {
 			case number:
 				if x.Denom().Cmp(one.Denom()) != 0 {
 					return nil, ArErr{
-						TYPE:    "TypeError",
+						TYPE:    "Type Error",
 						message: "expected integer, got " + fmt.Sprint(x),
 						EXISTS:  true,
 					}
@@ -53,7 +53,7 @@ func ArByte(Byte byte) ArObject {
 				n := x.Num().Int64()
 				if n > 255 || n < 0 {
 					return nil, ArErr{
-						TYPE:    "ValueError",
+						TYPE:    "Value Error",
 						message: "expected number between 0 and 255, got " + fmt.Sprint(floor(x).Num().Int64()),
 						EXISTS:  true,
 					}
@@ -62,7 +62,7 @@ func ArByte(Byte byte) ArObject {
 			case string:
 				if len(x) != 1 {
 					return nil, ArErr{
-						TYPE:    "ValueError",
+						TYPE:    "Value Error",
 						message: "expected string of length 1, got " + fmt.Sprint(len(x)),
 						EXISTS:  true,
 					}
@@ -70,7 +70,7 @@ func ArByte(Byte byte) ArObject {
 				Byte = byte(x[0])
 			default:
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected number or string, got " + typeof(x),
 					EXISTS:  true,
 				}
@@ -86,7 +86,6 @@ func ArBuffer(buf []byte) ArObject {
 		obj: anymap{
 			"__name__":  "buffer",
 			"__value__": buf,
-			"length":    newNumber().SetInt64(int64(len(buf))),
 		},
 	}
 	obj.obj["__string__"] = builtinFunc{
@@ -106,7 +105,7 @@ func ArBuffer(buf []byte) ArObject {
 		func(a ...any) (any, ArErr) {
 			if len(a) == 0 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected at least 1 argument, got 0",
 					EXISTS:  true,
 				}
@@ -124,7 +123,7 @@ func ArBuffer(buf []byte) ArObject {
 					case number:
 						if y.Denom().Cmp(one.Denom()) != 0 {
 							return nil, ArErr{
-								TYPE:    "TypeError",
+								TYPE:    "Type Error",
 								message: "Cannot convert non-integer to byte",
 								EXISTS:  true,
 							}
@@ -132,7 +131,7 @@ func ArBuffer(buf []byte) ArObject {
 						outputbuf = append(outputbuf, byte(y.Num().Int64()))
 					default:
 						return nil, ArErr{
-							TYPE:    "TypeError",
+							TYPE:    "Type Error",
 							message: "Cannot convert " + typeof(v) + " to byte",
 							EXISTS:  true,
 						}
@@ -141,13 +140,12 @@ func ArBuffer(buf []byte) ArObject {
 				buf = outputbuf
 			default:
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected string or buffer, got " + typeof(x),
 					EXISTS:  true,
 				}
 			}
 			obj.obj["__value__"] = buf
-			obj.obj["length"] = newNumber().SetInt64(int64(len(buf)))
 			return obj, ArErr{}
 		},
 	}
@@ -156,7 +154,7 @@ func ArBuffer(buf []byte) ArObject {
 		func(a ...any) (any, ArErr) {
 			if len(a) != 2 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected 1 argument, got " + fmt.Sprint(len(a)),
 					EXISTS:  true,
 				}
@@ -164,7 +162,7 @@ func ArBuffer(buf []byte) ArObject {
 			splitVal := ArValidToAny(a[0])
 			if typeof(splitVal) != "buffer" {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected buffer, got " + typeof(splitVal),
 					EXISTS:  true,
 				}
@@ -173,7 +171,7 @@ func ArBuffer(buf []byte) ArObject {
 			nVal := ArValidToAny(a[1])
 			if typeof(nVal) != "number" {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected number, got " + typeof(nVal),
 					EXISTS:  true,
 				}
@@ -181,7 +179,7 @@ func ArBuffer(buf []byte) ArObject {
 			nNum := nVal.(number)
 			if nNum.Denom().Cmp(one.Denom()) != 0 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected integer, got " + fmt.Sprint(nNum),
 					EXISTS:  true,
 				}
@@ -216,7 +214,7 @@ func ArBuffer(buf []byte) ArObject {
 		func(a ...any) (any, ArErr) {
 			if len(a) != 1 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected 1 argument, got " + fmt.Sprint(len(a)),
 					EXISTS:  true,
 				}
@@ -224,7 +222,7 @@ func ArBuffer(buf []byte) ArObject {
 			splitVal := ArValidToAny(a[0])
 			if typeof(splitVal) != "buffer" {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected buffer, got " + typeof(splitVal),
 					EXISTS:  true,
 				}
@@ -255,7 +253,7 @@ func ArBuffer(buf []byte) ArObject {
 		func(a ...any) (any, ArErr) {
 			if len(a) != 2 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected 2 arguments, got " + fmt.Sprint(len(a)),
 					EXISTS:  true,
 				}
@@ -263,7 +261,7 @@ func ArBuffer(buf []byte) ArObject {
 			startVal := ArValidToAny(a[0])
 			if typeof(startVal) != "number" {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected number, got " + typeof(startVal),
 					EXISTS:  true,
 				}
@@ -271,7 +269,7 @@ func ArBuffer(buf []byte) ArObject {
 			start := startVal.(number)
 			if start.Denom().Cmp(one.Denom()) != 0 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected integer, got " + fmt.Sprint(start),
 					EXISTS:  true,
 				}
@@ -279,7 +277,7 @@ func ArBuffer(buf []byte) ArObject {
 			endVal := ArValidToAny(a[1])
 			if typeof(endVal) != "number" {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected number, got " + typeof(endVal),
 					EXISTS:  true,
 				}
@@ -287,7 +285,7 @@ func ArBuffer(buf []byte) ArObject {
 			end := endVal.(number)
 			if end.Denom().Cmp(one.Denom()) != 0 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected integer, got " + fmt.Sprint(end),
 					EXISTS:  true,
 				}
@@ -300,14 +298,14 @@ func ArBuffer(buf []byte) ArObject {
 		func(a ...any) (any, ArErr) {
 			if len(a) != 1 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected 1 argument, got " + fmt.Sprint(len(a)),
 					EXISTS:  true,
 				}
 			}
 			if typeof(a[0]) != "string" {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected string, got " + typeof(a[0]),
 					EXISTS:  true,
 				}
@@ -330,7 +328,7 @@ func ArBuffer(buf []byte) ArObject {
 				return ArArray(output), ArErr{}
 			default:
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected string, bytes or array, got '" + Type + "'",
 					EXISTS:  true,
 				}
@@ -342,7 +340,7 @@ func ArBuffer(buf []byte) ArObject {
 		func(a ...any) (any, ArErr) {
 			if len(a) != 1 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected 1 argument, got " + fmt.Sprint(len(a)),
 					EXISTS:  true,
 				}
@@ -352,7 +350,7 @@ func ArBuffer(buf []byte) ArObject {
 			case number:
 				if x.Denom().Cmp(one.Denom()) != 0 {
 					return nil, ArErr{
-						TYPE:    "TypeError",
+						TYPE:    "Type Error",
 						message: "Cannot convert non-integer to byte",
 						EXISTS:  true,
 					}
@@ -368,7 +366,7 @@ func ArBuffer(buf []byte) ArObject {
 					case number:
 						if y.Denom().Cmp(one.Denom()) != 0 {
 							return nil, ArErr{
-								TYPE:    "TypeError",
+								TYPE:    "Type Error",
 								message: "Cannot convert non-integer to byte",
 								EXISTS:  true,
 							}
@@ -376,7 +374,7 @@ func ArBuffer(buf []byte) ArObject {
 						buf = append(buf, byte(y.Num().Int64()))
 					default:
 						return nil, ArErr{
-							TYPE:    "TypeError",
+							TYPE:    "Type Error",
 							message: "Cannot convert " + typeof(v) + " to byte",
 							EXISTS:  true,
 						}
@@ -384,13 +382,12 @@ func ArBuffer(buf []byte) ArObject {
 				}
 			default:
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected string, buffer or array, got " + typeof(x),
 					EXISTS:  true,
 				}
 			}
 			obj.obj["__value__"] = buf
-			obj.obj["length"] = newNumber().SetInt64(int64(len(buf)))
 			return obj, ArErr{}
 		},
 	}
@@ -399,7 +396,7 @@ func ArBuffer(buf []byte) ArObject {
 		func(a ...any) (any, ArErr) {
 			if len(a) != 2 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected 2 arguments, got " + fmt.Sprint(len(a)),
 					EXISTS:  true,
 				}
@@ -408,7 +405,7 @@ func ArBuffer(buf []byte) ArObject {
 			values := ArValidToAny(a[1])
 			if typeof(poss) != "number" {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected number, got " + typeof(poss),
 					EXISTS:  true,
 				}
@@ -416,7 +413,7 @@ func ArBuffer(buf []byte) ArObject {
 			pos := poss.(number)
 			if pos.Denom().Cmp(one.Denom()) != 0 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "position must be an integer",
 					EXISTS:  true,
 				}
@@ -426,7 +423,7 @@ func ArBuffer(buf []byte) ArObject {
 			case number:
 				if x.Denom().Cmp(one.Denom()) != 0 {
 					return nil, ArErr{
-						TYPE:    "TypeError",
+						TYPE:    "Type Error",
 						message: "Cannot convert non-integer to byte",
 						EXISTS:  true,
 					}
@@ -442,7 +439,7 @@ func ArBuffer(buf []byte) ArObject {
 					case number:
 						if y.Denom().Cmp(one.Denom()) != 0 {
 							return nil, ArErr{
-								TYPE:    "TypeError",
+								TYPE:    "Type Error",
 								message: "Cannot convert non-integer to byte",
 								EXISTS:  true,
 							}
@@ -450,7 +447,7 @@ func ArBuffer(buf []byte) ArObject {
 						buf = append(buf[:posNum], append([]byte{byte(y.Num().Int64())}, buf[posNum:]...)...)
 					default:
 						return nil, ArErr{
-							TYPE:    "TypeError",
+							TYPE:    "Type Error",
 							message: "Cannot convert " + typeof(v) + " to byte",
 							EXISTS:  true,
 						}
@@ -458,30 +455,39 @@ func ArBuffer(buf []byte) ArObject {
 				}
 			default:
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected string or buffer, got " + typeof(x),
 					EXISTS:  true,
 				}
 			}
 			obj.obj["__value__"] = buf
-			obj.obj["length"] = newNumber().SetInt64(int64(len(buf)))
 			return obj, ArErr{}
 		},
 	}
-	obj.obj["remove"] = builtinFunc{
+	obj.obj["__getindex__"] = builtinFunc{
-		"remove",
+		"__getindex__",
 		func(a ...any) (any, ArErr) {
 			if len(a) != 1 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected 1 argument, got " + fmt.Sprint(len(a)),
 					EXISTS:  true,
 				}
 			}
+			{
+				if len(a) == 1 {
+					if typeof(a[0]) == "string" {
+						var name = ArValidToAny(a[0]).(string)
+						if name == "length" {
+							return newNumber().SetInt64(int64(len(buf))), ArErr{}
+						}
+					}
+				}
+			}
 			poss := ArValidToAny(a[0])
 			if typeof(poss) != "number" {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected number, got " + typeof(poss),
 					EXISTS:  true,
 				}
@@ -489,7 +495,44 @@ func ArBuffer(buf []byte) ArObject {
 			pos := poss.(number)
 			if pos.Denom().Cmp(one.Denom()) != 0 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
+					message: "position must be an integer",
+					EXISTS:  true,
+				}
+			}
+			posNum := pos.Num().Int64()
+			if posNum < 0 || posNum >= int64(len(buf)) {
+				return nil, ArErr{
+					TYPE:    "Index Error",
+					message: "index out of range",
+					EXISTS:  true,
+				}
+			}
+			return ArByte(buf[posNum]), ArErr{}
+		},
+	}
+	obj.obj["remove"] = builtinFunc{
+		"remove",
+		func(a ...any) (any, ArErr) {
+			if len(a) != 1 {
+				return nil, ArErr{
+					TYPE:    "Type Error",
+					message: "expected 1 argument, got " + fmt.Sprint(len(a)),
+					EXISTS:  true,
+				}
+			}
+			poss := ArValidToAny(a[0])
+			if typeof(poss) != "number" {
+				return nil, ArErr{
+					TYPE:    "Type Error",
+					message: "expected number, got " + typeof(poss),
+					EXISTS:  true,
+				}
+			}
+			pos := poss.(number)
+			if pos.Denom().Cmp(one.Denom()) != 0 {
+				return nil, ArErr{
+					TYPE:    "Type Error",
 					message: "position must be an integer",
 					EXISTS:  true,
 				}
@@ -497,7 +540,6 @@ func ArBuffer(buf []byte) ArObject {
 			posNum := pos.Num().Int64()
 			buf = append(buf[:posNum], buf[posNum+1:]...)
 			obj.obj["__value__"] = buf
-			obj.obj["length"] = newNumber().SetInt64(int64(len(buf)))
 			return obj, ArErr{}
 		},
 	}

src/built-ins.go

@@ -9,8 +9,10 @@ func makeGlobal() ArObject {
 	var vars = anymap{}
 	vars["global"] = vars
 	vars["env"] = env
+	vars["platform"] = platform
 	vars["term"] = ArTerm
 	vars["ArgonVersion"] = ArString(VERSION)
+	vars["ArgonVersionNumber"] = newNumber().SetInt64(VERSION_NUM)
 	vars["number"] = builtinFunc{"number", ArgonNumber}
 	vars["string"] = builtinFunc{"string", ArgonString}
 	vars["socket"] = Map(anymap{
@@ -18,6 +20,7 @@ func makeGlobal() ArObject {
 		"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 {
 			return Map(anymap{}), ArErr{}
@@ -32,7 +35,7 @@ func makeGlobal() ArObject {
 					case []any:
 						if len(y) == 2 {
 							if isUnhashable(y[0]) {
-								return nil, ArErr{TYPE: "TypeError", message: "Cannot use unhashable value as key: " + typeof(y[0]), EXISTS: true}
+								return nil, ArErr{TYPE: "Type Error", message: "Cannot use unhashable value as key: " + typeof(y[0]), EXISTS: true}
 							}
 							key := ArValidToAny(y[0])
 							newmap[key] = y[1]
@@ -49,31 +52,42 @@ func makeGlobal() ArObject {
 				}
 				return Map(newmap), ArErr{}
 			}
-			return x, ArErr{}
+
+			newmap := anymap{}
+			for key, val := range x.obj {
+				newmap[key] = val
 			}
-		return nil, ArErr{TYPE: "TypeError", message: "Cannot create map from '" + typeof(a[0]) + "'", EXISTS: true}
+			return Map(newmap), ArErr{}
+		}
+		return nil, ArErr{TYPE: "Type Error", message: "Cannot create map from '" + typeof(a[0]) + "'", EXISTS: true}
 	}}
 	vars["hex"] = builtinFunc{"hex", func(a ...any) (any, ArErr) {
 		if len(a) != 1 {
-			return nil, ArErr{TYPE: "TypeError", message: "expected 1 argument, got " + fmt.Sprint(len(a)), EXISTS: true}
+			return nil, ArErr{TYPE: "Type Error", message: "expected 1 argument, got " + fmt.Sprint(len(a)), EXISTS: true}
 		}
 		a[0] = ArValidToAny(a[0])
 		switch x := a[0].(type) {
 		case number:
 			if x.Denom().Cmp(one.Denom()) != 0 {
-				return nil, ArErr{TYPE: "TypeError", message: "Cannot convert non-integer to hex", EXISTS: true}
+				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{}
 		}
-		return nil, ArErr{TYPE: "TypeError", message: "Cannot convert '" + typeof(a[0]) + "' to hex", EXISTS: true}
+		return nil, ArErr{TYPE: "Type Error", message: "Cannot convert '" + typeof(a[0]) + "' to hex", EXISTS: true}
 	}}
 	vars["buffer"] = builtinFunc{"buffer", func(a ...any) (any, ArErr) {
 		if len(a) != 0 {
-			return nil, ArErr{TYPE: "TypeError", message: "expected 0 arguments, got " + fmt.Sprint(len(a)), EXISTS: true}
+			return nil, ArErr{TYPE: "Type Error", message: "expected 0 arguments, got " + fmt.Sprint(len(a)), EXISTS: true}
 		}
 		return ArBuffer([]byte{}), ArErr{}
 	}}
+	vars["byte"] = builtinFunc{"byte", func(a ...any) (any, ArErr) {
+		if len(a) != 0 {
+			return nil, ArErr{TYPE: "Type Error", message: "expected 0 arguments, got " + fmt.Sprint(len(a)), EXISTS: true}
+		}
+		return ArByte(0), ArErr{}
+	}}
 	vars["throwError"] = builtinFunc{"throwError", ArThrowError}
 	vars["array"] = builtinFunc{"array", func(a ...any) (any, ArErr) {
 		if len(a) == 0 {
@@ -97,7 +111,7 @@ func makeGlobal() ArObject {
 			}
 			return ArArray(newarray), ArErr{}
 		}
-		return nil, ArErr{TYPE: "TypeError", message: "Cannot create array from '" + typeof(a[0]) + "'", EXISTS: true}
+		return nil, ArErr{TYPE: "Type Error", message: "Cannot create array from '" + typeof(a[0]) + "'", EXISTS: true}
 	}}
 	vars["boolean"] = builtinFunc{"boolean", func(a ...any) (any, ArErr) {
 		if len(a) == 0 {
@@ -124,11 +138,11 @@ func makeGlobal() ArObject {
 			switch x := a[1].(type) {
 			case number:
 				if !x.IsInt() {
-					return nil, ArErr{TYPE: "TypeError", message: "Cannot round to '" + typeof(a[1]) + "'", EXISTS: true}
+					return nil, ArErr{TYPE: "Type Error", message: "Cannot round to '" + typeof(a[1]) + "'", EXISTS: true}
 				}
 				precision = x
 			default:
-				return nil, ArErr{TYPE: "TypeError", message: "Cannot round to '" + typeof(a[1]) + "'", EXISTS: true}
+				return nil, ArErr{TYPE: "Type Error", message: "Cannot round to '" + typeof(a[1]) + "'", EXISTS: true}
 			}
 		}
 
@@ -136,7 +150,7 @@ func makeGlobal() ArObject {
 		case number:
 			return round(newNumber().Set(x), int(precision.Num().Int64())), ArErr{}
 		}
-		return nil, ArErr{TYPE: "TypeError", message: "Cannot round '" + typeof(a[0]) + "'", EXISTS: true}
+		return nil, ArErr{TYPE: "Type Error", message: "Cannot round '" + typeof(a[0]) + "'", EXISTS: true}
 	}}
 	vars["floor"] = builtinFunc{"floor", func(a ...any) (any, ArErr) {
 		if len(a) == 0 {
@@ -147,7 +161,7 @@ func makeGlobal() ArObject {
 		case number:
 			return floor(x), ArErr{}
 		}
-		return nil, ArErr{TYPE: "TypeError", message: "Cannot floor '" + typeof(a[0]) + "'", EXISTS: true}
+		return nil, ArErr{TYPE: "Type Error", message: "Cannot floor '" + typeof(a[0]) + "'", EXISTS: true}
 	}}
 	vars["ceil"] = builtinFunc{"ceil", func(a ...any) (any, ArErr) {
 		if len(a) == 0 {
@@ -159,7 +173,7 @@ func makeGlobal() ArObject {
 		case number:
 			return ceil(x), ArErr{}
 		}
-		return nil, ArErr{TYPE: "TypeError", message: "Cannot ceil '" + typeof(a[0]) + "'", EXISTS: true}
+		return nil, ArErr{TYPE: "Type Error", message: "Cannot ceil '" + typeof(a[0]) + "'", EXISTS: true}
 	}}
 	vars["sqrt"] = builtinFunc{"sqrt", ArgonSqrt}
 	vars["file"] = ArFile
@@ -205,7 +219,7 @@ func makeGlobal() ArObject {
 				return resp, ArErr{}
 			}
 		}
-		return nil, ArErr{TYPE: "TypeError", message: "Cannot fraction '" + typeof(a[0]) + "'", EXISTS: true}
+		return nil, ArErr{TYPE: "Type Error", message: "Cannot fraction '" + typeof(a[0]) + "'", EXISTS: true}
 	}}
 	vars["dir"] = builtinFunc{"dir", func(a ...any) (any, ArErr) {
 		if len(a) == 0 {
@@ -224,7 +238,7 @@ func makeGlobal() ArObject {
 	}}
 	vars["subprocess"] = builtinFunc{"subprocess", ArSubprocess}
 	vars["sequence"] = builtinFunc{"sequence", ArSequence}
-	vars["|"] = builtinFunc{"exit", func(a ...any) (any, ArErr) {
+	vars["exit"] = builtinFunc{"exit", func(a ...any) (any, ArErr) {
 		if len(a) == 0 {
 			os.Exit(0)
 		}
@@ -243,7 +257,7 @@ func makeGlobal() ArObject {
 		case number:
 			return string([]rune{rune(floor(x).Num().Int64())}), ArErr{}
 		}
-		return nil, ArErr{TYPE: "TypeError", message: "Cannot convert '" + typeof(a[0]) + "' to string", EXISTS: true}
+		return nil, ArErr{TYPE: "Type Error", message: "Cannot convert '" + typeof(a[0]) + "' to string", EXISTS: true}
 	}}
 	vars["ord"] = builtinFunc{"ord", func(a ...any) (any, ArErr) {
 		if len(a) != 1 {
@@ -253,11 +267,11 @@ func makeGlobal() ArObject {
 		switch x := a[0].(type) {
 		case string:
 			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 nil, ArErr{TYPE: "ord", message: "ord takes a string with only one character, got " + fmt.Sprint(len(x)), EXISTS: true}
 			}
 			return floor(newNumber().SetInt64(int64([]rune(x)[0]))), ArErr{}
 		}
-		return nil, ArErr{TYPE: "TypeError", message: "Cannot convert '" + typeof(a[0]) + "' to string", EXISTS: true}
+		return nil, ArErr{TYPE: "Type Error", message: "Cannot convert '" + typeof(a[0]) + "' to string", EXISTS: true}
 	}}
 	vars["max"] = builtinFunc{"max", func(a ...any) (any, ArErr) {
 		if len(a) != 1 {
@@ -284,7 +298,7 @@ func makeGlobal() ArObject {
 			}
 			return max, ArErr{}
 		}
-		return nil, ArErr{TYPE: "TypeError", message: "Cannot get max of type '" + typeof(a[0]) + "'", EXISTS: true}
+		return nil, ArErr{TYPE: "Type Error", message: "Cannot get max of type '" + typeof(a[0]) + "'", EXISTS: true}
 	}}
 	vars["min"] = builtinFunc{"min", func(a ...any) (any, ArErr) {
 		if len(a) != 1 {
@@ -311,7 +325,7 @@ func makeGlobal() ArObject {
 			}
 			return max, ArErr{}
 		}
-		return nil, ArErr{TYPE: "TypeError", message: "Cannot get max of type '" + typeof(a[0]) + "'", EXISTS: true}
+		return nil, ArErr{TYPE: "Type Error", message: "Cannot get max of type '" + typeof(a[0]) + "'", EXISTS: true}
 	}}
 	vars["path"] = ArPath
 	vars["typeof"] = builtinFunc{"typeof", func(a ...any) (any, ArErr) {
@@ -329,7 +343,7 @@ func makeGlobal() ArObject {
 		case string:
 			return ArString(sha256Hash(x)), ArErr{}
 		}
-		return nil, ArErr{TYPE: "TypeError", message: "Cannot hash type '" + typeof(a[0]) + "'", EXISTS: true}
+		return nil, ArErr{TYPE: "Type Error", message: "Cannot hash type '" + typeof(a[0]) + "'", EXISTS: true}
 	}}
 	return Map(vars)
 }

src/colour.go

@@ -12,7 +12,7 @@ var ArColour = Map(
 		"set": builtinFunc{"set", func(a ...any) (any, ArErr) {
 			if len(a) != 2 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "set() takes exactly 2 argument (" + fmt.Sprint(len(a)) + " given)",
 					EXISTS:  true,
 				}
@@ -23,7 +23,7 @@ var ArColour = Map(
 				c = color.Set(color.Attribute(x.Num().Int64()))
 			} else {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "set() argument 1 must be an number, not " + typeof(a[0]),
 					EXISTS:  true,
 				}
@@ -32,7 +32,7 @@ var ArColour = Map(
 				s = ArValidToAny(a[1]).(string)
 			} else {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "set() argument 2 must be a string, not " + typeof(a[1]),
 					EXISTS:  true,
 				}

src/dowraps.go

@@ -20,11 +20,11 @@ func isDoWrap(code UNPARSEcode) bool {
 func parseDoWrap(code UNPARSEcode, index int, codelines []UNPARSEcode) (any, bool, ArErr, int) {
 	currentindent := len(code.realcode) - len(strings.TrimLeft(code.realcode, " "))
 	var setindent int = -1
-	var i = index + 1
+	var allCodelines = []UNPARSEcode{}
-	translated := []any{}
+	i := index + 1
-	for i < len(codelines) {
+	for ; i < len(codelines); i++ {
+
 		if isBlank(codelines[i]) {
-			i++
 			continue
 		}
 		indent := len(codelines[i].code) - len(strings.TrimLeft(codelines[i].code, " "))
@@ -34,8 +34,15 @@ func parseDoWrap(code UNPARSEcode, index int, codelines []UNPARSEcode) (any, boo
 		if indent <= currentindent {
 			break
 		}
+		allCodelines = append(allCodelines, codelines[i])
+	}
+	finalLines := i
+	codelines = allCodelines
+	translated := []any{}
+	for i := 0; i < len(codelines); {
+		indent := len(codelines[i].code) - len(strings.TrimLeft(codelines[i].code, " "))
 		if indent != setindent {
-			return nil, false, ArErr{"Syntax Error", "invalid indent", i, code.path, codelines[i].code, true}, 1
+			return nil, false, ArErr{"Syntax Error", "invalid indent", code.line, code.path, codelines[i].code, true}, 1
 		}
 
 		val, _, err, step := translateVal(codelines[i], i, codelines, 3)
@@ -45,13 +52,15 @@ func parseDoWrap(code UNPARSEcode, index int, codelines []UNPARSEcode) (any, boo
 		}
 		translated = append(translated, val)
 	}
-	return dowrap{run: translated, line: code.line, path: code.path, code: code.realcode}, true, ArErr{}, i - index
+	return dowrap{run: translated, line: code.line, path: code.path, code: code.realcode}, true, ArErr{}, finalLines - index
 }
 
-func runDoWrap(d dowrap, stack stack, stacklevel int) (any, ArErr) {
+func runDoWrap(d dowrap, Stack stack, stacklevel int) (any, ArErr) {
-	newstack := append(stack, newscope())
+	newstack := append(Stack, newscope())
+	newstackCopy := make(stack, len(newstack))
+	copy(newstackCopy, newstack)
 	for _, v := range d.run {
-		val, err := runVal(v, newstack, stacklevel+1)
+		val, err := runVal(v, newstackCopy, stacklevel+1)
 		if err.EXISTS {
 			return nil, err
 		}

src/error.go

@@ -16,19 +16,19 @@ type ArErr struct {
 func ArThrowError(a ...any) (any, ArErr) {
 	if len(a) != 2 {
 		return nil, ArErr{
-			TYPE:    "TypeError",
+			TYPE:    "Type Error",
 			message: "throwError takes 2 arguments, " + fmt.Sprint(len(a)) + " given",
 			EXISTS:  true,
 		}
 	} else if typeof(a[0]) != "string" {
 		return nil, ArErr{
-			TYPE:    "TypeError",
+			TYPE:    "Type Error",
 			message: "throwError type must be a string",
 			EXISTS:  true,
 		}
 	} else if typeof(a[1]) != "string" {
 		return nil, ArErr{
-			TYPE:    "TypeError",
+			TYPE:    "Type Error",
 			message: "throwError message must be a string",
 			EXISTS:  true,
 		}

src/eval_function.go

@@ -0,0 +1,41 @@
+package main
+
+import "fmt"
+
+func AReval(a ...any) (any, ArErr) {
+	if len(a) < 1 || len(a) > 2 {
+		return nil, ArErr{TYPE: "Type Error", message: "expected 1 or 2 argument, got " + fmt.Sprint(len(a)), EXISTS: true}
+	}
+	var expression string
+	if typeof(a[0]) != "string" {
+		return nil, ArErr{TYPE: "Type Error", message: "expected string as first argument, got " + typeof(a[0]), EXISTS: true}
+	}
+	expression = ArValidToAny(a[0]).(string)
+
+	// translate the expression
+	var code UNPARSEcode = UNPARSEcode{
+		code:     expression,
+		realcode: expression,
+		line:     0,
+		path:     "eval",
+	}
+	translated, err := translate([]UNPARSEcode{code})
+	if err.EXISTS {
+		return nil, err
+	}
+
+	var scope ArObject
+	if len(a) == 2 {
+		if typeof(a[1]) != "map" {
+			return nil, ArErr{TYPE: "Type Error", message: "expected map as second argument, got " + typeof(a[1]), EXISTS: true}
+		}
+		scope = a[1].(ArObject)
+	} else {
+		scope = newscope()
+	}
+
+	var stack stack = []ArObject{scope}
+
+	// run the translated expression
+	return run(translated, stack)
+}

src/file.go

@@ -12,8 +12,73 @@ import (
 var ArFile = Map(anymap{
 	"read":  builtinFunc{"read", ArRead},
 	"write": builtinFunc{"write", ArWrite},
+	"move":  builtinFunc{"move", ARmoveFile},
+	"copy":  builtinFunc{"copy", ARcopyFile},
 })
 
+func ARmoveFile(args ...any) (any, ArErr) {
+	if len(args) != 2 {
+		return ArObject{}, ArErr{TYPE: "Runtime Error", message: "move takes 2 arguments, got " + fmt.Sprint(len(args)), EXISTS: true}
+	}
+	if typeof(args[0]) != "string" {
+		return ArObject{}, ArErr{TYPE: "Runtime Error", message: "move takes a string not type '" + typeof(args[0]) + "'", EXISTS: true}
+	}
+	if typeof(args[1]) != "string" {
+		return ArObject{}, ArErr{TYPE: "Runtime Error", message: "move takes a string not type '" + typeof(args[1]) + "'", EXISTS: true}
+	}
+	args[0] = ArValidToAny(args[0])
+	args[1] = ArValidToAny(args[1])
+	err := os.Rename(args[0].(string), args[1].(string))
+	if err != nil {
+		return ArObject{}, ArErr{TYPE: "Runtime Error", message: err.Error(), EXISTS: true}
+	}
+	return nil, ArErr{}
+}
+
+func copyFile(src, dst string) (int64, error) {
+	sourceFileStat, err := os.Stat(src)
+	if err != nil {
+		return 0, err
+	}
+
+	if !sourceFileStat.Mode().IsRegular() {
+		return 0, fmt.Errorf("%s is not a regular file", src)
+	}
+
+	source, err := os.Open(src)
+	if err != nil {
+		return 0, err
+	}
+	defer source.Close()
+
+	destination, err := os.Create(dst)
+	if err != nil {
+		return 0, err
+	}
+	defer destination.Close()
+	nBytes, err := io.Copy(destination, source)
+	return nBytes, err
+}
+
+func ARcopyFile(args ...any) (any, ArErr) {
+	if len(args) != 2 {
+		return ArObject{}, ArErr{TYPE: "Runtime Error", message: "copy takes 2 arguments, got " + fmt.Sprint(len(args)), EXISTS: true}
+	}
+	if typeof(args[0]) != "string" {
+		return ArObject{}, ArErr{TYPE: "Runtime Error", message: "copy takes a string not type '" + typeof(args[0]) + "'", EXISTS: true}
+	}
+	if typeof(args[1]) != "string" {
+		return ArObject{}, ArErr{TYPE: "Runtime Error", message: "copy takes a string not type '" + typeof(args[1]) + "'", EXISTS: true}
+	}
+	args[0] = ArValidToAny(args[0])
+	args[1] = ArValidToAny(args[1])
+	_, err := copyFile(args[0].(string), args[1].(string))
+	if err != nil {
+		return ArObject{}, ArErr{TYPE: "Runtime Error", message: err.Error(), EXISTS: true}
+	}
+	return nil, ArErr{}
+}
+
 func readtext(file *os.File) (string, error) {
 	var buf bytes.Buffer
 	_, err := io.Copy(&buf, file)
@@ -70,7 +135,7 @@ func ArRead(args ...any) (any, ArErr) {
 			if err != nil {
 				return ArObject{}, ArErr{TYPE: "Runtime Error", message: err.Error(), EXISTS: true}
 			}
-			return jsonparse(text), ArErr{}
+			return jsonparse(text)
 		}},
 		"contentType": builtinFunc{"contentType", func(...any) (any, ArErr) {
 			file.Seek(0, io.SeekStart)

src/forloop.go

@@ -63,7 +63,7 @@ func parseForLoop(code UNPARSEcode, index int, codelines []UNPARSEcode) (forLoop
 		}
 		innertotalstep += tostep - 1
 		body := strings.Join(tosplit[i:], ")")
-		bodyval, worked, err, bodystep := translateVal(UNPARSEcode{code: body, realcode: code.realcode, line: code.line, path: code.path}, index, codelines, 1)
+		bodyval, worked, err, bodystep := translateVal(UNPARSEcode{code: body, realcode: code.realcode, line: code.line, path: code.path}, index, codelines, 3)
 		if !worked {
 			if i == 0 {
 				return forLoop{}, worked, err, bodystep

src/getIndex.go

@@ -51,7 +51,7 @@ func mapGet(r ArMapGet, stack stack, stacklevel int) (any, ArErr) {
 		return nil, err
 	}
 	return nil, ArErr{
-		"TypeError",
+		"Type Error",
 		"cannot read " + anyToArgon(key, true, true, 3, 0, false, 0) + " from type '" + typeof(resp) + "'",
 		r.Line,
 		r.Path,

src/ifstatement.go

@@ -32,6 +32,7 @@ func parseIfStatement(code UNPARSEcode, index int, codeline []UNPARSEcode) (ifst
 	conditions := []statement{}
 	var ELSE any
 	i := index
+	codeline[i] = code
 	for i < len(codeline) && (elseifstatmentCompile.MatchString(codeline[i].code) || i == index) {
 		trimmed := strings.TrimSpace(codeline[i].code)
 		trimmed = strings.TrimSpace(trimmed[strings.Index(trimmed, "("):])
@@ -69,7 +70,7 @@ func parseIfStatement(code UNPARSEcode, index int, codeline []UNPARSEcode) (ifst
 				},
 				i,
 				codeline,
-				2,
+				3,
 			)
 			if err.EXISTS || !worked {
 				return ifstatement{}, worked, err, step
@@ -98,7 +99,7 @@ func parseIfStatement(code UNPARSEcode, index int, codeline []UNPARSEcode) (ifst
 			},
 			i,
 			codeline,
-			2,
+			3,
 		)
 		if err.EXISTS {
 			return ifstatement{}, false, err, step

src/import.go

@@ -7,6 +7,7 @@ import (
 )
 
 var imported = make(map[string]ArObject)
+var translatedImports = make(map[string]translatedImport)
 var importing = make(map[string]bool)
 
 const modules_folder = "argon_modules"
@@ -41,67 +42,31 @@ func readFile(path string) ([]UNPARSEcode, error) {
 	return output, nil
 }
 
-func importMod(realpath string, origin string, main bool, global ArObject) (ArObject, ArErr) {
+type translatedImport struct {
-	extention := filepath.Ext(realpath)
+	translated []any
-	path := realpath
+	p          string
-	if extention == "" {
+	path       string
-		path += ".ar"
+	origin     string
-	}
+}
-	ex, err := os.Getwd()
+
-	if err != nil {
+var runTranslatedImport func(translatedImport, ArObject, bool) (ArObject, ArErr)
-		return ArObject{}, ArErr{TYPE: "Import Error", message: "Could not get working directory", EXISTS: true}
+var ex string
-	}
+var exc string
-	exc, err := os.Executable()
+var exc_dir string
-	if err != nil {
+
-		return ArObject{}, ArErr{TYPE: "Import Error", message: "Could not get executable", EXISTS: true}
+func init() {
-	}
+	runTranslatedImport = __runTranslatedImport
-	executable := filepath.Dir(exc)
+	ex, _ = os.Getwd()
-	isABS := filepath.IsAbs(path)
+	exc, _ = os.Executable()
-	var pathsToTest []string
+	exc_dir = filepath.Dir(exc)
-	if isABS {
+}
-		pathsToTest = []string{
+
-			filepath.Join(path),
+func __runTranslatedImport(translatedImport translatedImport, global ArObject, main bool) (ArObject, ArErr) {
-			filepath.Join(realpath, "init.ar"),
+
-		}
+	if _, ok := imported[translatedImport.p]; ok {
-	} else {
+		return imported[translatedImport.p], ArErr{}
-		pathsToTest = []string{
-			filepath.Join(origin, path),
-			filepath.Join(origin, realpath, "init.ar"),
-			filepath.Join(origin, modules_folder, path),
-			filepath.Join(origin, modules_folder, realpath, "init.ar"),
-			filepath.Join(ex, path),
-			filepath.Join(ex, modules_folder, path),
-			filepath.Join(ex, modules_folder, realpath, "init.ar"),
-			filepath.Join(executable, modules_folder, path),
-			filepath.Join(executable, modules_folder, realpath, "init.ar"),
-		}
-	}
-	var p string
-	var found bool
-	for _, p = range pathsToTest {
-		if FileExists(p) {
-			found = true
-			break
-		}
 	}
 
-	if !found {
-		return ArObject{}, ArErr{TYPE: "Import Error", message: "File does not exist: " + path, EXISTS: true}
-	} else if importing[p] {
-		return ArObject{}, ArErr{TYPE: "Import Error", message: "Circular import: " + path, EXISTS: true}
-	} else if _, ok := imported[p]; ok {
-		return imported[p], ArErr{}
-	}
-	importing[p] = true
-	codelines, err := readFile(p)
-	if err != nil {
-		return ArObject{}, ArErr{TYPE: "Import Error", message: "Could not read file: " + path, EXISTS: true}
-	}
-	translated, translationerr := translate(codelines)
-
-	if translationerr.EXISTS {
-		return ArObject{}, translationerr
-	}
 	ArgsArArray := []any{}
 	withoutarfile := []string{}
 	if len(Args) > 1 {
@@ -114,30 +79,90 @@ func importMod(realpath string, origin string, main bool, global ArObject) (ArOb
 	localvars := Map(anymap{
 		"program": Map(anymap{
 			"args":   ArArray(ArgsArArray),
-			"origin": ArString(origin),
+			"origin": ArString(translatedImport.origin),
-			"import": builtinFunc{"import", func(args ...any) (any, ArErr) {
-				if len(args) != 1 {
-					return nil, ArErr{"Import Error", "Invalid number of arguments", 0, realpath, "", true}
-				}
-				if _, ok := args[0].(string); !ok {
-					return nil, ArErr{"Import Error", "Invalid argument type", 0, realpath, "", true}
-				}
-				return importMod(args[0].(string), filepath.Dir(filepath.ToSlash(p)), false, global)
-			}},
 			"cwd":    ArString(ex),
 			"exc":    ArString(exc),
 			"file": Map(anymap{
-				"name": ArString(filepath.Base(p)),
+				"name": ArString(filepath.Base(translatedImport.p)),
-				"path": ArString(p),
+				"path": ArString(translatedImport.p),
 			}),
 			"main": main,
 		}),
 	})
-	_, runimeErr := run(translated, stack{global, localvars, local})
+	imported[translatedImport.p] = local
-	importing[p] = false
+	_, runimeErr := run(translatedImport.translated, stack{global, localvars, local})
 	if runimeErr.EXISTS {
 		return ArObject{}, runimeErr
 	}
-	imported[p] = local
 	return local, ArErr{}
 }
+
+func translateImport(realpath string, origin string, topLevelOnly bool) (translatedImport, ArErr) {
+	extention := filepath.Ext(realpath)
+	path := realpath
+	if extention == "" {
+		path += ".ar"
+	}
+	isABS := filepath.IsAbs(path)
+	var pathsToTest []string
+	if isABS {
+		pathsToTest = []string{
+			filepath.Join(path),
+			filepath.Join(realpath, "init.ar"),
+		}
+	} else {
+		pathsToTest = []string{
+			filepath.Join(exc_dir, path),
+			filepath.Join(exc_dir, realpath, "init.ar"),
+			filepath.Join(exc_dir, modules_folder, path),
+			filepath.Join(exc_dir, modules_folder, realpath, "init.ar"),
+		}
+		var currentPath string = origin
+		var oldPath string = ""
+		for currentPath != oldPath {
+			pathsToTest = append(pathsToTest,
+				filepath.Join(currentPath, path),
+				filepath.Join(currentPath, realpath, "init.ar"),
+				filepath.Join(currentPath, modules_folder, path),
+				filepath.Join(currentPath, modules_folder, realpath, "init.ar"))
+			if topLevelOnly {
+				break
+			}
+			oldPath = currentPath
+			currentPath = filepath.Dir(currentPath)
+		}
+	}
+	var p string
+	var found bool
+	for _, p = range pathsToTest {
+		if FileExists(p) {
+			found = true
+			break
+		}
+	}
+
+	if !found {
+		return translatedImport{}, ArErr{TYPE: "Import Error", message: "File does not exist: " + path, EXISTS: true}
+	} else if importing[p] {
+		return translatedImport{}, ArErr{TYPE: "Import Error", message: "Circular import: " + path, EXISTS: true}
+	} else if _, ok := translatedImports[p]; ok {
+		return translatedImports[p], ArErr{}
+	}
+	importing[p] = true
+	codelines, err := readFile(p)
+	if err != nil {
+		return translatedImport{}, ArErr{TYPE: "Import Error", message: "Could not read file: " + path, EXISTS: true}
+	}
+
+	importing[p] = true
+	translated, translationerr := translate(codelines)
+	debugPrintln(translated...)
+	importing[p] = false
+
+	if translationerr.EXISTS {
+		return translatedImport{}, translationerr
+	}
+
+	translatedImports[p] = translatedImport{translated, p, path, origin}
+	return translatedImports[p], ArErr{}
+}

src/input.go

@@ -1,63 +1,13 @@
 package main
 
 import (
-	"bufio"
 	"fmt"
 	"os"
 
 	"golang.org/x/term"
 )
 
-func input(args ...any) string {
+var tempFilePath = os.TempDir() + "/argon_input_history.tmp"
-	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
-}
-
-func getPassword(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...)
-	password := []byte{}
-
-	oldState, err := term.MakeRaw(int(os.Stdin.Fd()))
-	if err != nil {
-		panic(err)
-	}
-	defer term.Restore(int(os.Stdin.Fd()), oldState)
-
-	for {
-		char := make([]byte, 1)
-		_, err := os.Stdin.Read(char)
-		if err != nil {
-			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
-}
 
 func pause() {
 	fmt.Print("Press Enter to continue...")

src/input_unix.go

@@ -0,0 +1,55 @@
+//go:build !WINDOWS
+// +build !WINDOWS
+
+package main
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/chzyer/readline"
+)
+
+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))
+	}
+	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) {
+	output := []any{}
+	for i := 0; i < len(args); i++ {
+		output = append(output, anyToArgon(args[i], false, true, 3, 0, true, 0))
+	}
+	message := fmt.Sprint(output...)
+	rl, err := readline.NewEx(&readline.Config{
+		Prompt:     message,
+		MaskRune:   '*',
+		EnableMask: 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
+}

src/input_windows.go

@@ -0,0 +1,63 @@
+//go:build WINDOWS
+// +build WINDOWS
+
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+
+	"golang.org/x/term"
+)
+
+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, nil
+}
+
+func getPassword(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...)
+	password := []byte{}
+
+	oldState, err := term.MakeRaw(int(os.Stdin.Fd()))
+	if err != nil {
+		panic(err)
+	}
+	defer term.Restore(int(os.Stdin.Fd()), oldState)
+
+	for {
+		char := make([]byte, 1)
+		_, err := os.Stdin.Read(char)
+		if err != nil {
+			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
+}

src/json.go

@@ -33,10 +33,11 @@ func convertToArgon(obj any) any {
 	return nil
 }
 
-func jsonparse(str string) any {
+func jsonparse(str string) (any, ArErr) {
 	var jsonMap any
-	json.Unmarshal([]byte(str), &jsonMap)
+	var err = json.Unmarshal([]byte(str), &jsonMap)
-	return convertToArgon(jsonMap)
+	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) {
@@ -90,7 +91,7 @@ var ArJSON = Map(anymap{
 			return nil, ArErr{TYPE: "Runtime Error", message: "parse takes a string not a '" + typeof(args[0]) + "'", EXISTS: true}
 		}
 		args[0] = ArValidToAny(args[0])
-		return jsonparse(args[0].(string)), ArErr{}
+		return jsonparse(args[0].(string))
 	}},
 	"stringify": builtinFunc{"stringify", func(args ...any) (any, ArErr) {
 		if len(args) == 0 {

src/main.go

@@ -10,13 +10,8 @@ var Args = os.Args[1:]
 
 type stack = []ArObject
 
-const VERSION = "3.0.1"
+const VERSION = "3.0.11"
-
+const VERSION_NUM = 9
-// Example struct
-type Person struct {
-	Name string
-	Age  int
-}
 
 func newscope() ArObject {
 	return Map(anymap{})
@@ -61,12 +56,15 @@ func main() {
 	if e != nil {
 		panic(e)
 	}
-	_, err := importMod(Args[0], ex, true, global)
+	translated, err := translateImport(Args[0], ex, true)
 	if err.EXISTS {
 		panicErr(err)
 		os.Exit(1)
 	}
-	if threadCount > 0 {
+	_, runimeErr := runTranslatedImport(translated, global, true)
-		<-threadChan
+	if runimeErr.EXISTS {
+		panicErr(runimeErr)
+		os.Exit(1)
 	}
+	threadChan.Wait()
 }

src/map.go

@@ -36,7 +36,7 @@ func runCreateMap(m createMap, stack stack, stacklevel int) (any, ArErr) {
 		}
 		if isUnhashable(keyVal) {
 			return nil, ArErr{
-				"TypeError",
+				"Type Error",
 				"unhashable type: '" + typeof(keyVal) + "'",
 				m.line,
 				m.path,
@@ -114,18 +114,17 @@ func parseMap(code UNPARSEcode, index int, codelines []UNPARSEcode) (any, bool,
 	}, true, ArErr{}, countIndex
 }
 
-var mutex = sync.RWMutex{}
-var listenersMutex = sync.RWMutex{}
-
 func Map(m anymap) ArObject {
+	var mutex = sync.RWMutex{}
+	var listenersMutex = sync.RWMutex{}
 	var currentID uint32 = 0
 	listeners := map[any]map[uint32]any{}
 	obj := ArObject{
 		obj: anymap{
 			"__value__": m,
 			"__name__":  "map",
-			"get": builtinFunc{
+			"get_value": builtinFunc{
-				"get",
+				"get_value",
 				func(args ...any) (any, ArErr) {
 					if len(args) < 1 || len(args) > 2 {
 						return nil, ArErr{
@@ -161,7 +160,7 @@ func Map(m anymap) ArObject {
 				func(args ...any) (any, ArErr) {
 					if len(args) != 1 {
 						return nil, ArErr{
-							TYPE:    "TypeError",
+							TYPE:    "Type Error",
 							message: "expected 1 argument, got " + fmt.Sprint(len(args)),
 							EXISTS:  true,
 						}
@@ -201,7 +200,7 @@ func Map(m anymap) ArObject {
 				func(args ...any) (any, ArErr) {
 					if len(args) != 1 {
 						return nil, ArErr{
-							TYPE:    "TypeError",
+							TYPE:    "Type Error",
 							message: "expected 1 argument, got " + fmt.Sprint(len(args)),
 							EXISTS:  true,
 						}
@@ -241,7 +240,7 @@ func Map(m anymap) ArObject {
 				func(args ...any) (any, ArErr) {
 					if len(args) != 2 {
 						return nil, ArErr{
-							TYPE:    "TypeError",
+							TYPE:    "Type Error",
 							message: "expected 2 arguments, got " + fmt.Sprint(len(args)),
 							EXISTS:  true,
 						}
@@ -274,12 +273,60 @@ func Map(m anymap) ArObject {
 					return nil, ArErr{}
 				},
 			},
+			"__deleteindex__": builtinFunc{
+				"__deleteindex__",
+				func(args ...any) (any, ArErr) {
+					if len(args) != 1 {
+						return nil, ArErr{
+							TYPE:    "Type Error",
+							message: "expected 1 argument, got " + fmt.Sprint(len(args)),
+							EXISTS:  true,
+						}
+					}
+					if isUnhashable(args[0]) {
+						return nil, ArErr{
+							TYPE:    "Runtime Error",
+							message: "unhashable type: " + typeof(args[0]),
+							EXISTS:  true,
+						}
+					}
+					key := ArValidToAny(args[0])
+					mutex.RLock()
+					if _, ok := m[key]; !ok {
+						mutex.RUnlock()
+						return nil, ArErr{
+							TYPE:    "KeyError",
+							message: "key " + fmt.Sprint(key) + " not found",
+							EXISTS:  true,
+						}
+					}
+					mutex.RUnlock()
+					listenersMutex.RLock()
+					if _, ok := listeners[key]; ok {
+						for _, v := range listeners[key] {
+							runCall(
+								call{
+									Callable: v,
+									Args:     []any{},
+								},
+								stack{},
+								0,
+							)
+						}
+					}
+					listenersMutex.RUnlock()
+					mutex.Lock()
+					delete(m, key)
+					mutex.Unlock()
+					return nil, ArErr{}
+				},
+			},
 			"__getindex__": builtinFunc{
 				"__getindex__",
 				func(args ...any) (any, ArErr) {
 					if len(args) != 1 {
 						return nil, ArErr{
-							TYPE:    "TypeError",
+							TYPE:    "Type Error",
 							message: "expected 1 argument, got " + fmt.Sprint(len(args)),
 							EXISTS:  true,
 						}
@@ -330,7 +377,7 @@ func Map(m anymap) ArObject {
 			debugPrintln("Equal", args)
 			if len(args) != 1 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected 1 argument, got " + fmt.Sprint(len(args)),
 					EXISTS:  true,
 				}
@@ -372,7 +419,7 @@ func Map(m anymap) ArObject {
 			debugPrintln("copy", args)
 			if len(args) != 0 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected 0 arguments, got " + fmt.Sprint(len(args)),
 					EXISTS:  true,
 				}
@@ -391,7 +438,7 @@ func Map(m anymap) ArObject {
 		func(args ...any) (any, ArErr) {
 			if len(args) != 2 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected 2 arguments, got " + fmt.Sprint(len(args)),
 					EXISTS:  true,
 				}
@@ -406,7 +453,7 @@ func Map(m anymap) ArObject {
 			}
 			if typeof(args[1]) != "function" {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected function, got " + typeof(args[1]),
 					EXISTS:  true,
 				}
@@ -425,7 +472,7 @@ func Map(m anymap) ArObject {
 					func(args ...any) (any, ArErr) {
 						if len(args) != 0 {
 							return nil, ArErr{
-								TYPE:    "TypeError",
+								TYPE:    "Type Error",
 								message: "expected 0 arguments, got " + fmt.Sprint(len(args)),
 								EXISTS:  true,
 							}
@@ -444,7 +491,7 @@ func Map(m anymap) ArObject {
 		func(args ...any) (any, ArErr) {
 			if len(args) != 0 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected 0 arguments, got " + fmt.Sprint(len(args)),
 					EXISTS:  true,
 				}
@@ -458,6 +505,7 @@ func Map(m anymap) ArObject {
 			return ArArray(keys), ArErr{}
 		},
 	}
+
 	obj.obj["__Boolean__"] = builtinFunc{
 		"__Boolean__",
 		func(args ...any) (any, ArErr) {
@@ -475,7 +523,7 @@ func Map(m anymap) ArObject {
 		func(args ...any) (any, ArErr) {
 			if len(args) != 0 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "expected 0 arguments, got " + fmt.Sprint(len(args)),
 					EXISTS:  true,
 				}

src/operations.go

@@ -20,8 +20,8 @@ var operations = []string{
 	"==",
 	"+",
 	"-",
-	"*",
 	"%",
+	"*",
 	"//",
 	"/",
 	"^",
@@ -82,7 +82,7 @@ func parseOperations(code UNPARSEcode, index int, codelines []UNPARSEcode) (oper
 				operation: i,
 				values:    values,
 				line:      code.line,
-				code:      code.code,
+				code:      code.realcode,
 				path:      code.path,
 			}, true, ArErr{}, totalStep
 		}
@@ -680,7 +680,7 @@ func equals(a any, b any, o operationType, stack stack, stacklevel int) (bool, A
 		}
 	}
 	if x, ok := b.(ArObject); ok {
-		if y, ok := x.obj["__GreaterThanEqual__"]; ok {
+		if y, ok := x.obj["__Equal__"]; ok {
 			val, err := runCall(
 				call{
 					y,
@@ -918,9 +918,9 @@ func runOperation(o operationType, stack stack, stacklevel int) (any, ArErr) {
 	case 11:
 		return calcNegative(o, stack, stacklevel+1)
 	case 12:
-		return calcMul(o, stack, stacklevel+1)
-	case 13:
 		return calcMod(o, stack, stacklevel+1)
+	case 13:
+		return calcMul(o, stack, stacklevel+1)
 	case 14:
 		return calcIntDiv(o, stack, stacklevel+1)
 	case 15:

src/parseImport.go

@@ -5,9 +5,11 @@ import (
 	"strings"
 )
 
-var genericImportCompiled = makeRegex(`import( )+(.|\n)+(( )+as( )+([a-zA-Z_]|(\p{L}\p{M}*))([a-zA-Z0-9_]|(\p{L}\p{M}*))*)?( *)`)
+var genericImportCompiled = makeRegex(`( *)import( )+(.|\n)+(( )+as( )+([a-zA-Z_]|(\p{L}\p{M}*))([a-zA-Z0-9_]|(\p{L}\p{M}*))*)?( *)`)
 
 type ArImport struct {
+	pretranslated bool
+	translated    translatedImport
 	FilePath      any
 	Values        any
 	Code          string
@@ -67,16 +69,30 @@ func parseGenericImport(code UNPARSEcode, index int, codeline []UNPARSEcode) (Ar
 		}
 	}
 
-	return ArImport{
+	importOBJ := ArImport{
+		false,
+		translatedImport{},
 		toImport,
 		asStr,
 		code.realcode,
 		code.line,
 		code.path,
-	}, true, ArErr{}, i
+	}
+
+	if str, ok := toImport.(string); ok {
+		resp, err := translateImport(str, filepath.Dir(filepath.ToSlash(code.path)), false)
+		if !err.EXISTS {
+			importOBJ.translated = resp
+			importOBJ.pretranslated = true
+		}
+	}
+
+	return importOBJ, true, ArErr{}, i
 }
 
 func runImport(importOBJ ArImport, stack stack, stacklevel int) (any, ArErr) {
+	var translated = importOBJ.translated
+	if !importOBJ.pretranslated {
 		val, err := runVal(importOBJ.FilePath, stack, stacklevel+1)
 		val = ArValidToAny(val)
 		if err.EXISTS {
@@ -85,9 +101,22 @@ func runImport(importOBJ ArImport, stack stack, stacklevel int) (any, ArErr) {
 		if typeof(val) != "string" {
 			return nil, ArErr{"Type Error", "import requires a string, got type '" + typeof(val) + "'", importOBJ.Line, importOBJ.Path, importOBJ.Code, true}
 		}
-	path := val.(string)
 		parent := filepath.Dir(filepath.ToSlash(importOBJ.Path))
-	stackMap, err := importMod(path, parent, false, stack[0])
+		translated, err = translateImport(val.(string), parent, false)
+		if err.EXISTS {
+			if err.line == 0 {
+				err.line = importOBJ.Line
+			}
+			if err.path == "" {
+				err.path = importOBJ.Path
+			}
+			if err.code == "" {
+				err.code = importOBJ.Code
+			}
+			return nil, err
+		}
+	}
+	stackMap, err := runTranslatedImport(translated, stack[0], false)
 	if err.EXISTS {
 		if err.line == 0 {
 			err.line = importOBJ.Line
@@ -116,7 +145,7 @@ func runImport(importOBJ ArImport, stack stack, stacklevel int) (any, ArErr) {
 		for _, v := range x {
 			val, ok := stackMap.obj[v]
 			if !ok {
-				return nil, ArErr{"Import Error", "could not find value " + anyToArgon(v, true, false, 3, 0, false, 0) + " in module " + anyToArgon(path, true, false, 3, 0, false, 0), importOBJ.Line, importOBJ.Path, importOBJ.Code, true}
+				return nil, ArErr{"Import Error", "could not find value " + anyToArgon(v, true, false, 3, 0, false, 0) + " in module " + anyToArgon(translated.path, true, false, 3, 0, false, 0), importOBJ.Line, importOBJ.Path, importOBJ.Code, true}
 			}
 			builtinCall(setindex, []any{v, val})
 		}

src/path.go

@@ -14,7 +14,7 @@ var ArPath = Map(
 			func(args ...any) (any, ArErr) {
 				if len(args) != 1 {
 					return nil, ArErr{
-						TYPE:    "runtime",
+						TYPE:    "Runtime Error",
 						message: "ReadDir takes exactly 1 argument, got " + fmt.Sprint(len(args)),
 						EXISTS:  true,
 					}
@@ -22,7 +22,7 @@ var ArPath = Map(
 				args[0] = ArValidToAny(args[0])
 				if typeof(args[0]) != "string" {
 					return nil, ArErr{
-						TYPE:    "runtime",
+						TYPE:    "Runtime Error",
 						message: "ReadDir argument must be a string, got " + typeof(args[0]),
 						EXISTS:  true,
 					}
@@ -30,7 +30,7 @@ var ArPath = Map(
 				files, err := os.ReadDir(args[0].(string))
 				if err != nil {
 					return nil, ArErr{
-						TYPE:    "runtime",
+						TYPE:    "Runtime Error",
 						message: err.Error(),
 						EXISTS:  true,
 					}
@@ -46,7 +46,7 @@ var ArPath = Map(
 			func(args ...any) (any, ArErr) {
 				if len(args) != 1 {
 					return nil, ArErr{
-						TYPE:    "runtime",
+						TYPE:    "Runtime Error",
 						message: "exists takes exactly 1 argument, got " + fmt.Sprint(len(args)),
 						EXISTS:  true,
 					}
@@ -54,7 +54,7 @@ var ArPath = Map(
 				args[0] = ArValidToAny(args[0])
 				if typeof(args[0]) != "string" {
 					return nil, ArErr{
-						TYPE:    "runtime",
+						TYPE:    "Runtime Error",
 						message: "exists argument must be a string, got " + typeof(args[0]),
 						EXISTS:  true,
 					}
@@ -65,7 +65,7 @@ var ArPath = Map(
 						return false, ArErr{}
 					}
 					return nil, ArErr{
-						TYPE:    "runtime",
+						TYPE:    "Runtime Error",
 						message: err.Error(),
 						EXISTS:  true,
 					}
@@ -77,7 +77,7 @@ var ArPath = Map(
 			func(args ...any) (any, ArErr) {
 				if len(args) != 1 {
 					return nil, ArErr{
-						TYPE:    "runtime",
+						TYPE:    "Runtime Error",
 						message: "mkAllDir takes exactly 1 argument, got " + fmt.Sprint(len(args)),
 						EXISTS:  true,
 					}
@@ -85,7 +85,7 @@ var ArPath = Map(
 				args[0] = ArValidToAny(args[0])
 				if typeof(args[0]) != "string" {
 					return nil, ArErr{
-						TYPE:    "runtime",
+						TYPE:    "Runtime Error",
 						message: "mkAllDir argument must be a string, got " + typeof(args[0]),
 						EXISTS:  true,
 					}
@@ -93,7 +93,7 @@ var ArPath = Map(
 				err := os.MkdirAll(args[0].(string), os.ModePerm)
 				if err != nil {
 					return nil, ArErr{
-						TYPE:    "runtime",
+						TYPE:    "Runtime Error",
 						message: err.Error(),
 						EXISTS:  true,
 					}
@@ -105,7 +105,7 @@ var ArPath = Map(
 			func(args ...any) (any, ArErr) {
 				if len(args) != 1 {
 					return nil, ArErr{
-						TYPE:    "runtime",
+						TYPE:    "Runtime Error",
 						message: "mkDir takes exactly 1 argument, got " + fmt.Sprint(len(args)),
 						EXISTS:  true,
 					}
@@ -113,7 +113,7 @@ var ArPath = Map(
 				args[0] = ArValidToAny(args[0])
 				if typeof(args[0]) != "string" {
 					return nil, ArErr{
-						TYPE:    "runtime",
+						TYPE:    "Runtime Error",
 						message: "mkDir argument must be a string, got " + typeof(args[0]),
 						EXISTS:  true,
 					}
@@ -121,7 +121,7 @@ var ArPath = Map(
 				err := os.Mkdir(args[0].(string), os.ModePerm)
 				if err != nil {
 					return nil, ArErr{
-						TYPE:    "runtime",
+						TYPE:    "Runtime Error",
 						message: err.Error(),
 						EXISTS:  true,
 					}
@@ -133,7 +133,7 @@ var ArPath = Map(
 			func(args ...any) (any, ArErr) {
 				if len(args) != 1 {
 					return nil, ArErr{
-						TYPE:    "runtime",
+						TYPE:    "Runtime Error",
 						message: "remove takes exactly 1 argument, got " + fmt.Sprint(len(args)),
 						EXISTS:  true,
 					}
@@ -141,7 +141,7 @@ var ArPath = Map(
 				args[0] = ArValidToAny(args[0])
 				if typeof(args[0]) != "string" {
 					return nil, ArErr{
-						TYPE:    "runtime",
+						TYPE:    "Runtime Error",
 						message: "remove argument must be a string, got " + typeof(args[0]),
 						EXISTS:  true,
 					}
@@ -149,7 +149,7 @@ var ArPath = Map(
 				err := os.Remove(args[0].(string))
 				if err != nil {
 					return nil, ArErr{
-						TYPE:    "runtime",
+						TYPE:    "Runtime Error",
 						message: err.Error(),
 						EXISTS:  true,
 					}
@@ -161,7 +161,7 @@ var ArPath = Map(
 			func(args ...any) (any, ArErr) {
 				if len(args) != 1 {
 					return nil, ArErr{
-						TYPE:    "runtime",
+						TYPE:    "Runtime Error",
 						message: "isDir takes exactly 1 argument, got " + fmt.Sprint(len(args)),
 						EXISTS:  true,
 					}
@@ -169,7 +169,7 @@ var ArPath = Map(
 				args[0] = ArValidToAny(args[0])
 				if typeof(args[0]) != "string" {
 					return nil, ArErr{
-						TYPE:    "runtime",
+						TYPE:    "Runtime Error",
 						message: "isDir argument must be a string, got " + typeof(args[0]),
 						EXISTS:  true,
 					}
@@ -180,7 +180,7 @@ var ArPath = Map(
 						return false, ArErr{}
 					}
 					return nil, ArErr{
-						TYPE:    "runtime",
+						TYPE:    "Runtime Error",
 						message: err.Error(),
 						EXISTS:  true,
 					}
@@ -192,7 +192,7 @@ var ArPath = Map(
 			func(args ...any) (any, ArErr) {
 				if len(args) != 1 {
 					return nil, ArErr{
-						TYPE:    "runtime",
+						TYPE:    "Runtime Error",
 						message: "join takes exactly 1 argument, got " + fmt.Sprint(len(args)),
 						EXISTS:  true,
 					}
@@ -205,7 +205,7 @@ var ArPath = Map(
 						x = ArValidToAny(x)
 						if typeof(x) != "string" {
 							return nil, ArErr{
-								TYPE:    "runtime",
+								TYPE:    "Runtime Error",
 								message: "join argument must be an array of strings, got " + typeof(x),
 								EXISTS:  true,
 							}
@@ -215,7 +215,7 @@ var ArPath = Map(
 					return filepath.Join(Path...), ArErr{}
 				}
 				return nil, ArErr{
-					TYPE:    "runtime",
+					TYPE:    "Runtime Error",
 					message: "join argument must be an array, got " + typeof(args[0]),
 					EXISTS:  true,
 				}
@@ -225,7 +225,7 @@ var ArPath = Map(
 			func(args ...any) (any, ArErr) {
 				if len(args) != 1 {
 					return nil, ArErr{
-						TYPE:    "runtime",
+						TYPE:    "Runtime Error",
 						message: "parent takes exactly 1 argument, got " + fmt.Sprint(len(args)),
 						EXISTS:  true,
 					}
@@ -233,7 +233,7 @@ var ArPath = Map(
 				args[0] = ArValidToAny(args[0])
 				if typeof(args[0]) != "string" {
 					return nil, ArErr{
-						TYPE:    "runtime",
+						TYPE:    "Runtime Error",
 						message: "parent argument must be a string, got " + typeof(args[0]),
 						EXISTS:  true,
 					}

src/platform.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+	"fmt"
+	"runtime"
+	"time"
+
+	"github.com/shirou/gopsutil/cpu"
+)
+
+var platform = Map(
+	anymap{
+		"os": ArString(runtime.GOOS),
+
+		"cpu": Map(anymap{
+			"count": newNumber().SetInt64((int64)(runtime.NumCPU())),
+			"usage": builtinFunc{"usage", func(args ...any) (any, ArErr) {
+				if len(args) != 2 {
+					return nil, ArErr{
+						TYPE:    "Runtime Error",
+						message: "usage takes 2 arguments, got " + fmt.Sprint(len(args)),
+						EXISTS:  true,
+					}
+				}
+				if !isAnyNumber(args[0]) {
+					return nil, ArErr{
+						TYPE:    "Runtime Error",
+						message: "first argument is meant to be a number, got " + fmt.Sprint(typeof(args[0])),
+						EXISTS:  true,
+					}
+				}
+				var Number = newNumber().Mul(args[0].(number), newNumber().SetInt64(1000)).Num().Int64()
+				avgPercent, err := cpu.Percent(time.Duration(Number)*time.Millisecond, anyToBool(args[1]))
+				if err != nil {
+					return nil, ArErr{
+						TYPE:    "Runtime Error",
+						message: err.Error(),
+						EXISTS:  true,
+					}
+				}
+				var ArAvgPercent = []any{}
+				for i := 0; i < len(avgPercent); i++ {
+					ArAvgPercent = append(ArAvgPercent, newNumber().SetFloat64(avgPercent[i]))
+				}
+				return ArArray(ArAvgPercent), ArErr{}
+			}},
+		}),
+	},
+)

src/run.go

@@ -76,18 +76,10 @@ func runVal(line any, stack stack, stacklevel int) (any, ArErr) {
 			return y, ArErr{}
 		}
 		return nil, ArErr{
-			TYPE:    "TypeError",
+			TYPE:    "Type Error",
 			message: "cannot negate a non-number",
 			EXISTS:  true,
 		}
-	case brackets:
-		if stackoverflow {
-			linenum = x.line
-			path = x.path
-			code = x.code
-			break
-		}
-		return runVal(x.VAL, stack, stacklevel+1)
 	case operationType:
 		if stackoverflow {
 			linenum = x.line

src/shell.go

@@ -14,12 +14,12 @@ func shell(global ArObject) {
 	go func() {
 		for sig := range c {
 			if sig == os.Interrupt {
-				fmt.Println("\x1b[0m\n\x1b[32;5;240mBye :)\x1b[0m")
+				fmt.Println("\x1b[0m\n\x1b[32;240mBye :)\x1b[0m")
 				os.Exit(0)
 			}
 		}
 	}()
-	fmt.Print("\x1b[32;5;240mWelcome to the Argon v3!\x1b[0m\n\n")
+	fmt.Print("\x1b[32;240mWelcome to the Argon v3!\x1b[0m\n\n")
 	for {
 		indent := 0
 		previous := 0
@@ -27,13 +27,17 @@ 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")
+			inp, err := input("\x1b[38;240m" + textBefore + indentStr + " \x1b[0m")
+			if err != nil {
+				fmt.Println("\x1b[0m\n\x1b[32;240mBye :)\x1b[0m")
+				os.Exit(0)
+			}
+			code := indentStr + inp
 			fmt.Print("\x1b[0m")
 			totranslate = append(totranslate, UNPARSEcode{code, code, i, "<shell>"})
 			trimmed := strings.TrimSpace(code)
-			split := strings.Split(trimmed, " ")
 			previous = indent
-			if split[len(split)-1] == "do" {
+			if len(trimmed) >= 2 && trimmed[len(trimmed)-2:] == "do" {
 				indent++
 			} else if trimmed == "" {
 				indent--

src/socket.go

@@ -10,19 +10,19 @@ import (
 func ArSocketClient(args ...any) (any, ArErr) {
 	if len(args) != 2 {
 		return ArObject{}, ArErr{
-			TYPE:    "SocketError",
+			TYPE:    "Socket Error",
 			message: "Socket takes exactly 2 arguments",
 			EXISTS:  true,
 		}
 	} else if typeof(args[0]) != "string" {
 		return ArObject{}, ArErr{
-			TYPE:    "SocketError",
+			TYPE:    "Socket Error",
 			message: "Socket type must be a string",
 			EXISTS:  true,
 		}
 	} else if typeof(args[1]) != "string" {
 		return ArObject{}, ArErr{
-			TYPE:    "SocketError",
+			TYPE:    "Socket Error",
 			message: "Socket address must be a string",
 			EXISTS:  true,
 		}
@@ -32,7 +32,7 @@ func ArSocketClient(args ...any) (any, ArErr) {
 	conn, err := net.Dial(networktype, address)
 	if err != nil {
 		return ArObject{}, ArErr{
-			TYPE:    "SocketError",
+			TYPE:    "Socket Error",
 			message: fmt.Sprintf("Socket connection failed: %s", err.Error()),
 			EXISTS:  true,
 		}
@@ -44,14 +44,14 @@ func ArSocketClient(args ...any) (any, ArErr) {
 				func(args ...any) (any, ArErr) {
 					if len(args) != 1 {
 						return ArObject{}, ArErr{
-							TYPE:    "SocketError",
+							TYPE:    "Socket Error",
 							message: "Socket.readData() takes exactly 1 argument",
 							EXISTS:  true,
 						}
 					}
 					if conn == nil {
 						return ArObject{}, ArErr{
-							TYPE:    "SocketError",
+							TYPE:    "Socket Error",
 							message: "Connection is closed",
 							EXISTS:  true,
 						}
@@ -60,7 +60,7 @@ func ArSocketClient(args ...any) (any, ArErr) {
 					n, err := conn.Read(buf)
 					if err != nil {
 						return ArObject{}, ArErr{
-							TYPE:    "SocketError",
+							TYPE:    "Socket Error",
 							message: fmt.Sprintf("Socket read failed: %s", err.Error()),
 							EXISTS:  true,
 						}
@@ -72,14 +72,14 @@ func ArSocketClient(args ...any) (any, ArErr) {
 				func(args ...any) (any, ArErr) {
 					if len(args) != 1 {
 						return ArObject{}, ArErr{
-							TYPE:    "SocketError",
+							TYPE:    "Socket Error",
 							message: "Socket.readUntil() takes exactly 1 argument",
 							EXISTS:  true,
 						}
 					}
 					if conn == nil {
 						return ArObject{}, ArErr{
-							TYPE:    "SocketError",
+							TYPE:    "Socket Error",
 							message: "Connection is closed",
 							EXISTS:  true,
 						}
@@ -87,7 +87,7 @@ func ArSocketClient(args ...any) (any, ArErr) {
 					value := ArValidToAny(args[0])
 					if typeof(value) != "buffer" {
 						return ArObject{}, ArErr{
-							TYPE:    "TypeError",
+							TYPE:    "Type Error",
 							message: fmt.Sprintf("Socket.readUntil() argument must be a buffer, not %s", typeof(value)),
 							EXISTS:  true,
 						}
@@ -100,7 +100,7 @@ func ArSocketClient(args ...any) (any, ArErr) {
 						_, err := reader.Read(buf)
 						if err != nil {
 							return ArObject{}, ArErr{
-								TYPE:    "SocketError",
+								TYPE:    "Socket Error",
 								message: fmt.Sprintf("Socket read failed: %s", err.Error()),
 								EXISTS:  true,
 							}
@@ -125,21 +125,21 @@ func ArSocketClient(args ...any) (any, ArErr) {
 				func(args ...any) (any, ArErr) {
 					if len(args) != 1 {
 						return nil, ArErr{
-							TYPE:    "TypeError",
+							TYPE:    "Type Error",
 							message: fmt.Sprintf("write() takes exactly 1 argument (%d given)", len(args)),
 							EXISTS:  true,
 						}
 					}
 					if typeof(args[0]) != "buffer" {
 						return ArObject{}, ArErr{
-							TYPE:    "TypeError",
+							TYPE:    "Type Error",
 							message: fmt.Sprintf("write() argument must be a buffer, not %s", typeof(args[0])),
 							EXISTS:  true,
 						}
 					}
 					if conn == nil {
 						return ArObject{}, ArErr{
-							TYPE:    "SocketError",
+							TYPE:    "Socket Error",
 							message: "Connection is closed",
 							EXISTS:  true,
 						}
@@ -147,7 +147,7 @@ func ArSocketClient(args ...any) (any, ArErr) {
 					args[0] = ArValidToAny(args[0])
 					if typeof(args[0]) != "buffer" {
 						return ArObject{}, ArErr{
-							TYPE:    "TypeError",
+							TYPE:    "Type Error",
 							message: fmt.Sprintf("write() argument must be a buffer, not %s", typeof(args[0])),
 							EXISTS:  true,
 						}
@@ -155,7 +155,7 @@ func ArSocketClient(args ...any) (any, ArErr) {
 					_, err := conn.Write(args[0].([]byte))
 					if err != nil {
 						return ArObject{}, ArErr{
-							TYPE:    "SocketError",
+							TYPE:    "Socket Error",
 							message: err.Error(),
 							EXISTS:  true,
 						}
@@ -167,7 +167,7 @@ func ArSocketClient(args ...any) (any, ArErr) {
 				func(args ...any) (any, ArErr) {
 					if conn == nil {
 						return ArObject{}, ArErr{
-							TYPE:    "SocketError",
+							TYPE:    "Socket Error",
 							message: "Connection is already closed",
 							EXISTS:  true,
 						}
@@ -175,7 +175,7 @@ func ArSocketClient(args ...any) (any, ArErr) {
 					err := conn.Close()
 					if err != nil {
 						return ArObject{}, ArErr{
-							TYPE:    "SocketError",
+							TYPE:    "Socket Error",
 							message: err.Error(),
 							EXISTS:  true,
 						}
@@ -208,19 +208,19 @@ func ArSocketClient(args ...any) (any, ArErr) {
 func ArSocketServer(args ...any) (any, ArErr) {
 	if len(args) != 2 {
 		return ArObject{}, ArErr{
-			TYPE:    "SocketError",
+			TYPE:    "Socket Error",
 			message: "Socket takes exactly 2 arguments",
 			EXISTS:  true,
 		}
 	} else if typeof(args[0]) != "string" {
 		return ArObject{}, ArErr{
-			TYPE:    "SocketError",
+			TYPE:    "Socket Error",
 			message: "Socket type must be a string",
 			EXISTS:  true,
 		}
 	} else if typeof(args[1]) != "number" {
 		return ArObject{}, ArErr{
-			TYPE:    "SocketError",
+			TYPE:    "Socket Error",
 			message: "Socket port must be a number",
 			EXISTS:  true,
 		}
@@ -229,7 +229,7 @@ func ArSocketServer(args ...any) (any, ArErr) {
 	port := args[1].(number)
 	if port.Denom().Int64() != 1 {
 		return ArObject{}, ArErr{
-			TYPE:    "SocketError",
+			TYPE:    "Socket Error",
 			message: "Socket port must be an integer",
 			EXISTS:  true,
 		}
@@ -237,7 +237,7 @@ func ArSocketServer(args ...any) (any, ArErr) {
 	ln, err := net.Listen(networktype, ":"+fmt.Sprint(port.Num().Int64()))
 	if err != nil {
 		return ArObject{}, ArErr{
-			TYPE:    "SocketError",
+			TYPE:    "Socket Error",
 			message: err.Error(),
 			EXISTS:  true,
 		}
@@ -248,7 +248,7 @@ func ArSocketServer(args ...any) (any, ArErr) {
 			func(args ...any) (any, ArErr) {
 				if ln == nil {
 					return ArObject{}, ArErr{
-						TYPE:    "SocketError",
+						TYPE:    "Socket Error",
 						message: "Socket is closed",
 						EXISTS:  true,
 					}
@@ -256,7 +256,7 @@ func ArSocketServer(args ...any) (any, ArErr) {
 				conn, err := ln.Accept()
 				if err != nil {
 					return ArObject{}, ArErr{
-						TYPE:    "SocketError",
+						TYPE:    "Socket Error",
 						message: err.Error(),
 						EXISTS:  true,
 					}
@@ -267,14 +267,14 @@ func ArSocketServer(args ...any) (any, ArErr) {
 						func(args ...any) (any, ArErr) {
 							if len(args) != 1 {
 								return ArObject{}, ArErr{
-									TYPE:    "SocketError",
+									TYPE:    "Socket Error",
 									message: "Socket.readData() takes exactly 1 argument",
 									EXISTS:  true,
 								}
 							}
 							if conn == nil {
 								return ArObject{}, ArErr{
-									TYPE:    "SocketError",
+									TYPE:    "Socket Error",
 									message: "Connection is closed",
 									EXISTS:  true,
 								}
@@ -283,7 +283,7 @@ func ArSocketServer(args ...any) (any, ArErr) {
 							n, err := conn.Read(buf)
 							if err != nil {
 								return ArObject{}, ArErr{
-									TYPE:    "SocketError",
+									TYPE:    "Socket Error",
 									message: err.Error(),
 									EXISTS:  true,
 								}
@@ -296,14 +296,14 @@ func ArSocketServer(args ...any) (any, ArErr) {
 						func(args ...any) (any, ArErr) {
 							if len(args) != 1 {
 								return ArObject{}, ArErr{
-									TYPE:    "SocketError",
+									TYPE:    "Socket Error",
 									message: "Socket.readUntil() takes exactly 1 argument",
 									EXISTS:  true,
 								}
 							}
 							if conn == nil {
 								return ArObject{}, ArErr{
-									TYPE:    "SocketError",
+									TYPE:    "Socket Error",
 									message: "Connection is closed",
 									EXISTS:  true,
 								}
@@ -311,7 +311,7 @@ func ArSocketServer(args ...any) (any, ArErr) {
 							value := ArValidToAny(args[0])
 							if typeof(value) != "buffer" {
 								return ArObject{}, ArErr{
-									TYPE:    "TypeError",
+									TYPE:    "Type Error",
 									message: fmt.Sprintf("Socket.readUntil() argument must be a buffer, not %s", typeof(value)),
 									EXISTS:  true,
 								}
@@ -346,14 +346,14 @@ func ArSocketServer(args ...any) (any, ArErr) {
 						func(args ...any) (any, ArErr) {
 							if len(args) != 0 {
 								return ArObject{}, ArErr{
-									TYPE:    "SocketError",
+									TYPE:    "Socket Error",
 									message: "Socket.clearTimeout() takes exactly 0 arguments",
 									EXISTS:  true,
 								}
 							}
 							if conn == nil {
 								return ArObject{}, ArErr{
-									TYPE:    "SocketError",
+									TYPE:    "Socket Error",
 									message: "Connection is closed",
 									EXISTS:  true,
 								}
@@ -367,21 +367,21 @@ func ArSocketServer(args ...any) (any, ArErr) {
 						func(args ...any) (any, ArErr) {
 							if len(args) != 1 {
 								return ArObject{}, ArErr{
-									TYPE:    "SocketError",
+									TYPE:    "Socket Error",
 									message: "Socket.setTimeout() takes exactly 1 argument",
 									EXISTS:  true,
 								}
 							}
 							if typeof(args[0]) != "number" {
 								return ArObject{}, ArErr{
-									TYPE:    "SocketError",
+									TYPE:    "Socket Error",
 									message: "Socket timeout must be a number",
 									EXISTS:  true,
 								}
 							}
 							if conn == nil {
 								return ArObject{}, ArErr{
-									TYPE:    "SocketError",
+									TYPE:    "Socket Error",
 									message: "Connection is closed",
 									EXISTS:  true,
 								}
@@ -389,7 +389,7 @@ func ArSocketServer(args ...any) (any, ArErr) {
 							timeout := args[0].(number)
 							if timeout.Denom().Int64() != 1 {
 								return ArObject{}, ArErr{
-									TYPE:    "SocketError",
+									TYPE:    "Socket Error",
 									message: "Socket timeout must be an integer",
 									EXISTS:  true,
 								}
@@ -397,7 +397,7 @@ func ArSocketServer(args ...any) (any, ArErr) {
 							err := conn.SetDeadline(time.Now().Add(time.Duration(timeout.Num().Int64()) * time.Millisecond))
 							if err != nil {
 								return ArObject{}, ArErr{
-									TYPE:    "SocketError",
+									TYPE:    "Socket Error",
 									message: err.Error(),
 									EXISTS:  true,
 								}
@@ -410,14 +410,14 @@ func ArSocketServer(args ...any) (any, ArErr) {
 						func(args ...any) (any, ArErr) {
 							if len(args) != 1 {
 								return ArObject{}, ArErr{
-									TYPE:    "SocketError",
+									TYPE:    "Socket Error",
 									message: "Socket.writeData() takes exactly 1 argument",
 									EXISTS:  true,
 								}
 							}
 							if conn == nil {
 								return ArObject{}, ArErr{
-									TYPE:    "SocketError",
+									TYPE:    "Socket Error",
 									message: "Connection is closed",
 									EXISTS:  true,
 								}
@@ -429,7 +429,7 @@ func ArSocketServer(args ...any) (any, ArErr) {
 								for _, v := range x {
 									if typeof(v) != "number" && v.(number).Denom().Int64() != 1 {
 										return ArObject{}, ArErr{
-											TYPE:    "SocketError",
+											TYPE:    "Socket Error",
 											message: "Socket.writeData() argument must be a array of integers",
 											EXISTS:  true,
 										}
@@ -443,7 +443,7 @@ func ArSocketServer(args ...any) (any, ArErr) {
 								return nil, ArErr{}
 							}
 							return nil, ArErr{
-								TYPE:    "SocketError",
+								TYPE:    "Socket Error",
 								message: "Socket.writeData() argument must be a array of numbers",
 							}
 						},
@@ -453,7 +453,7 @@ func ArSocketServer(args ...any) (any, ArErr) {
 						func(args ...any) (any, ArErr) {
 							if conn == nil {
 								return ArObject{}, ArErr{
-									TYPE:    "SocketError",
+									TYPE:    "Socket Error",
 									message: "Connection is already closed",
 									EXISTS:  true,
 								}
@@ -486,7 +486,7 @@ func ArSocketServer(args ...any) (any, ArErr) {
 						func(args ...any) (any, ArErr) {
 							if conn == nil {
 								return ArObject{}, ArErr{
-									TYPE:    "SocketError",
+									TYPE:    "Socket Error",
 									message: "Connection is closed",
 									EXISTS:  true,
 								}
@@ -508,7 +508,7 @@ func ArSocketServer(args ...any) (any, ArErr) {
 			func(args ...any) (any, ArErr) {
 				if ln == nil {
 					return ArObject{}, ArErr{
-						TYPE:    "SocketError",
+						TYPE:    "Socket Error",
 						message: "Socket is already closed",
 						EXISTS:  true,
 					}

src/string.go

@@ -65,7 +65,6 @@ func ArString(str string) ArObject {
 		anymap{
 			"__value__": str,
 			"__name__":  "string",
-			"length":    newNumber().SetUint64(uint64(len(str))),
 		},
 	}
 
@@ -73,30 +72,29 @@ func ArString(str string) ArObject {
 		"__setindex__",
 		func(a ...any) (any, ArErr) {
 			if len(a) != 2 {
-				return nil, ArErr{"TypeError", "expected 2 arguments, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 2 arguments, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			if typeof(a[0]) != "number" {
-				return nil, ArErr{"TypeError", "expected number, got " + typeof(a[0]), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected number, got " + typeof(a[0]), 0, "", "", true}
 			}
 			if typeof(a[1]) != "string" {
-				return nil, ArErr{"TypeError", "expected string, got " + typeof(a[1]), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected string, got " + typeof(a[1]), 0, "", "", true}
 			}
 			if len(a[1].(string)) != 1 {
-				return nil, ArErr{"TypeError", "expected string of length 1, got " + fmt.Sprint(len(a[1].(string))), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected string of length 1, got " + fmt.Sprint(len(a[1].(string))), 0, "", "", true}
 			}
 			if !a[0].(number).IsInt() {
-				return nil, ArErr{"TypeError", "expected integer, got float", 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected integer, got float", 0, "", "", true}
 			}
 			index := a[0].(number).Num().Int64()
 			if index < 0 {
 				index = int64(len(str)) + index
 			}
 			if index < 0 || index >= int64(len(str)) {
-				return nil, ArErr{"IndexError", "index out of range", 0, "", "", true}
+				return nil, ArErr{"Index Error", "index out of range", 0, "", "", true}
 			}
 			str = strings.Join([]string{str[:index], a[1].(string), str[index+1:]}, "")
 			obj.obj["__value__"] = str
-			obj.obj["length"] = newNumber().SetUint64(uint64(len(str)))
 			return nil, ArErr{}
 		}}
 	obj.obj["__getindex__"] = builtinFunc{
@@ -105,8 +103,18 @@ func ArString(str string) ArObject {
 			// a[0] is start
 			// a[1] is end
 			// a[2] is step
-			if len(a) > 3 {
+			if len(a) > 3 || len(a) == 0 {
-				return nil, ArErr{"TypeError", "expected 1 to 3 arguments, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 1 to 3 arguments, got " + fmt.Sprint(len(a)), 0, "", "", true}
+			}
+			{
+				if len(a) == 1 {
+					if typeof(a[0]) == "string" {
+						var name = ArValidToAny(a[0]).(string)
+						if name == "length" {
+							return newNumber().SetInt64(int64(len(str))), ArErr{}
+						}
+					}
+				}
 			}
 			var (
 				start int = 0
@@ -118,7 +126,7 @@ func ArString(str string) ArObject {
 					start = 0
 				} else if typeof(a[0]) != "number" || !a[0].(number).IsInt() {
 					return "", ArErr{
-						TYPE:    "TypeError",
+						TYPE:    "Type Error",
 						message: "slice index must be an integer",
 						EXISTS:  true,
 					}
@@ -131,7 +139,7 @@ func ArString(str string) ArObject {
 					end = len(str)
 				} else if typeof(a[1]) != "number" || !a[1].(number).IsInt() {
 					return "", ArErr{
-						TYPE:    "TypeError",
+						TYPE:    "Type Error",
 						message: "slice index must be an integer",
 						EXISTS:  true,
 					}
@@ -144,7 +152,7 @@ func ArString(str string) ArObject {
 					step = 1
 				} else if typeof(a[2]) != "number" || !a[2].(number).IsInt() {
 					return "", ArErr{
-						TYPE:    "TypeError",
+						TYPE:    "Type Error",
 						message: "slice index must be an integer",
 						EXISTS:  true,
 					}
@@ -184,40 +192,38 @@ func ArString(str string) ArObject {
 		"append",
 		func(a ...any) (any, ArErr) {
 			if len(a) == 0 {
-				return nil, ArErr{"TypeError", "expected 1 or more argument, got 0", 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 1 or more argument, got 0", 0, "", "", true}
 			}
 			output := []string{str}
 			for _, v := range a {
 				v = ArValidToAny(v)
 				if typeof(v) != "string" {
-					return nil, ArErr{"TypeError", "expected string, got " + typeof(v), 0, "", "", true}
+					return nil, ArErr{"Type Error", "expected string, got " + typeof(v), 0, "", "", true}
 				}
 				output = append(output, v.(string))
 			}
 			str = strings.Join(output, "")
 			obj.obj["__value__"] = str
-			obj.obj["length"] = newNumber().SetUint64(uint64(len(str)))
 			return nil, ArErr{}
 		}}
 	obj.obj["extend"] = builtinFunc{
 		"extend",
 		func(a ...any) (any, ArErr) {
 			if len(a) != 1 {
-				return nil, ArErr{"TypeError", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			if typeof(a[0]) != "array" {
-				return nil, ArErr{"TypeError", "expected array, got " + typeof(a[0]), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected array, got " + typeof(a[0]), 0, "", "", true}
 			}
 			output := []string{str}
 			for _, v := range a[0].([]any) {
 				if typeof(v) != "string" {
-					return nil, ArErr{"TypeError", "expected string, got " + typeof(v), 0, "", "", true}
+					return nil, ArErr{"Type Error", "expected string, got " + typeof(v), 0, "", "", true}
 				}
 				output = append(output, v.(string))
 			}
 			str = strings.Join(output, "")
 			obj.obj["__value__"] = str
-			obj.obj["length"] = newNumber().SetUint64(uint64(len(str)))
 			return nil, ArErr{}
 		},
 	}
@@ -225,13 +231,13 @@ func ArString(str string) ArObject {
 		"insert",
 		func(a ...any) (any, ArErr) {
 			if len(a) != 2 {
-				return nil, ArErr{"TypeError", "expected 2 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 2 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			if typeof(a[0]) != "number" || !a[0].(number).IsInt() {
-				return nil, ArErr{"TypeError", "expected integer, got " + typeof(a[0]), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected integer, got " + typeof(a[0]), 0, "", "", true}
 			}
 			if typeof(a[1]) != "string" {
-				return nil, ArErr{"TypeError", "expected string, got " + typeof(a[1]), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected string, got " + typeof(a[1]), 0, "", "", true}
 			}
 			index := int(a[0].(number).Num().Int64())
 			if index < 0 {
@@ -242,19 +248,18 @@ func ArString(str string) ArObject {
 			}
 			str = str[:index] + a[1].(string) + str[index:]
 			obj.obj["__value__"] = str
-			obj.obj["length"] = newNumber().SetUint64(uint64(len(str)))
 			return nil, ArErr{}
 		}}
 	obj.obj["concat"] = builtinFunc{
 		"concat",
 		func(a ...any) (any, ArErr) {
 			if len(a) == 0 {
-				return nil, ArErr{"TypeError", "expected 1 or more argument, got 0", 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 1 or more argument, got 0", 0, "", "", true}
 			}
 			output := []string{str}
 			for _, v := range a {
 				if typeof(v) != "string" {
-					return nil, ArErr{"TypeError", "expected string, got " + typeof(v), 0, "", "", true}
+					return nil, ArErr{"Type Error", "expected string, got " + typeof(v), 0, "", "", true}
 				}
 				output = append(output, v.(string))
 			}
@@ -264,10 +269,10 @@ func ArString(str string) ArObject {
 		"split",
 		func(a ...any) (any, ArErr) {
 			if len(a) != 1 {
-				return nil, ArErr{"TypeError", "expected 1 or more argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 1 or more argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			if typeof(a[0]) != "string" {
-				return nil, ArErr{"TypeError", "expected string, got " + typeof(a[0]), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected string, got " + typeof(a[0]), 0, "", "", true}
 			}
 			splitby := ArValidToAny(a[0]).(string)
 			output := []any{}
@@ -281,13 +286,13 @@ func ArString(str string) ArObject {
 		"splitN",
 		func(a ...any) (any, ArErr) {
 			if len(a) != 2 {
-				return nil, ArErr{"TypeError", "expected 2 or more argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 2 or more argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			if typeof(a[0]) != "string" {
-				return nil, ArErr{"TypeError", "expected string, got " + typeof(a[0]), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected string, got " + typeof(a[0]), 0, "", "", true}
 			}
 			if typeof(a[1]) != "number" || !a[1].(number).IsInt() {
-				return nil, ArErr{"TypeError", "expected integer, got " + typeof(a[1]), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected integer, got " + typeof(a[1]), 0, "", "", true}
 			}
 			splitby := ArValidToAny(a[0]).(string)
 			n := int(a[1].(number).Num().Int64())
@@ -302,7 +307,7 @@ func ArString(str string) ArObject {
 		"capitalise",
 		func(a ...any) (any, ArErr) {
 			if len(a) != 0 {
-				return nil, ArErr{"TypeError", "expected 0 arguments, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 0 arguments, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			return cases.Title(language.English).String(str), ArErr{}
 		}}
@@ -310,7 +315,7 @@ func ArString(str string) ArObject {
 		"lower",
 		func(a ...any) (any, ArErr) {
 			if len(a) != 0 {
-				return nil, ArErr{"TypeError", "expected 0 arguments, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 0 arguments, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			return strings.ToLower(str), ArErr{}
 		}}
@@ -318,7 +323,7 @@ func ArString(str string) ArObject {
 		"upper",
 		func(a ...any) (any, ArErr) {
 			if len(a) != 0 {
-				return nil, ArErr{"TypeError", "expected 0 arguments, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 0 arguments, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			return strings.ToUpper(str), ArErr{}
 		}}
@@ -326,13 +331,13 @@ func ArString(str string) ArObject {
 		"replace",
 		func(a ...any) (any, ArErr) {
 			if len(a) != 2 {
-				return nil, ArErr{"TypeError", "expected 2 arguments, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 2 arguments, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			if typeof(a[0]) != "string" {
-				return nil, ArErr{"TypeError", "expected string, got " + typeof(a[0]), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected string, got " + typeof(a[0]), 0, "", "", true}
 			}
 			if typeof(a[1]) != "string" {
-				return nil, ArErr{"TypeError", "expected string, got " + typeof(a[1]), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected string, got " + typeof(a[1]), 0, "", "", true}
 			}
 			a[0] = ArValidToAny(a[0])
 			a[1] = ArValidToAny(a[1])
@@ -342,10 +347,10 @@ func ArString(str string) ArObject {
 		"contains",
 		func(a ...any) (any, ArErr) {
 			if len(a) != 1 {
-				return nil, ArErr{"TypeError", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			if typeof(a[0]) != "string" {
-				return nil, ArErr{"TypeError", "expected string, got " + typeof(a[0]), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected string, got " + typeof(a[0]), 0, "", "", true}
 			}
 			return strings.Contains(str, a[0].(ArObject).obj["__value__"].(string)), ArErr{}
 		}}
@@ -353,10 +358,10 @@ func ArString(str string) ArObject {
 		"startswith",
 		func(a ...any) (any, ArErr) {
 			if len(a) != 1 {
-				return nil, ArErr{"TypeError", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			if typeof(a[0]) != "string" {
-				return nil, ArErr{"TypeError", "expected string, got " + typeof(a[0]), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected string, got " + typeof(a[0]), 0, "", "", true}
 			}
 			return strings.HasPrefix(str, a[0].(ArObject).obj["__value__"].(string)), ArErr{}
 		}}
@@ -364,10 +369,10 @@ func ArString(str string) ArObject {
 		"endswith",
 		func(a ...any) (any, ArErr) {
 			if len(a) != 1 {
-				return nil, ArErr{"TypeError", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			if typeof(a[0]) != "string" {
-				return nil, ArErr{"TypeError", "expected string, got " + typeof(a[0]), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected string, got " + typeof(a[0]), 0, "", "", true}
 			}
 			return strings.HasSuffix(str, a[0].(ArObject).obj["__value__"].(string)), ArErr{}
 		}}
@@ -375,10 +380,10 @@ func ArString(str string) ArObject {
 		"index",
 		func(a ...any) (any, ArErr) {
 			if len(a) != 1 {
-				return nil, ArErr{"TypeError", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			if typeof(a[0]) != "string" {
-				return nil, ArErr{"TypeError", "expected string, got " + typeof(a[0]), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected string, got " + typeof(a[0]), 0, "", "", true}
 			}
 			return strings.Index(str, a[0].(ArObject).obj["__value__"].(string)), ArErr{}
 		}}
@@ -386,10 +391,10 @@ func ArString(str string) ArObject {
 		"rindex",
 		func(a ...any) (any, ArErr) {
 			if len(a) != 1 {
-				return nil, ArErr{"TypeError", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			if typeof(a[0]) != "string" {
-				return nil, ArErr{"TypeError", "expected string, got " + typeof(a[0]), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected string, got " + typeof(a[0]), 0, "", "", true}
 			}
 			return strings.LastIndex(str, a[0].(ArObject).obj["__value__"].(string)), ArErr{}
 		}}
@@ -398,10 +403,10 @@ func ArString(str string) ArObject {
 		func(a ...any) (any, ArErr) {
 			if len(a) != 1 {
 
-				return nil, ArErr{"TypeError", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			if typeof(a[0]) != "string" {
-				return nil, ArErr{"TypeError", "expected string, got " + typeof(a[0]), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected string, got " + typeof(a[0]), 0, "", "", true}
 			}
 			return strings.Count(str, a[0].(ArObject).obj["__value__"].(string)), ArErr{}
 		}}
@@ -411,7 +416,7 @@ func ArString(str string) ArObject {
 		func(args ...any) (any, ArErr) {
 			if len(args) > 2 {
 				return nil, ArErr{
-					TYPE:    "TypeError",
+					TYPE:    "Type Error",
 					message: "too many arguments",
 					EXISTS:  true,
 				}
@@ -420,7 +425,7 @@ func ArString(str string) ArObject {
 			if len(args) >= 1 {
 				if typeof(args[0]) != "boolean" {
 					return nil, ArErr{
-						TYPE:    "TypeError",
+						TYPE:    "Type Error",
 						message: "argument must be a boolean",
 						EXISTS:  true,
 					}
@@ -435,7 +440,7 @@ func ArString(str string) ArObject {
 			if len(args) == 2 {
 				if typeof(args[1]) != "function" {
 					return nil, ArErr{
-						TYPE:    "TypeError",
+						TYPE:    "Type Error",
 						message: "argument must be a function",
 						EXISTS:  true,
 					}
@@ -454,7 +459,6 @@ func ArString(str string) ArObject {
 					bytes[i] = b.(byte)
 				}
 				str = string(bytes)
-				obj.obj["length"] = newNumber().SetUint64(uint64(len(str)))
 				obj.obj["__value__"] = str
 				return nil, ArErr{}
 			}
@@ -474,7 +478,6 @@ func ArString(str string) ArObject {
 				bytes[i] = b.(byte)
 			}
 			str = string(bytes)
-			obj.obj["length"] = newNumber().SetUint64(uint64(len(str)))
 			obj.obj["__value__"] = str
 			return nil, ArErr{}
 		},
@@ -483,12 +486,12 @@ func ArString(str string) ArObject {
 		"strip",
 		func(a ...any) (any, ArErr) {
 			if len(a) > 1 {
-				return nil, ArErr{"TypeError", "expected 0 or 1 arguments, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 0 or 1 arguments, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			cutset := " "
 			if len(a) == 1 {
 				if typeof(a[0]) != "string" {
-					return nil, ArErr{"TypeError", "expected string, got " + typeof(a[0]), 0, "", "", true}
+					return nil, ArErr{"Type Error", "expected string, got " + typeof(a[0]), 0, "", "", true}
 				}
 				cutset = a[0].(ArObject).obj["__value__"].(string)
 			}
@@ -498,12 +501,12 @@ func ArString(str string) ArObject {
 		"leftstrip",
 		func(a ...any) (any, ArErr) {
 			if len(a) > 1 {
-				return nil, ArErr{"TypeError", "expected 0 or 1 arguments, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 0 or 1 arguments, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			cutset := " "
 			if len(a) == 1 {
 				if typeof(a[0]) != "string" {
-					return nil, ArErr{"TypeError", "expected string, got " + typeof(a[0]), 0, "", "", true}
+					return nil, ArErr{"Type Error", "expected string, got " + typeof(a[0]), 0, "", "", true}
 				}
 				cutset = a[0].(ArObject).obj["__value__"].(string)
 			}
@@ -513,12 +516,12 @@ func ArString(str string) ArObject {
 		"rightstrip",
 		func(a ...any) (any, ArErr) {
 			if len(a) > 1 {
-				return nil, ArErr{"TypeError", "expected 0 or 1 arguments, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 0 or 1 arguments, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			cutset := " "
 			if len(a) == 1 {
 				if typeof(a[0]) != "string" {
-					return nil, ArErr{"TypeError", "expected string, got " + typeof(a[0]), 0, "", "", true}
+					return nil, ArErr{"Type Error", "expected string, got " + typeof(a[0]), 0, "", "", true}
 				}
 				cutset = a[0].(ArObject).obj["__value__"].(string)
 			}
@@ -528,10 +531,10 @@ func ArString(str string) ArObject {
 		"__LessThanOrEqual__",
 		func(a ...any) (any, ArErr) {
 			if len(a) != 1 {
-				return nil, ArErr{"TypeError", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			if typeof(a[0]) != "string" {
-				return nil, ArErr{"TypeError", "cannot get less than or equal to of type " + typeof(a[0]) + " from string", 0, "", "", true}
+				return nil, ArErr{"Type Error", "cannot get less than or equal to of type " + typeof(a[0]) + " from string", 0, "", "", true}
 			}
 			a[0] = ArValidToAny(a[0])
 			return str <= a[0].(string), ArErr{}
@@ -540,10 +543,10 @@ func ArString(str string) ArObject {
 		"__LessThan__",
 		func(a ...any) (any, ArErr) {
 			if len(a) != 1 {
-				return nil, ArErr{"TypeError", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			if typeof(a[0]) != "string" {
-				return nil, ArErr{"TypeError", "cannot get less than of type " + typeof(a[0]) + " from string", 0, "", "", true}
+				return nil, ArErr{"Type Error", "cannot get less than of type " + typeof(a[0]) + " from string", 0, "", "", true}
 			}
 			a[0] = ArValidToAny(a[0])
 			return str < a[0].(string), ArErr{}
@@ -552,10 +555,10 @@ func ArString(str string) ArObject {
 		"__GreaterThan__",
 		func(a ...any) (any, ArErr) {
 			if len(a) != 1 {
-				return nil, ArErr{"TypeError", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			if typeof(a[0]) != "string" {
-				return nil, ArErr{"TypeError", "cannot get greater than of type " + typeof(a[0]) + " from string", 0, "", "", true}
+				return nil, ArErr{"Type Error", "cannot get greater than of type " + typeof(a[0]) + " from string", 0, "", "", true}
 			}
 			a[0] = ArValidToAny(a[0])
 			return str > a[0].(string), ArErr{}
@@ -565,10 +568,10 @@ func ArString(str string) ArObject {
 		"__GreaterThanEqual__",
 		func(a ...any) (any, ArErr) {
 			if len(a) != 1 {
-				return nil, ArErr{"TypeError", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			if typeof(a[0]) != "string" {
-				return nil, ArErr{"TypeError", "cannot get greater than or equal to of type " + typeof(a[0]) + " from string", 0, "", "", true}
+				return nil, ArErr{"Type Error", "cannot get greater than or equal to of type " + typeof(a[0]) + " from string", 0, "", "", true}
 			}
 			a[0] = ArValidToAny(a[0])
 			return str >= a[0].(string), ArErr{}
@@ -577,7 +580,7 @@ func ArString(str string) ArObject {
 		"__Equal__",
 		func(a ...any) (any, ArErr) {
 			if len(a) != 1 {
-				return nil, ArErr{"TypeError", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			a[0] = ArValidToAny(a[0])
 			return str == a[0], ArErr{}
@@ -586,7 +589,7 @@ func ArString(str string) ArObject {
 		"__NotEqual__",
 		func(a ...any) (any, ArErr) {
 			if len(a) != 1 {
-				return nil, ArErr{"TypeError", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			a[0] = ArValidToAny(a[0])
 			return str != a[0], ArErr{}
@@ -595,7 +598,7 @@ func ArString(str string) ArObject {
 		"__Add__",
 		func(a ...any) (any, ArErr) {
 			if len(a) != 1 {
-				return nil, ArErr{"TypeError", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			a[0] = ArValidToAny(a[0])
 			if typeof(a[0]) != "string" {
@@ -607,7 +610,7 @@ func ArString(str string) ArObject {
 		"__PostAdd__",
 		func(a ...any) (any, ArErr) {
 			if len(a) != 1 {
-				return nil, ArErr{"TypeError", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			a[0] = ArValidToAny(a[0])
 			if typeof(a[0]) != "string" {
@@ -619,17 +622,17 @@ func ArString(str string) ArObject {
 		"__Multiply__",
 		func(a ...any) (any, ArErr) {
 			if len(a) != 1 {
-				return nil, ArErr{"TypeError", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			if typeof(a[0]) != "number" {
-				return nil, ArErr{"TypeError", "cannot multiply string by " + typeof(a[0]), 0, "", "", true}
+				return nil, ArErr{"Type Error", "cannot multiply string by " + typeof(a[0]), 0, "", "", true}
 			}
 			n := a[0].(number)
 			if !n.IsInt() {
-				return nil, ArErr{"ValueError", "cannot multiply string by float", 0, "", "", true}
+				return nil, ArErr{"Value Error", "cannot multiply string by float", 0, "", "", true}
 			}
 			if n.Sign() < 0 {
-				return nil, ArErr{"ValueError", "cannot multiply string by negative number", 0, "", "", true}
+				return nil, ArErr{"Value Error", "cannot multiply string by negative number", 0, "", "", true}
 			}
 			return strings.Repeat(str, int(n.Num().Int64())), ArErr{}
 		}}
@@ -637,10 +640,10 @@ func ArString(str string) ArObject {
 		"__NotContains__",
 		func(a ...any) (any, ArErr) {
 			if len(a) != 1 {
-				return nil, ArErr{"TypeError", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			if typeof(a[0]) != "string" {
-				return nil, ArErr{"TypeError", "cannot check if string contains " + typeof(a[0]), 0, "", "", true}
+				return nil, ArErr{"Type Error", "cannot check if string contains " + typeof(a[0]), 0, "", "", true}
 			}
 			a[0] = ArValidToAny(a[0])
 			return !strings.Contains(str, a[0].(string)), ArErr{}
@@ -649,10 +652,10 @@ func ArString(str string) ArObject {
 		"__Contains__",
 		func(a ...any) (any, ArErr) {
 			if len(a) != 1 {
-				return nil, ArErr{"TypeError", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			if typeof(a[0]) != "string" {
-				return nil, ArErr{"TypeError", "cannot check if string contains " + typeof(a[0]), 0, "", "", true}
+				return nil, ArErr{"Type Error", "cannot check if string contains " + typeof(a[0]), 0, "", "", true}
 			}
 			a[0] = ArValidToAny(a[0])
 			return strings.Contains(str, a[0].(string)), ArErr{}
@@ -661,10 +664,10 @@ func ArString(str string) ArObject {
 		"__Subtract__",
 		func(a ...any) (any, ArErr) {
 			if len(a) != 1 {
-				return nil, ArErr{"TypeError", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			if typeof(a[0]) != "string" {
-				return nil, ArErr{"TypeError", "cannot subtract " + typeof(a[0]) + " from string", 0, "", "", true}
+				return nil, ArErr{"Type Error", "cannot subtract " + typeof(a[0]) + " from string", 0, "", "", true}
 			}
 			a[0] = ArValidToAny(a[0])
 			return strings.Replace(str, a[0].(string), "", -1), ArErr{}
@@ -673,10 +676,10 @@ func ArString(str string) ArObject {
 		"__Divide__",
 		func(a ...any) (any, ArErr) {
 			if len(a) != 1 {
-				return nil, ArErr{"TypeError", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
+				return nil, ArErr{"Type Error", "expected 1 argument, got " + fmt.Sprint(len(a)), 0, "", "", true}
 			}
 			if typeof(a[0]) != "string" {
-				return nil, ArErr{"TypeError", "cannot divide string by " + typeof(a[0]), 0, "", "", true}
+				return nil, ArErr{"Type Error", "cannot divide string by " + typeof(a[0]), 0, "", "", true}
 			}
 			a[0] = ArValidToAny(a[0])
 			splitby := a[0].(string)

src/subprocess.go

@@ -15,7 +15,7 @@ func ArSubprocess(args ...any) (any, ArErr) {
 		}
 	} else if typeof(args[0]) != "array" {
 		return nil, ArErr{
-			TYPE:    "TypeError",
+			TYPE:    "Type Error",
 			message: fmt.Sprintf("subprocess() argument must be an array, not %s", typeof(args[0])),
 			EXISTS:  true,
 		}
@@ -32,7 +32,7 @@ func ArSubprocess(args ...any) (any, ArErr) {
 	for _, x := range args[0].([]any) {
 		if typeof(x) != "string" {
 			return nil, ArErr{
-				TYPE:    "TypeError",
+				TYPE:    "Type Error",
 				message: fmt.Sprintf("subprocess() argument must be an array of strings, not %s", typeof(x)),
 				EXISTS:  true,
 			}
@@ -70,7 +70,7 @@ func ArSubprocess(args ...any) (any, ArErr) {
 							func(args ...any) (any, ArErr) {
 								if len(args) != 0 {
 									return nil, ArErr{
-										TYPE:    "TypeError",
+										TYPE:    "Type Error",
 										message: fmt.Sprintf("scan() takes exactly 0 arguments (%d given)", len(args)),
 										EXISTS:  true,
 									}
@@ -82,7 +82,7 @@ func ArSubprocess(args ...any) (any, ArErr) {
 							func(args ...any) (any, ArErr) {
 								if len(args) != 0 {
 									return nil, ArErr{
-										TYPE:    "TypeError",
+										TYPE:    "Type Error",
 										message: fmt.Sprintf("text() takes exactly 0 arguments (%d given)", len(args)),
 										EXISTS:  true,
 									}
@@ -94,7 +94,7 @@ func ArSubprocess(args ...any) (any, ArErr) {
 							func(args ...any) (any, ArErr) {
 								if len(args) != 0 {
 									return nil, ArErr{
-										TYPE:    "TypeError",
+										TYPE:    "Type Error",
 										message: fmt.Sprintf("err() takes exactly 0 arguments (%d given)", len(args)),
 										EXISTS:  true,
 									}
@@ -109,7 +109,7 @@ func ArSubprocess(args ...any) (any, ArErr) {
 							func(args ...any) (any, ArErr) {
 								if len(args) != 0 {
 									return nil, ArErr{
-										TYPE:    "TypeError",
+										TYPE:    "Type Error",
 										message: fmt.Sprintf("wait() takes exactly 0 arguments (%d given)", len(args)),
 										EXISTS:  true,
 									}

src/term-class.go

@@ -115,7 +115,7 @@ var ArTerm = Map(anymap{
 		}
 		timingSync.RLock()
 		if _, ok := timing[id]; !ok {
-			return nil, ArErr{TYPE: "TypeError", message: "Cannot find timer with id '" + fmt.Sprint(id) + "'", EXISTS: true}
+			return nil, ArErr{TYPE: "Type Error", message: "Cannot find timer with id '" + fmt.Sprint(id) + "'", EXISTS: true}
 		}
 		timesince := time.Since(timing[id].(time.Time))
 		timingSync.RUnlock()
@@ -140,7 +140,15 @@ var ArInput = Map(
 			return ArString(resp), ArErr{}
 		}},
 		"__call__": builtinFunc{"input", func(args ...any) (any, ArErr) {
-			return input(args...), ArErr{}
+			inp, err := input(args...)
+			if err != nil {
+				return nil, ArErr{
+					TYPE:    "Runtime Error",
+					message: err.Error(),
+					EXISTS:  true,
+				}
+			}
+			return ArString(inp), ArErr{}
 		}},
 		"pause": builtinFunc{"pause", func(args ...any) (any, ArErr) {
 			pause()

src/thread.go

@@ -2,50 +2,48 @@ package main
 
 import (
 	"fmt"
+	"sync"
 )
 
-var threadCount = 0
+var threadChan = sync.WaitGroup{}
-var threadChan = make(chan bool)
 
 func ArThread(args ...any) (any, ArErr) {
 	if len(args) != 1 {
-		return nil, ArErr{TYPE: "TypeError", message: "Invalid number of arguments, expected 1, got " + fmt.Sprint(len(args)), EXISTS: true}
+		return nil, ArErr{TYPE: "Type Error", message: "Invalid number of arguments, expected 1, got " + fmt.Sprint(len(args)), EXISTS: true}
 	}
 	var tocall any
 	switch x := args[0].(type) {
 	case anymap:
 		if _, ok := x["__call__"]; !ok {
-			return nil, ArErr{TYPE: "TypeError", message: "Cannot call thread with a '" + typeof(args[0]) + "'", EXISTS: true}
+			return nil, ArErr{TYPE: "Type Error", message: "Cannot call thread with a '" + typeof(args[0]) + "'", EXISTS: true}
 		}
 		tocall = x["__call__"]
 	case builtinFunc, Callable:
 		tocall = x
 	default:
-		return nil, ArErr{TYPE: "TypeError", message: "Cannot call thread with a '" + typeof(args[0]) + "'", EXISTS: true}
+		return nil, ArErr{TYPE: "Type Error", message: "Cannot call thread with a '" + typeof(args[0]) + "'", EXISTS: true}
 	}
 	var resp any
 	var err ArErr
 
 	hasrun := false
 	joined := false
-	var wg = make(chan bool)
+	var wg = sync.WaitGroup{}
 	threadMap := Map(anymap{
 		"start": builtinFunc{"start", func(args ...any) (any, ArErr) {
 			if hasrun {
 				return nil, ArErr{TYPE: "Runtime Error", message: "Cannot start a thread twice", EXISTS: true}
 			}
 			if len(args) != 0 {
-				return nil, ArErr{TYPE: "TypeError", message: "Invalid number of arguments, expected 0, got " + fmt.Sprint(len(args)), EXISTS: true}
+				return nil, ArErr{TYPE: "Type Error", message: "Invalid number of arguments, expected 0, got " + fmt.Sprint(len(args)), EXISTS: true}
 			}
 			hasrun = true
+			wg.Add(1)
+			threadChan.Add(1)
 			go func() {
-				threadCount++
 				resp, err = runCall(call{Callable: tocall, Args: []any{}}, nil, 0)
-				wg <- true
+				wg.Done()
-				threadCount--
+				threadChan.Done()
-				if threadCount == 0 {
-					threadChan <- true
-				}
 			}()
 			return nil, ArErr{}
 		}},
@@ -56,10 +54,10 @@ func ArThread(args ...any) (any, ArErr) {
 				return nil, ArErr{TYPE: "Runtime Error", message: "Cannot join a thread twice", EXISTS: true}
 			}
 			if len(args) != 0 {
-				return nil, ArErr{TYPE: "TypeError", message: "Invalid number of arguments, expected 0, got " + fmt.Sprint(len(args)), EXISTS: true}
+				return nil, ArErr{TYPE: "Type Error", message: "Invalid number of arguments, expected 0, got " + fmt.Sprint(len(args)), EXISTS: true}
 			}
 			joined = true
-			<-wg
+			wg.Wait()
 			return resp, err
 		}},
 	})

src/time.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"fmt"
 	"time"
 )
 
@@ -195,7 +194,6 @@ var ArTime = Map(anymap{
 	},
 	},
 	"date": builtinFunc{"date", func(a ...any) (any, ArErr) {
-		fmt.Println(a, len(a))
 		if len(a) == 1 {
 			if typeof(a[0]) != "string" {
 				return nil, ArErr{

src/to-argon.go

@@ -42,7 +42,7 @@ func anyToArgon(x any, quote bool, simplify bool, depth int, indent int, colored
 		}
 	case number:
 		if colored {
-			output = append(output, "\x1b[34;5;240m")
+			output = append(output, "\x1b[34;240m")
 		}
 		num, _ := x.Float64()
 		if math.IsNaN(num) {
@@ -59,7 +59,7 @@ func anyToArgon(x any, quote bool, simplify bool, depth int, indent int, colored
 		}
 	case bool:
 		if colored {
-			output = append(output, "\x1b[35;5;240m")
+			output = append(output, "\x1b[35;240m")
 		}
 		output = append(output, strconv.FormatBool(x))
 		if colored {
@@ -67,7 +67,7 @@ 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;240m")
 		}
 		output = append(output, "null")
 		if colored {
@@ -128,7 +128,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;240m")
 				}
 				outputkeyval = append(outputkeyval, key.(string))
 				if colored {
@@ -148,7 +148,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;240m(...)\x1b[0m")
 			} else {
 				output = append(output, "(...)")
 			}
@@ -173,7 +173,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;240m")
 		}
 		output = append(output, "<builtin function "+x.name+">")
 		if colored {
@@ -181,7 +181,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;240m")
 		}
 		output = append(output, "<function "+x.name+">")
 		if colored {

src/translate.go

@@ -11,105 +11,53 @@ type UNPARSEcode struct {
 	path     string
 }
 
-var knownFailures = map[string]ArErr{}
+var QuickKnownFailures = map[string]bool{}
 
 func translateVal(code UNPARSEcode, index int, codelines []UNPARSEcode, isLine int) (any, bool, ArErr, int) {
-	if knownErr, ok := knownFailures[code.code]; ok {
-		return nil, false, ArErr{
-			knownErr.TYPE,
-			knownErr.message,
-			code.line,
-			code.path,
-			code.realcode,
-			true,
-		}, 1
-	}
 	var (
 		resp   any   = nil
 		worked bool  = false
 		err    ArErr = ArErr{"Syntax Error", "invalid syntax", code.line, code.path, code.realcode, true}
 		i      int   = 1
 	)
-	if isLine == 3 {
+	if isLine >= 3 {
 		if isComment(code) {
 			resp, worked, err, i = parseComment(code, index, codelines)
 			if worked {
 				return resp, worked, err, i
 			}
-		} else if isIfStatement(code) {
-			resp, worked, err, i = parseIfStatement(code, index, codelines)
-			if !worked {
-				knownFailures[code.code] = err
 		}
-			return resp, worked, err, i
+		if isIfStatement(code) {
+			return parseIfStatement(code, index, codelines)
 		} else if isWhileLoop(code) {
-			resp, worked, err, i = parseWhileLoop(code, index, codelines)
+			return parseWhileLoop(code, index, codelines)
-			if !worked {
-				knownFailures[code.code] = err
-			}
-			return resp, worked, err, i
 		} else if isForeverLoop(code) {
-			resp, worked, err, i = parseForeverLoop(code, index, codelines)
+			return parseForeverLoop(code, index, codelines)
-			if !worked {
+
-				knownFailures[code.code] = err
-			}
-			return resp, worked, err, i
 		} else if isForLoop(code) {
-			resp, worked, err, i = parseForLoop(code, index, codelines)
+			return parseForLoop(code, index, codelines)
-			if !worked {
+
-				knownFailures[code.code] = err
-			}
-			return resp, worked, err, i
 		} else if isGenericImport(code) {
-			resp, worked, err, i = parseGenericImport(code, index, codelines)
+			return parseGenericImport(code, index, codelines)
-			if !worked {
+
-				knownFailures[code.code] = err
-			}
-			return resp, worked, err, i
 		} else if isTryCatch(code) {
-			resp, worked, err, i = parseTryCatch(code, index, codelines)
+			return parseTryCatch(code, index, codelines)
-			if !worked {
-				knownFailures[code.code] = err
-			}
-			return resp, worked, err, i
 		}
 	}
 
 	if isLine >= 2 {
 		if isReturn(code) {
-			resp, worked, err, i = parseReturn(code, index, codelines)
+			return parseReturn(code, index, codelines)
-			if !worked {
+
-				knownFailures[code.code] = err
+		} else if isBreak(code) {
-			}
+			return parseBreak(code)
-			return resp, worked, err, i
+
-		} else if isBreak(code) {
+		} else if isContinue(code) {
-			resp, worked, err, i = parseBreak(code)
+			return parseContinue(code)
-			if !worked {
+
-				knownFailures[code.code] = err
+		} else if isDeleteVariable(code) {
-			}
+			return parseDelete(code, index, codelines)
-			return resp, worked, err, i
-		} else if isContinue(code) {
-			resp, worked, err, i = parseContinue(code)
-			if !worked {
-				knownFailures[code.code] = err
-			}
-			return resp, worked, err, i
-		} else if isDeleteVariable(code) {
-			resp, worked, err, i = parseDelete(code, index, codelines)
-			if !worked {
-				knownFailures[code.code] = err
-			}
-			return resp, worked, err, i
-		}
-	}
 
-	if isLine >= 1 {
-		if isDoWrap(code) {
-			resp, worked, err, i = parseDoWrap(code, index, codelines)
-			if !worked {
-				knownFailures[code.code] = err
-			}
-			return resp, worked, err, i
 		}
 	}
 
@@ -117,112 +65,100 @@ func translateVal(code UNPARSEcode, index int, codelines []UNPARSEcode, isLine i
 		isLine = 1
 	}
 
-	if isBoolean(code) {
+	if isDoWrap(code) {
+		return parseDoWrap(code, index, codelines)
+	} else if isBoolean(code) {
 		return parseBoolean(code)
-	} else if isBrackets(code) {
+	} else if !QuickKnownFailures["brackets"+code.code] && isBrackets(code) {
 		resp, worked, err, i = parseBrackets(code, index, codelines)
 		if worked {
 			return resp, worked, err, i
 		}
+		QuickKnownFailures["brackets"+code.code] = true
 	}
-	if isAbs(code) {
+	if !QuickKnownFailures["abs"+code.code] && isAbs(code) {
 		resp, worked, err, i = parseAbs(code, index, codelines)
 		if worked {
 			return resp, worked, err, i
 		}
+		QuickKnownFailures["abs"+code.code] = true
 	}
-	if isSetVariable(code) {
+	if !QuickKnownFailures["autoasign"+code.code] && isAutoAsignVariable(code) {
-		resp, worked, err, i = parseSetVariable(code, index, codelines, isLine)
-		if worked {
-			return resp, worked, err, i
-		}
-	}
-	if isAutoAsignVariable(code) {
 		resp, worked, err, i = parseAutoAsignVariable(code, index, codelines, isLine)
 		if worked {
 			return resp, worked, err, i
 		}
+		QuickKnownFailures["autoasign"+code.code] = true
 	}
-	if isNumber(code) {
+	if isSetVariable(code) {
-		resp, worked, err, i = parseNumber(code)
+		return parseSetVariable(code, index, codelines, isLine)
-		if !worked {
+	} else if isNumber(code) {
-			knownFailures[code.code] = err
+		return parseNumber(code)
-		}
-		return resp, worked, err, i
 	} else if isString(code) {
-		resp, worked, err, i = parseString(code)
+		return parseString(code)
-		if !worked {
+	} else if !QuickKnownFailures["squareroot"+code.code] && issquareroot(code) {
-			knownFailures[code.code] = err
-		}
-		return resp, worked, err, i
-	} else if issquareroot(code) {
 		resp, worked, err, i = parseSquareroot(code, index, codelines)
 		if worked {
 			return resp, worked, err, i
 		}
+		QuickKnownFailures["squareroot"+code.code] = true
 	}
-	if isFactorial(code) {
+	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) {
-		resp, worked, err, i = parseVariable(code)
+		return parseVariable(code)
-		if !worked {
-			knownFailures[code.code] = err
 	}
-		return resp, worked, err, i
+	if !QuickKnownFailures["array"+code.code] && isArray(code) {
-	}
-	if isArray(code) {
 		resp, worked, err, i = parseArray(code, index, codelines)
 		if worked {
 			return resp, worked, err, i
 		}
+		QuickKnownFailures["array"+code.code] = true
 	} else if isMap(code) {
 		resp, worked, err, i = parseMap(code, index, codelines)
 	}
-	if isnot(code) {
+	if !QuickKnownFailures["not"+code.code] && isnot(code) {
 		resp, worked, err, i = parseNot(code, index, codelines, isLine)
 		if worked {
 			return resp, worked, err, i
 		}
+		QuickKnownFailures["not"+code.code] = true
 	}
-	{
+	if !QuickKnownFailures["operations"+code.code] {
 		operation, worked, err, step := parseOperations(code, index, codelines)
 		if worked {
 			return operation, worked, err, step
-		} else if err.EXISTS {
+		}
+		QuickKnownFailures["operations"+code.code] = true
+		if err.EXISTS {
 			return nil, worked, err, step
 		}
 	}
-	if isCall(code) {
+	if isNegative(code) {
+		return parseNegative(code, index, codelines)
+	}
+	if !QuickKnownFailures["call"+code.code] && isCall(code) {
 		resp, worked, err, i = parseCall(code, index, codelines)
 		if worked {
 			return resp, worked, err, i
 		}
+		QuickKnownFailures["call"+code.code] = true
 	}
-	if isNegative(code) {
+	if isMapGet(code) {
-		resp, worked, err, i = parseNegative(code, index, codelines)
+		return mapGetParse(code, index, codelines)
-		if !worked {
+	} else if !QuickKnownFailures["indexget"+code.code] && isIndexGet(code) {
-			knownFailures[code.code] = err
-		}
-		return resp, worked, err, i
-	} else if isMapGet(code) {
-		resp, worked, err, i = mapGetParse(code, index, codelines)
-		if !worked {
-			knownFailures[code.code] = err
-		}
-		return resp, worked, err, i
-	} else if isIndexGet(code) {
 		resp, worked, err, i = indexGetParse(code, index, codelines)
 		if worked {
 			return resp, worked, err, i
 		}
+		QuickKnownFailures["indexget"+code.code] = true
 	}
-	if !worked {
+
-		knownFailures[code.code] = err
-	}
 	return resp, worked, err, i
 }
 
@@ -237,7 +173,7 @@ func translate(codelines []UNPARSEcode) ([]any, ArErr) {
 		if currentindent != 0 {
 			return nil, ArErr{"Syntax Error", "invalid indent", codelines[i].line, codelines[i].path, codelines[i].realcode, true}
 		}
-		val, _, err, step := translateVal(codelines[i], i, codelines, 3)
+		val, _, err, step := translateVal(codelines[i], i, codelines, 4)
 		i += step
 		if err.EXISTS {
 			return nil, err

src/trig.go

@@ -7,6 +7,18 @@ import (
 
 var PIFloatInaccuracy number = newNumber()
 
+type sinCacheValue struct {
+	INPUT  number
+	OUTPUT number
+}
+
+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)},
+}
+
 func init() {
 	PIFloatInaccuracy.SetFloat64(math.Asin(1) * 2)
 }
@@ -25,6 +37,18 @@ var ArSin = builtinFunc{"sin", func(args ...any) (any, ArErr) {
 		}
 	}
 	num := newNumber().Set(args[0].(number))
+	toTrim := newNumber().Mul(PI, newNumber().SetInt64(2))
+	toTrim.Quo(num, toTrim)
+	toTrim = floor(toTrim)
+	toTrim.Mul(toTrim, newNumber().Mul(PI, newNumber().SetInt64(2)))
+	num.Sub(num, toTrim)
+
+	for i := 0; i < len(sinCache); i++ {
+		if sinCache[i].INPUT.Cmp(num) == 0 {
+			return sinCache[i].OUTPUT, ArErr{}
+		}
+	}
+
 	num.Quo(num, PI)
 	num.Mul(num, PIFloatInaccuracy)
 	n, _ := num.Float64()
@@ -71,12 +95,7 @@ var ArCos = builtinFunc{"cos", func(args ...any) (any, ArErr) {
 			EXISTS:  true,
 		}
 	}
-	num := newNumber().Set(args[0].(number))
+	return builtinCall(ArSin, []any{newNumber().Add(args[0].(number), newNumber().Quo(PI, newNumber().SetInt64(2)))})
-	num.Quo(num, PI)
-	num.Mul(num, PIFloatInaccuracy)
-	n, _ := num.Float64()
-	outputnum := newNumber().SetFloat64(math.Cos(n))
-	return outputnum, ArErr{}
 }}
 var ArArccos = builtinFunc{"arccos", func(args ...any) (any, ArErr) {
 	if len(args) != 1 {

src/trycatch.go

@@ -23,7 +23,7 @@ func isTryCatch(code UNPARSEcode) bool {
 func parseTryCatch(code UNPARSEcode, index int, codelines []UNPARSEcode) (TryCatch, bool, ArErr, int) {
 	trytrimmed := strings.TrimSpace(code.code)
 	totalIndex := 0
-	tryparsed, worked, err, i := translateVal(UNPARSEcode{trytrimmed[4:], code.realcode, code.line, code.path}, index, codelines, 1)
+	tryparsed, worked, err, i := translateVal(UNPARSEcode{trytrimmed[4:], code.realcode, code.line, code.path}, index, codelines, 3)
 	if !worked {
 		return TryCatch{}, false, err, i
 	}
@@ -40,7 +40,7 @@ func parseTryCatch(code UNPARSEcode, index int, codelines []UNPARSEcode) (TryCat
 	catchbracketSplit := strings.SplitN(catchtrimmed, ")", 2)
 	errorName := strings.TrimSpace(strings.TrimSpace(catchbracketSplit[0])[1:])
 	errcode := catchbracketSplit[1]
-	catchparsed, worked, err, i := translateVal(UNPARSEcode{errcode, code.realcode, code.line, code.path}, index+totalIndex, codelines, 1)
+	catchparsed, worked, err, i := translateVal(UNPARSEcode{errcode, code.realcode, code.line, code.path}, index+totalIndex, codelines, 3)
 	if !worked {
 		return TryCatch{}, false, err, i
 	}

src/whileloop.go

@@ -60,7 +60,7 @@ func parseWhileLoop(code UNPARSEcode, index int, codeline []UNPARSEcode) (whileL
 			},
 			index+outindex-1,
 			codeline,
-			2,
+			3,
 		)
 		if err.EXISTS || !worked {
 			return whileLoop{}, worked, err, step
@@ -96,7 +96,7 @@ func parseForeverLoop(code UNPARSEcode, index int, codeline []UNPARSEcode) (whil
 		},
 		index,
 		codeline,
-		2,
+		3,
 	)
 	return whileLoop{
 		condition: true,
@@ -108,13 +108,14 @@ func parseForeverLoop(code UNPARSEcode, index int, codeline []UNPARSEcode) (whil
 }
 
 func runWhileLoop(loop whileLoop, stack stack, stacklevel int) (any, ArErr) {
+
 	newstack := append(stack, newscope())
 	for {
 		condition, err := runVal(loop.condition, newstack, stacklevel+1)
-		newbodystack := append(newstack, newscope())
 		if err.EXISTS {
 			return nil, err
 		}
+		newbodystack := append(newstack, newscope())
 		if !anyToBool(condition) {
 			break
 		}

tests/brainfuck.ar

@@ -1,33 +1,45 @@
-let interpret(code) = do
+let brainfuck(INPUT) = do
-    memory = map()
+    memory = [0] * 30*1000
     pointer = 0
-    code_ptr = 0
+    output = ""
-    loops = []
+    i = 0
+    while (i < INPUT.length) do
+        if (INPUT[i] == ">") do
+            pointer += 1
+        else if (INPUT[i] == "<") do
+            pointer -= 1
+        else if (INPUT[i] == "+") do
+            memory[pointer] += 1
+        else if (INPUT[i] == "-") do
+            memory[pointer] -= 1
+        else if (INPUT[i] == ".") do
+            output += chr(memory[pointer])
+        else if (INPUT[i] == ",") do
+            memory[pointer] = ord(input())
+        else if (INPUT[i] == "[") do
+            if (memory[pointer] == 0) do
+                count = 1
+                while (count > 0) do
+                    i += 1
+                    if (INPUT[i] == "[") do
+                        count += 1
+                    else if (INPUT[i] == "]") do
+                        count -= 1
+        else if (INPUT[i] == "]") do
+            if (memory[pointer] != 0) do
+                count = 1
+                while (count > 0) do
+                    i -= 1
+                    if (INPUT[i] == "]") do
+                        count += 1
+                    else if (INPUT[i] == "[") do
+                        count -= 1
+        else do
+            pass
+        i += 1
+    term.print(memory)
+    return output
 
-    while (code_ptr < code.length) do
+term.time("brainfuck")
-        command = code[code_ptr]
+term.plain.oneLine(brainfuck(input()))
-
+term.timeEnd("brainfuck")
-        if (command == '>') pointer = pointer + 1
-        else if (command == '<') pointer = pointer - 1
-        else if (command == '+') do
-            if (pointer not in memory) memory[pointer] = 0
-            memory[pointer] = memory[pointer] + 1
-        else if (command == '-') do
-            if (pointer not in memory) memory[pointer] = 0
-            memory[pointer] = memory[pointer] - 1
-        else if (command == '.') term.log((memory.get(pointer, 0)))
-        else if (command == ',') memory[pointer] = ord(input())
-        else if (command == '[') do
-            if (memory.get(pointer, 0) == 0) do
-                loop_depth = 1
-                while (loop_depth > 0) do
-                    code_ptr = code_ptr + 1
-                    if (code[code_ptr] == '[') loop_depth = loop_depth + 1
-                    else if (code[code_ptr] == ']') loop_depth = loop_depth - 1
-            else loops.append(code_ptr)
-        else if (command == ']') do
-            if (memory.get(pointer, 0) != 0) code_ptr = loops[-1]
-            else loops.pop()
-        code_ptr = code_ptr + 1
-
-interpret('>+++++++++[<++++++++>-]<.>+++++++[<++++>-]<+.+++++++..+++.>>>++++++++[<++++>-]<.>>>++++++++++[<+++++++++>-]<---.<<<<.+++.------.--------.>>+.>++++++++++.')

tests/broken_funcCall.ar

@@ -0,0 +1,13 @@
+let x = do
+    let class = {}
+    class.f(path) = do
+        let nice(callback) = do
+            callback()
+            return class
+        let class = {nice:nice}
+        return class
+    class.cool(path, callback) = class.f(path).nice(callback)
+    return class
+
+
+term.log(x.cool("to", ()=term.log("epic")).nice(()=term.log("test")))

tests/chatbot code.ar

@@ -0,0 +1,20 @@
+# This is a comment
+
+term.log("Hello World!") # Printing to console/output  
+
+value = "Hello" # Declaring a variable
+
+do # Start of indented block
+  combined = value + " World!"
+  term.log(combined)
+
+loop = true # Using true condition
+
+while (loop) do # While loop syntax
+  term.log("Looping...")
+  loop = false # Using false condition
+
+if (value == "Hello") do # If statement syntax
+  term.log("The value is Hello")
+else do # else block
+  term.log("The value is not Hello")

tests/circular_import.ar

@@ -0,0 +1,2 @@
+import "circular_test"
+term.log("epic wow")

tests/circular_test.ar

@@ -0,0 +1,2 @@
+import "circular_import"
+term.log("hello")

tests/diff.ar

@@ -1,5 +1,5 @@
-let zero = 1e-1000
+let h = 1e-1000
-let diff(f) = (x) = (f(x + zero) - f(x)) / zero
+let diff(f) = (x) = (f(x + h) - f(x)) / h
 
 
 let f(x) = x^10+x^9+x^8+x^7+x^6+x^5+x^4+x^3+x^2+x+1

tests/multi_threading.ar

@@ -0,0 +1,16 @@
+let mythread(threadID) = do
+    term.log(threadID, "start")
+    let mynumber = 10
+    for (i from 0 to 1e4) do
+        mynumber += 1
+        mynumber
+    return term.log(threadID, "done")
+
+let threads = []
+term.time("start")
+for (i from 0 to 100) do
+    threads.append(thread(()=mythread(i)))
+    threads[i].start()
+for (i from 0 to 100) do
+    threads[i].join()
+term.timeEnd("start")

tests/rng.ar

@@ -0,0 +1,2 @@
+forever do
+    term.log(random())

wasm-build

@@ -0,0 +1 @@
+GOOS=js GOARCH=wasm go build  -trimpath -ldflags="-s -w" -o ./bin/argon.wasm ./src