Various changes

Arrays, loops, ternary, and other major features. Check doc

BOB_LANGUAGE_REFERENCE.md

@@ -71,6 +71,52 @@ make
 ### None
 - **Null value**: `none` (represents absence of value)
 
+### Arrays
+- **Array literals**: `[1, 2, 3, 4, 5]`
+- **Empty arrays**: `[]`
+- **Mixed types**: `[1, "hello", true, 3.14]`
+- **Nested arrays**: `[[1, 2], [3, 4]]`
+
+#### Array Access
+```go
+var arr = [10, 20, 30, 40, 50];
+
+// Basic indexing
+print(arr[0]);  // 10
+print(arr[2]);  // 30
+
+// Float indices auto-truncate (like JavaScript/Lua)
+print(arr[3.14]);  // 40 (truncated to arr[3])
+print(arr[2.99]);  // 30 (truncated to arr[2])
+
+// Assignment
+arr[1] = 25;
+print(arr[1]);  // 25
+
+// Increment/decrement on array elements
+arr[0]++;
+print(arr[0]);  // 11
+++arr[1];
+print(arr[1]);  // 26
+```
+
+#### Array Built-in Functions
+```go
+var arr = [1, 2, 3];
+
+// Get array length
+print(len(arr));  // 3
+
+// Add element to end
+push(arr, 4);
+print(arr);  // [1, 2, 3, 4]
+
+// Remove and return last element
+var last = pop(arr);
+print(last);  // 4
+print(arr);   // [1, 2, 3]
+```
+
 ## Variables
 
 ### Declaration
@@ -170,6 +216,42 @@ var result = (x = 10) + 5;             // AssignExpr not allowed in arithmetic
 - **Division**: `/`
 - **Modulo**: `%`
 
+### Compound Assignment Operators
+- **Add and assign**: `+=`
+- **Subtract and assign**: `-=`
+- **Multiply and assign**: `*=`
+- **Divide and assign**: `/=`
+- **Modulo and assign**: `%=`
+
+```go
+var x = 10;
+x += 5;   // x = 15
+x -= 3;   // x = 12
+x *= 2;   // x = 24
+x /= 4;   // x = 6
+x %= 4;   // x = 2
+```
+
+### Increment and Decrement Operators
+- **Prefix increment**: `++x`
+- **Postfix increment**: `x++`
+- **Prefix decrement**: `--x`
+- **Postfix decrement**: `x--`
+
+```go
+var x = 5;
+print(++x);   // 6 (increments first, then prints)
+print(x++);   // 6 (prints first, then increments)
+print(x);     // 7
+
+// Works with array elements
+var arr = [1, 2, 3];
+arr[0]++;
+print(arr[0]);  // 2
+++arr[1];
+print(arr[1]);  // 3
+```
+
 ### Comparison Operators
 - **Equal**: `==`
 - **Not equal**: `!=`
@@ -178,6 +260,21 @@ var result = (x = 10) + 5;             // AssignExpr not allowed in arithmetic
 - **Greater than or equal**: `>=`
 - **Less than or equal**: `<=`
 
+#### Cross-Type Comparisons
+Bob supports cross-type comparisons with intuitive behavior:
+
+```go
+// Equality operators work with any types
+print(none == "hello");    // false (different types)
+print(42 == "42");         // false (different types)
+print(true == true);       // true (same type and value)
+
+// Comparison operators only work with numbers
+print(5 > 3);              // true
+print(5 > "3");            // Error: > not supported between number and string
+print(none > 5);           // Error: > not supported between none and number
+```
+
 ### Logical Operators
 - **And**: `&&`
 - **Or**: `||`
@@ -426,6 +523,194 @@ assert(condition, "optional message");
 - No exception handling mechanism (yet)
 - Useful for testing and validation
 
+### Type Function
+```go
+type(value);
+```
+
+**Usage**:
+- Returns the type of a value as a string
+- Returns: `"number"`, `"string"`, `"boolean"`, `"none"`, `"array"`, `"function"`
+
+**Examples**:
+```go
+print(type(42));        // "number"
+print(type("hello"));   // "string"
+print(type(true));      // "boolean"
+print(type(none));      // "none"
+print(type([1, 2, 3])); // "array"
+print(type(func() {})); // "function"
+```
+
+### ToString Function
+```go
+toString(value);
+```
+
+**Usage**:
+- Converts any value to a string
+- Works with all data types
+
+**Examples**:
+```go
+print(toString(42));        // "42"
+print(toString(3.14));      // "3.14"
+print(toString(true));      // "true"
+print(toString([1, 2, 3])); // "[1, 2, 3]"
+```
+
+### ToNumber Function
+```go
+toNumber(value);
+```
+
+**Usage**:
+- Converts a value to a number
+- Returns 0 for non-numeric strings
+- Returns 0 for boolean false, 1 for boolean true
+
+**Examples**:
+```go
+print(toNumber("42"));      // 42
+print(toNumber("3.14"));    // 3.14
+print(toNumber("hello"));   // 0
+print(toNumber(true));      // 1
+print(toNumber(false));     // 0
+```
+
+### ToInt Function
+```go
+toInt(value);
+```
+
+**Usage**:
+- Converts a number to an integer (truncates decimal part)
+- Throws error for non-numeric values
+- Same result as using bitwise OR with 0 (`value | 0`)
+
+**Examples**:
+```go
+print(toInt(3.7));   // 3
+print(toInt(3.2));   // 3
+print(toInt(-3.7));  // -3
+print(toInt(3.0));   // 3
+```
+
+### Input Function
+```go
+input();
+input("prompt");
+```
+
+**Usage**:
+- Reads a line from standard input
+- Optional prompt string
+- Returns the input as a string
+
+**Examples**:
+```go
+var name = input("Enter your name: ");
+print("Hello, " + name + "!");
+```
+
+### Time Function
+```go
+time();
+```
+
+**Usage**:
+- Returns current Unix timestamp (seconds since epoch)
+- Useful for timing and random seed generation
+
+**Examples**:
+```go
+var start = time();
+// ... do some work ...
+var end = time();
+print("Elapsed: " + (end - start) + " seconds");
+```
+
+### Sleep Function
+```go
+sleep(seconds);
+```
+
+**Usage**:
+- Pauses execution for specified number of seconds
+- Useful for animations and timing
+
+**Examples**:
+```go
+print("Starting...");
+sleep(1);
+print("One second later...");
+```
+
+### PrintRaw Function
+```go
+printRaw("text");
+```
+
+**Usage**:
+- Prints text without adding a newline
+- Supports ANSI escape codes for colors and cursor control
+- Useful for animations and formatted output
+
+**Examples**:
+```go
+// Simple output
+printRaw("Hello");
+printRaw(" World");  // Prints: Hello World
+
+// ANSI colors
+printRaw("\e[31mRed text\e[0m");  // Red text
+printRaw("\e[32mGreen text\e[0m"); // Green text
+
+// Cursor positioning
+printRaw("\e[2J");   // Clear screen
+printRaw("\e[H");    // Move cursor to top-left
+```
+
+### Random Function
+```go
+random();
+```
+
+**Usage**:
+- Returns a random number between 0.0 and 1.0
+- Uses current time as seed
+
+**Examples**:
+```go
+var randomValue = random();
+print(randomValue);  // 0.0 to 1.0
+
+// Generate random integer 1-10
+var randomInt = toInt(random() * 10) + 1;
+print(randomInt);
+```
+
+### Eval Function
+```go
+eval("code");
+```
+
+**Usage**:
+- Executes Bob code as a string
+- Returns the result of the last expression
+- Runs in the current scope (can access variables)
+
+**Examples**:
+```go
+var x = 10;
+var result = eval("x + 5");
+print(result);  // 15
+
+var code = "2 + 3 * 4";
+var result = eval(code);
+print(result);  // 14
+```
+
 ## Error Handling
 
 ### Current Error Types

bob-language-extension/.vsix-version

@@ -0,0 +1 @@
+bob-language-0.2.0.vsix

bob-language-extension/README.md

@@ -21,12 +21,14 @@ This extension provides syntax highlighting and language support for the Bob pro
 
 ### Built-in Functions
 - `print()`, `assert()`, `input()`, `type()`, `toString()`, `toNumber()`, `time()`
+- `sleep()`, `printRaw()`, `len()`, `push()`, `pop()`, `random()`, `eval()`
 
 ### Data Types
-- Numbers (integers and floats)
+- Numbers (integers, floats, binary `0b1010`, hex `0xFF`)
 - Strings (single and double quoted)
 - Booleans (`true`, `false`)
 - None value (`none`)
+- Arrays (`[1, 2, 3]`)
 
 ### Operators
 - Arithmetic: `+`, `-`, `*`, `/`, `%`
@@ -34,6 +36,8 @@ This extension provides syntax highlighting and language support for the Bob pro
 - Logical: `&&`, `||`, `!`
 - Bitwise: `&`, `|`, `^`, `<<`, `>>`, `~`
 - Compound assignment: `+=`, `-=`, `*=`, `/=`, `%=`, `&=`, `|=`, `^=`, `<<=`, `>>=`
+- Ternary: `condition ? valueIfTrue : valueIfFalse`
+- String multiplication: `"hello" * 3`
 
 ## Installation
 
@@ -67,6 +71,16 @@ Type the following prefixes and press `Tab` to insert code snippets:
 - `continue` - Continue statement
 - `comment` - Comment block
 - `test` - Test function
+- `array` - Array declaration
+- `arrayaccess` - Array access
+- `arrayassign` - Array assignment
+- `len` - Array length
+- `push` - Array push
+- `pop` - Array pop
+- `random` - Random number
+- `sleep` - Sleep function
+- `printraw` - Print raw
+- `eval` - Eval function
 
 ### File Association
 Files with the `.bob` extension will automatically be recognized as Bob language files.
@@ -78,6 +92,12 @@ Files with the `.bob` extension will automatically be recognized as Bob language
 var message = "Hello, Bob!";
 print(message);
 
+// Array operations
+var numbers = [1, 2, 3, 4, 5];
+print("Array length: " + len(numbers));
+print("First element: " + numbers[0]);
+
+// Function with ternary operator
 func factorial(n) {
     if (n <= 1) {
         return 1;
@@ -86,7 +106,11 @@ func factorial(n) {
 }
 
 var result = factorial(5);
+var status = result > 100 ? "large" : "small";
 assert(result == 120, "Factorial calculation failed");
+
+// String multiplication
+var repeated = "hello" * 3;  // "hellohellohello"
 ```
 
 ## Contributing

bob-language-extension/example.bob

@@ -7,11 +7,26 @@ var pi = 3.14159;
 var isActive = true;
 var empty = none;
 
+// Binary and hex numbers
+var binaryNum = 0b1010;  // 10 in decimal
+var hexNum = 0xFF;       // 255 in decimal
+
 // Print statements
 print(message);
 print("Number: " + toString(number));
 print("Pi: " + toString(pi));
 
+// Array operations
+var numbers = [1, 2, 3, 4, 5];
+var fruits = ["apple", "banana", "cherry"];
+
+print("Array length: " + len(numbers));
+print("First element: " + numbers[0]);
+
+numbers[2] = 99;  // Array assignment
+push(numbers, 6); // Add element
+var lastElement = pop(numbers); // Remove and get last element
+
 // Function definition
 func factorial(n) {
     if (n <= 1) {
@@ -38,11 +53,25 @@ for (var i = 0; i < 10; i = i + 1) {
     sum = sum + i;
 }
 
+// Do-while loop
+var doCounter = 0;
+do {
+    doCounter = doCounter + 1;
+} while (doCounter < 5);
+
 // Anonymous function
 var double = func(x) {
     return x * 2;
 };
 
+// Ternary operator
+var max = 10 > 5 ? 10 : 5;
+var status = age >= 18 ? "adult" : "minor";
+
+// String multiplication
+var repeated = "hello" * 3;  // "hellohellohello"
+var numRepeated = 3 * "hi";  // "hihihi"
+
 // Logical operators
 var a = true && false;
 var b = true || false;
@@ -61,6 +90,12 @@ value += 5;
 value *= 2;
 value -= 3;
 
+// New built-in functions
+var randomValue = random();
+sleep(100);  // Sleep for 100ms
+printRaw("No newline here");
+eval("print('Dynamic code execution!');");
+
 // Assertions
 assert(factorial(5) == 120, "Factorial calculation failed");
 assert(sum == 25, "Sum calculation failed");
@@ -68,6 +103,7 @@ assert(sum == 25, "Sum calculation failed");
 // Type checking
 var typeOfMessage = type(message);
 var typeOfNumber = type(number);
+var typeOfArray = type(numbers);
 
 // Time function
 var currentTime = time();

bob-language-extension/package.json

@@ -1,8 +1,8 @@
 {
   "name": "bob-language",
   "displayName": "Bob Language",
-  "description": "Syntax highlighting and language support for the Bob programming language",
+  "description": "Syntax highlighting and language support for the Bob programming language - featuring arrays, auto-truncating float indices, increment/decrement operators, cross-type comparisons, and comprehensive built-in functions",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "engines": {
     "vscode": "^1.60.0"
   },

bob-language-extension/snippets/bob.json

@@ -229,6 +229,76 @@
     ],
     "description": "Check type of expression"
   },
+  "Array Declaration": {
+    "prefix": "array",
+    "body": [
+      "var ${1:arrayName} = [${2:element1}, ${3:element2}];"
+    ],
+    "description": "Declare an array"
+  },
+  "Array Access": {
+    "prefix": "arrayaccess",
+    "body": [
+      "var element = ${1:arrayName}[${2:index}];"
+    ],
+    "description": "Access array element"
+  },
+  "Array Assignment": {
+    "prefix": "arrayassign",
+    "body": [
+      "${1:arrayName}[${2:index}] = ${3:value};"
+    ],
+    "description": "Assign value to array element"
+  },
+  "Array Length": {
+    "prefix": "len",
+    "body": [
+      "var length = len(${1:arrayName});"
+    ],
+    "description": "Get array length"
+  },
+  "Array Push": {
+    "prefix": "push",
+    "body": [
+      "push(${1:arrayName}, ${2:value});"
+    ],
+    "description": "Add element to array"
+  },
+  "Array Pop": {
+    "prefix": "pop",
+    "body": [
+      "var element = pop(${1:arrayName});"
+    ],
+    "description": "Remove and return last element"
+  },
+  "Random Number": {
+    "prefix": "random",
+    "body": [
+      "var randomValue = random();"
+    ],
+    "description": "Generate random number"
+  },
+  "Sleep": {
+    "prefix": "sleep",
+    "body": [
+      "sleep(${1:milliseconds});"
+    ],
+    "description": "Sleep for specified milliseconds"
+  },
+  "Print Raw": {
+    "prefix": "printraw",
+    "body": [
+      "printRaw(${1:expression});"
+    ],
+    "description": "Print without newline"
+  },
+  "Eval": {
+    "prefix": "eval",
+    "body": [
+      "eval(\"${1:code}\");"
+    ],
+    "description": "Evaluate dynamic code"
+  },
   "ToString": {
     "prefix": "tostring",
     "body": [
@@ -287,5 +357,61 @@
       "print(\"SUCCESS: ${1:success message}\");"
     ],
     "description": "Success message print"
+  },
+  "ToInt": {
+    "prefix": "toint",
+    "body": [
+      "var intValue = toInt(${1:floatValue});"
+    ],
+    "description": "Convert float to integer"
+  },
+  "Compound Assignment": {
+    "prefix": "compound",
+    "body": [
+      "${1:variable} += ${2:value};"
+    ],
+    "description": "Compound assignment operator"
+  },
+  "Increment": {
+    "prefix": "inc",
+    "body": [
+      "${1:variable}++;"
+    ],
+    "description": "Increment variable"
+  },
+  "Decrement": {
+    "prefix": "dec",
+    "body": [
+      "${1:variable}--;"
+    ],
+    "description": "Decrement variable"
+  },
+  "Array Increment": {
+    "prefix": "arrayinc",
+    "body": [
+      "${1:arrayName}[${2:index}]++;"
+    ],
+    "description": "Increment array element"
+  },
+  "Array Decrement": {
+    "prefix": "arraydec",
+    "body": [
+      "${1:arrayName}[${2:index}]--;"
+    ],
+    "description": "Decrement array element"
+  },
+  "Cross-Type Comparison": {
+    "prefix": "crosscomp",
+    "body": [
+      "var result = ${1:value1} == ${2:value2};  // Works with any types"
+    ],
+    "description": "Cross-type comparison"
+  },
+  "Float Array Index": {
+    "prefix": "floatindex",
+    "body": [
+      "var element = ${1:arrayName}[${2:floatIndex}];  // Auto-truncates to int"
+    ],
+    "description": "Array access with float index (auto-truncates)"
   }
 } 

bob-language-extension/syntaxes/bob.tmLanguage.json

@@ -11,6 +11,9 @@
     {
       "include": "#numbers"
     },
+    {
+      "include": "#arrays"
+    },
     {
       "include": "#keywords"
     },
@@ -47,7 +50,7 @@
           "patterns": [
             {
               "name": "constant.character.escape.bob",
-              "match": "\\\\[nt\"\\\\]"
+              "match": "\\\\[nt\"\\\\e]"
             }
           ]
         },
@@ -58,7 +61,7 @@
           "patterns": [
             {
               "name": "constant.character.escape.bob",
-              "match": "\\\\[nt'\\\\]"
+              "match": "\\\\[nt'\\\\e]"
             }
           ]
         }
@@ -73,6 +76,36 @@
         {
           "name": "constant.numeric.float.bob",
           "match": "\\b\\d+\\.\\d+\\b"
+        },
+        {
+          "name": "constant.numeric.binary.bob",
+          "match": "\\b0b[01]+\\b"
+        },
+        {
+          "name": "constant.numeric.hex.bob",
+          "match": "\\b0x[0-9a-fA-F]+\\b"
+        }
+      ]
+    },
+    "arrays": {
+      "patterns": [
+        {
+          "name": "meta.array.bob",
+          "begin": "\\[",
+          "end": "\\]",
+          "patterns": [
+            {
+              "include": "#expressions"
+            }
+          ]
+        },
+        {
+          "name": "variable.other.array-index.bob",
+          "match": "([a-zA-Z_][a-zA-Z0-9_]*)\\[([^\\]]+)\\]",
+          "captures": {
+            "1": { "name": "variable.other.bob" },
+            "2": { "name": "constant.numeric.integer.bob" }
+          }
         }
       ]
     },
@@ -104,7 +137,7 @@
         },
         {
           "name": "support.function.builtin.bob",
-          "match": "\\b(print|assert|input|type|toString|toNumber|time)\\b"
+          "match": "\\b(print|assert|input|type|toString|toNumber|toInt|time|sleep|printRaw|len|push|pop|random|eval)\\b"
         }
       ]
     },
@@ -170,6 +203,31 @@
           "match": "\\?|:"
         }
       ]
+    },
+    "expressions": {
+      "patterns": [
+        {
+          "include": "#comments"
+        },
+        {
+          "include": "#strings"
+        },
+        {
+          "include": "#numbers"
+        },
+        {
+          "include": "#keywords"
+        },
+        {
+          "include": "#functions"
+        },
+        {
+          "include": "#variables"
+        },
+        {
+          "include": "#operators"
+        }
+      ]
     }
   }
 } 

bob-language-extension/version-info.md

@@ -0,0 +1,73 @@
+# Bob Language Extension v0.3.0
+
+## What's New
+
+### ✨ New Features Added
+
+#### **Enhanced Array Support**
+- **Auto-truncating float indices**: `array[3.14]` → `array[3]` (like JavaScript/Lua)
+- **Increment/decrement on array elements**: `array[0]++`, `++array[1]`
+- **Improved array operations**: Better error handling and bounds checking
+
+#### **New Built-in Functions**
+- `toInt()` - convert floats to integers (truncates decimals)
+- Enhanced error reporting for all built-in functions
+
+#### **Increment/Decrement Operators**
+- **Prefix increment**: `++x`
+- **Postfix increment**: `x++`
+- **Prefix decrement**: `--x`
+- **Postfix decrement**: `x--`
+- **Works on variables and array elements**
+
+#### **Cross-Type Comparisons**
+- **Equality operators** (`==`, `!=`) work with any types
+- **Comparison operators** (`>`, `<`, `>=`, `<=`) only work with numbers
+- **Clear error messages** for type mismatches
+
+#### **Compound Assignment Operators**
+- **Enhanced error reporting** with correct operator names
+- **Consistent behavior** across all compound operators
+- **Better type checking** before operations
+
+#### **New Code Snippets**
+- `toint` - Convert float to integer
+- `compound` - Compound assignment operators
+- `inc` - Increment variable
+- `dec` - Decrement variable
+- `arrayinc` - Increment array element
+- `arraydec` - Decrement array element
+- `crosscomp` - Cross-type comparison
+- `floatindex` - Array access with float index
+
+### 🎨 Syntax Highlighting Improvements
+- Support for `toInt()` built-in function
+- Enhanced operator recognition for increment/decrement
+- Better array indexing syntax support
+
+### 📝 Documentation Updates
+- Comprehensive array documentation with auto-truncation examples
+- New built-in function documentation (`toInt`, enhanced error reporting)
+- Cross-type comparison behavior documentation
+- Increment/decrement operator documentation
+- Compound assignment operator documentation
+
+### 🐛 Bug Fixes
+- **Fixed array printing** - arrays no longer show as "unknown"
+- **Enhanced error reporting** - all errors now use the error reporter system
+- **Improved type checking** - better error messages for type mismatches
+- **Memory management** - better cleanup of unused functions and arrays
+
+## Installation
+
+To create the VSIX package:
+1. Install Node.js and npm
+2. Run `npm install -g vsce`
+3. Run `./package-vsix.sh`
+
+The extension will be packaged as `bob-language-0.3.0.vsix`
+
+## Compatibility
+- VS Code 1.60.0+
+- Cursor (VS Code compatible)
+- All platforms (Windows, macOS, Linux) 

headers/BobStdLib.h

@@ -7,7 +7,7 @@
 class Interpreter;
 class ErrorReporter;
 
-class StdLib {
+class BobStdLib {
 public:
     static void addToEnvironment(std::shared_ptr<Environment> env, Interpreter& interpreter, ErrorReporter* errorReporter = nullptr);
 }; 

headers/Environment.h

@@ -14,6 +14,17 @@ public:
     Environment() : parent(nullptr), errorReporter(nullptr) {}
     Environment(std::shared_ptr<Environment> parent_env) : parent(parent_env), errorReporter(nullptr) {}
     
+    // Copy constructor for closure snapshots - creates a deep copy of the environment chain
+    Environment(const Environment& other) : parent(nullptr), errorReporter(other.errorReporter) {
+        // Copy all variables normally - arrays will be handled by forceCleanup
+        variables = other.variables;
+        
+        // Create a deep copy of the parent environment chain
+        if (other.parent) {
+            parent = std::make_shared<Environment>(*other.parent);
+        }
+    }
+    
     // Set error reporter for enhanced error reporting
     void setErrorReporter(ErrorReporter* reporter) {
         errorReporter = reporter;
@@ -46,3 +57,4 @@ private:
     std::shared_ptr<Environment> parent;
     ErrorReporter* errorReporter;
 };
+

headers/ErrorReporter.h

@@ -48,6 +48,9 @@ public:
     // Check if an error has been reported
     bool hasReportedError() const { return hadError; }
 
+    // Reset error state (call this between REPL commands)
+    void resetErrorState() { hadError = false; }
+
     // Report errors with full context
     void reportErrorWithContext(const ErrorContext& context);
 

headers/Expression.h

@@ -14,6 +14,9 @@
 struct FunctionExpr;
 struct IncrementExpr;
 struct TernaryExpr;
+struct ArrayLiteralExpr;
+struct ArrayIndexExpr;
+struct ArrayAssignExpr;
 struct ExprVisitor;
 
 struct AssignExpr;
@@ -37,6 +40,9 @@ struct ExprVisitor
     virtual Value visitUnaryExpr(const std::shared_ptr<UnaryExpr>& expr) = 0;
     virtual Value visitVarExpr(const std::shared_ptr<VarExpr>& expr) = 0;
     virtual Value visitTernaryExpr(const std::shared_ptr<TernaryExpr>& expr) = 0;
+    virtual Value visitArrayLiteralExpr(const std::shared_ptr<ArrayLiteralExpr>& expr) = 0;
+    virtual Value visitArrayIndexExpr(const std::shared_ptr<ArrayIndexExpr>& expr) = 0;
+    virtual Value visitArrayAssignExpr(const std::shared_ptr<ArrayAssignExpr>& expr) = 0;
 };
 
 struct Expr : public std::enable_shared_from_this<Expr> {
@@ -168,3 +174,44 @@ struct TernaryExpr : Expr
     }
 };
 
+struct ArrayLiteralExpr : Expr
+{
+    std::vector<std::shared_ptr<Expr>> elements;
+    
+    explicit ArrayLiteralExpr(const std::vector<std::shared_ptr<Expr>>& elements)
+        : elements(elements) {}
+    Value accept(ExprVisitor* visitor) override
+    {
+        return visitor->visitArrayLiteralExpr(std::static_pointer_cast<ArrayLiteralExpr>(shared_from_this()));
+    }
+};
+
+struct ArrayIndexExpr : Expr
+{
+    std::shared_ptr<Expr> array;
+    std::shared_ptr<Expr> index;
+    Token bracket;  // The closing bracket token for error reporting
+    
+    ArrayIndexExpr(std::shared_ptr<Expr> array, std::shared_ptr<Expr> index, Token bracket)
+        : array(array), index(index), bracket(bracket) {}
+    Value accept(ExprVisitor* visitor) override
+    {
+        return visitor->visitArrayIndexExpr(std::static_pointer_cast<ArrayIndexExpr>(shared_from_this()));
+    }
+};
+
+struct ArrayAssignExpr : Expr
+{
+    std::shared_ptr<Expr> array;
+    std::shared_ptr<Expr> index;
+    std::shared_ptr<Expr> value;
+    Token bracket;  // The closing bracket token for error reporting
+    
+    ArrayAssignExpr(std::shared_ptr<Expr> array, std::shared_ptr<Expr> index, std::shared_ptr<Expr> value, Token bracket)
+        : array(array), index(index), value(value), bracket(bracket) {}
+    Value accept(ExprVisitor* visitor) override
+    {
+        return visitor->visitArrayAssignExpr(std::static_pointer_cast<ArrayAssignExpr>(shared_from_this()));
+    }
+};
+

headers/Interpreter.h

@@ -5,7 +5,7 @@
 #include "TypeWrapper.h"
 #include "Environment.h"
 #include "Value.h"
-#include "StdLib.h"
+#include "BobStdLib.h"
 #include "ErrorReporter.h"
 
 #include <vector>
@@ -66,6 +66,9 @@ public:
     Value visitIncrementExpr(const std::shared_ptr<IncrementExpr>& expression) override;
     Value visitAssignExpr(const std::shared_ptr<AssignExpr>& expression) override;
     Value visitTernaryExpr(const std::shared_ptr<TernaryExpr>& expression) override;
+    Value visitArrayLiteralExpr(const std::shared_ptr<ArrayLiteralExpr>& expression) override;
+    Value visitArrayIndexExpr(const std::shared_ptr<ArrayIndexExpr>& expression) override;
+    Value visitArrayAssignExpr(const std::shared_ptr<ArrayAssignExpr>& expression) override;
 
     void visitBlockStmt(const std::shared_ptr<BlockStmt>& statement, ExecutionContext* context = nullptr) override;
     void visitExpressionStmt(const std::shared_ptr<ExpressionStmt>& statement, ExecutionContext* context = nullptr) override;
@@ -80,7 +83,7 @@ public:
     void visitContinueStmt(const std::shared_ptr<ContinueStmt>& statement, ExecutionContext* context = nullptr) override;
     void visitAssignStmt(const std::shared_ptr<AssignStmt>& statement, ExecutionContext* context = nullptr) override;
 
-    void interpret(std::vector<std::shared_ptr<Stmt> > statements);
+    void interpret(std::vector<std::shared_ptr<Stmt>> statements);
 
     explicit Interpreter(bool IsInteractive) : IsInteractive(IsInteractive), errorReporter(nullptr){
         environment = std::make_shared<Environment>();
@@ -90,25 +93,25 @@ public:
 private:
     std::shared_ptr<Environment> environment;
     bool IsInteractive;
-    std::vector<std::shared_ptr<BuiltinFunction> > builtinFunctions;
+    std::vector<std::shared_ptr<BuiltinFunction>> builtinFunctions;
-    std::vector<std::shared_ptr<Function> > functions;
+    std::vector<std::shared_ptr<Function>> functions;
-    std::vector<std::shared_ptr<Thunk> > thunks;  // Store thunks to prevent memory leaks
+    std::vector<std::shared_ptr<Thunk>> thunks;  // Store thunks to prevent memory leaks
     ErrorReporter* errorReporter;
     bool inThunkExecution = false;
     
     // Automatic cleanup tracking
     int functionCreationCount = 0;
     int thunkCreationCount = 0;
-    static const int CLEANUP_THRESHOLD = 1000;  // Cleanup every 1000 creations
+    static const int CLEANUP_THRESHOLD = 1000000;  // Cleanup every 1M creations (effectively disabled for performance)
     
 
     
     Value evaluate(const std::shared_ptr<Expr>& expr);
     Value evaluateWithoutTrampoline(const std::shared_ptr<Expr>& expr);
     bool isEqual(Value a, Value b);
-    bool isWholeNumer(double num);
+
     void execute(const std::shared_ptr<Stmt>& statement, ExecutionContext* context = nullptr);
-    void executeBlock(std::vector<std::shared_ptr<Stmt> > statements, std::shared_ptr<Environment> env, ExecutionContext* context = nullptr);
+    void executeBlock(std::vector<std::shared_ptr<Stmt>> statements, std::shared_ptr<Environment> env, ExecutionContext* context = nullptr);
     void addStdLibFunctions();
     
     // Trampoline execution
@@ -122,6 +125,7 @@ public:
     // Memory management
     void cleanupUnusedFunctions();
     void cleanupUnusedThunks();
+    void forceCleanup();
 
     // Error reporting
     void setErrorReporter(ErrorReporter* reporter) { 
@@ -133,4 +137,6 @@ public:
         // Add standard library functions after error reporter is set
         addStdLibFunctions();
     }
+    
+
 };

headers/Lexer.h

@@ -6,6 +6,7 @@
 
 enum TokenType{
     OPEN_PAREN, CLOSE_PAREN, OPEN_BRACE, CLOSE_BRACE,
+    OPEN_BRACKET, CLOSE_BRACKET,  // Array brackets
     COMMA, DOT, MINUS, PLUS, SEMICOLON, SLASH, STAR, PERCENT,
 
     BIN_OR, BIN_AND, BIN_NOT, BIN_XOR, BIN_SLEFT, BIN_SRIGHT,
@@ -36,6 +37,7 @@ enum TokenType{
 };
 
 inline std::string enum_mapping[] = {"OPEN_PAREN", "CLOSE_PAREN", "OPEN_BRACE", "CLOSE_BRACE",
+                           "OPEN_BRACKET", "CLOSE_BRACKET",  // Array brackets
                            "COMMA", "DOT", "MINUS", "PLUS", "SEMICOLON", "SLASH", "STAR", "PERCENT",
 
                            "BIN_OR", "BIN_AND", "BIN_NOT", "BIN_XOR", "BIN_SLEFT", "BIN_SRIGHT",

headers/Parser.h

@@ -83,6 +83,10 @@ private:
     std::vector<std::shared_ptr<Stmt>> block();
     
     sptr(Expr) finishCall(sptr(Expr) callee);
+    sptr(Expr) finishArrayIndex(sptr(Expr) array);
+    sptr(Expr) finishArrayAssign(sptr(Expr) array, sptr(Expr) index, sptr(Expr) value);
+    sptr(Expr) arrayLiteral();
+    sptr(Expr) call();  // Handle call chains (function calls and array indexing)
     
     // Helper methods for function scope tracking
     void enterFunction() { functionDepth++; }

headers/Statement.h

@@ -51,8 +51,8 @@ struct Stmt : public std::enable_shared_from_this<Stmt>
 
 struct BlockStmt : Stmt
 {
-    std::vector<std::shared_ptr<Stmt> > statements;
+    std::vector<std::shared_ptr<Stmt>> statements;
-    explicit BlockStmt(std::vector<std::shared_ptr<Stmt> > statements) : statements(statements)
+    explicit BlockStmt(std::vector<std::shared_ptr<Stmt>> statements) : statements(statements)
     {
     }
     void accept(StmtVisitor* visitor, ExecutionContext* context = nullptr) override
@@ -94,9 +94,9 @@ struct FunctionStmt : Stmt
 {
     const Token name;
     const std::vector<Token> params;
-    std::vector<std::shared_ptr<Stmt> > body;
+    std::vector<std::shared_ptr<Stmt>> body;
 
-    FunctionStmt(Token name, std::vector<Token> params, std::vector<std::shared_ptr<Stmt> > body) 
+    FunctionStmt(Token name, std::vector<Token> params, std::vector<std::shared_ptr<Stmt>> body) 
         : name(name), params(params), body(body) {}
 
     void accept(StmtVisitor* visitor, ExecutionContext* context = nullptr) override

headers/Value.h

@@ -1,4 +1,5 @@
 #pragma once
+#include "helperFunctions/ErrorUtils.h"
 #include <string>
 #include <vector>
 #include <unordered_map>
@@ -21,7 +22,8 @@ enum ValueType {
     VAL_STRING,
     VAL_FUNCTION,
     VAL_BUILTIN_FUNCTION,
-    VAL_THUNK
+    VAL_THUNK,
+    VAL_ARRAY
 };
 
 // Tagged value system (like Lua) - no heap allocation for simple values
@@ -35,6 +37,7 @@ struct Value {
     };
     ValueType type;
     std::string string_value; // Store strings outside the union for safety
+    std::shared_ptr<std::vector<Value> > array_value; // Store arrays as shared_ptr for mutability
 
     // Constructors
     Value() : number(0.0), type(ValueType::VAL_NONE) {}
@@ -46,11 +49,15 @@ struct Value {
     Value(Function* f) : function(f), type(ValueType::VAL_FUNCTION) {}
     Value(BuiltinFunction* bf) : builtin_function(bf), type(ValueType::VAL_BUILTIN_FUNCTION) {}
     Value(Thunk* t) : thunk(t), type(ValueType::VAL_THUNK) {}
+    Value(const std::vector<Value>& arr) : type(ValueType::VAL_ARRAY), array_value(std::make_shared<std::vector<Value> >(arr)) {}
+    Value(std::vector<Value>&& arr) : type(ValueType::VAL_ARRAY), array_value(std::make_shared<std::vector<Value> >(std::move(arr))) {}
+    
+
 
     // Move constructor
     Value(Value&& other) noexcept 
-        : type(other.type), string_value(std::move(other.string_value)) {
+        : type(other.type), string_value(std::move(other.string_value)), array_value(std::move(other.array_value)) {
-        if (type != ValueType::VAL_STRING) {
+        if (type != ValueType::VAL_STRING && type != ValueType::VAL_ARRAY) {
             number = other.number; // Copy the union
         }
         other.type = ValueType::VAL_NONE;
@@ -62,6 +69,8 @@ struct Value {
             type = other.type;
             if (type == ValueType::VAL_STRING) {
                 string_value = std::move(other.string_value);
+            } else if (type == ValueType::VAL_ARRAY) {
+                array_value = std::move(other.array_value); // shared_ptr automatically handles moving
             } else {
                 number = other.number; // Copy the union
             }
@@ -74,6 +83,8 @@ struct Value {
     Value(const Value& other) : type(other.type) {
         if (type == ValueType::VAL_STRING) {
             string_value = other.string_value;
+        } else if (type == ValueType::VAL_ARRAY) {
+            array_value = other.array_value; // shared_ptr automatically handles sharing
         } else {
             number = other.number; // Copy the union
         }
@@ -85,6 +96,8 @@ struct Value {
             type = other.type;
             if (type == ValueType::VAL_STRING) {
                 string_value = other.string_value;
+            } else if (type == ValueType::VAL_ARRAY) {
+                array_value = other.array_value; // shared_ptr automatically handles sharing
             } else {
                 number = other.number; // Copy the union
             }
@@ -98,13 +111,37 @@ struct Value {
     inline bool isString() const { return type == ValueType::VAL_STRING; }
     inline bool isFunction() const { return type == ValueType::VAL_FUNCTION; }
     inline bool isBuiltinFunction() const { return type == ValueType::VAL_BUILTIN_FUNCTION; }
+    inline bool isArray() const { return type == ValueType::VAL_ARRAY; }
     inline bool isThunk() const { return type == ValueType::VAL_THUNK; }
     inline bool isNone() const { return type == ValueType::VAL_NONE; }
 
+    // Get type name as string for error messages
+    inline std::string getType() const {
+        switch (type) {
+            case ValueType::VAL_NONE: return "none";
+            case ValueType::VAL_NUMBER: return "number";
+            case ValueType::VAL_BOOLEAN: return "boolean";
+            case ValueType::VAL_STRING: return "string";
+            case ValueType::VAL_FUNCTION: return "function";
+            case ValueType::VAL_BUILTIN_FUNCTION: return "builtin_function";
+            case ValueType::VAL_THUNK: return "thunk";
+            case ValueType::VAL_ARRAY: return "array";
+            default: return "unknown";
+        }
+    }
+    
+
+
     // Value extraction (safe, with type checking) - inline for performance
     inline double asNumber() const { return isNumber() ? number : 0.0; }
     inline bool asBoolean() const { return isBoolean() ? boolean : false; }
     inline const std::string& asString() const { return string_value; }
+    inline const std::vector<Value>& asArray() const { 
+        return *array_value; 
+    }
+    inline std::vector<Value>& asArray() { 
+        return *array_value; 
+    }
     inline Function* asFunction() const { return isFunction() ? function : nullptr; }
     inline BuiltinFunction* asBuiltinFunction() const { return isBuiltinFunction() ? builtin_function : nullptr; }
     inline Thunk* asThunk() const { return isThunk() ? thunk : nullptr; }
@@ -160,6 +197,18 @@ struct Value {
             case ValueType::VAL_FUNCTION: return "<function>";
             case ValueType::VAL_BUILTIN_FUNCTION: return "<builtin_function>";
             case ValueType::VAL_THUNK: return "<thunk>";
+            case ValueType::VAL_ARRAY: {
+                const std::vector<Value>& arr = *array_value;
+                std::string result = "[";
+                
+                for (size_t i = 0; i < arr.size(); i++) {
+                    if (i > 0) result += ", ";
+                    result += arr[i].toString();
+                }
+                
+                result += "]";
+                return result;
+            }
             default: return "unknown";
         }
     }
@@ -191,14 +240,14 @@ struct Value {
         if (!isString() && !isNumber() && other.isString()) {
             return Value(toString() + other.string_value);
         }
-        throw std::runtime_error("Invalid operands for + operator");
+        throw std::runtime_error(ErrorUtils::makeOperatorError("+", getType(), other.getType()));
     }
 
     Value operator-(const Value& other) const {
         if (isNumber() && other.isNumber()) {
             return Value(number - other.number);
         }
-        throw std::runtime_error("Invalid operands for - operator");
+        throw std::runtime_error(ErrorUtils::makeOperatorError("-", getType(), other.getType()));
     }
 
     Value operator*(const Value& other) const {
@@ -219,7 +268,7 @@ struct Value {
             }
             return Value(result);
         }
-        throw std::runtime_error("Invalid operands for * operator");
+        throw std::runtime_error(ErrorUtils::makeOperatorError("*", getType(), other.getType()));
     }
 
     Value operator/(const Value& other) const {
@@ -229,49 +278,49 @@ struct Value {
             }
             return Value(number / other.number);
         }
-        throw std::runtime_error("Invalid operands for / operator");
+        throw std::runtime_error(ErrorUtils::makeOperatorError("/", getType(), other.getType()));
     }
 
     Value operator%(const Value& other) const {
         if (isNumber() && other.isNumber()) {
             return Value(fmod(number, other.number));
         }
-        throw std::runtime_error("Invalid operands for % operator");
+        throw std::runtime_error(ErrorUtils::makeOperatorError("%", getType(), other.getType()));
     }
 
     Value operator&(const Value& other) const {
         if (isNumber() && other.isNumber()) {
             return Value(static_cast<double>(static_cast<long>(number) & static_cast<long>(other.number)));
         }
-        throw std::runtime_error("Invalid operands for & operator");
+        throw std::runtime_error(ErrorUtils::makeOperatorError("&", getType(), other.getType()));
     }
 
     Value operator|(const Value& other) const {
         if (isNumber() && other.isNumber()) {
             return Value(static_cast<double>(static_cast<long>(number) | static_cast<long>(other.number)));
         }
-        throw std::runtime_error("Invalid operands for | operator");
+        throw std::runtime_error(ErrorUtils::makeOperatorError("|", getType(), other.getType()));
     }
 
     Value operator^(const Value& other) const {
         if (isNumber() && other.isNumber()) {
             return Value(static_cast<double>(static_cast<long>(number) ^ static_cast<long>(other.number)));
         }
-        throw std::runtime_error("Invalid operands for ^ operator");
+        throw std::runtime_error(ErrorUtils::makeOperatorError("^", getType(), other.getType()));
     }
 
     Value operator<<(const Value& other) const {
         if (isNumber() && other.isNumber()) {
             return Value(static_cast<double>(static_cast<long>(number) << static_cast<long>(other.number)));
         }
-        throw std::runtime_error("Invalid operands for << operator");
+        throw std::runtime_error(ErrorUtils::makeOperatorError("<<", getType(), other.getType()));
     }
 
     Value operator>>(const Value& other) const {
         if (isNumber() && other.isNumber()) {
             return Value(static_cast<double>(static_cast<long>(number) >> static_cast<long>(other.number)));
         }
-        throw std::runtime_error("Invalid operands for >> operator");
+        throw std::runtime_error(ErrorUtils::makeOperatorError(">>", getType(), other.getType()));
     }
 };
 

headers/bob.h

@@ -8,7 +8,7 @@
 #include "../headers/helperFunctions/ShortHands.h"
 #include "../headers/ErrorReporter.h"
 
-#define VERSION "0.0.2"
+#define VERSION "0.0.3"
 
 class Bob
 {

headers/helperFunctions/ErrorUtils.h

@@ -0,0 +1,10 @@
+#pragma once
+#include <string>
+
+// Common error message utilities
+namespace ErrorUtils {
+    // Generate consistent operator error messages with single quotes
+    inline std::string makeOperatorError(const std::string& op, const std::string& leftType, const std::string& rightType) {
+        return "'" + op + "' is not supported between '" + leftType + "' and '" + rightType + "'";
+    }
+} 

source/BobStdLib.cpp

@@ -0,0 +1,509 @@
+#include "../headers/BobStdLib.h"
+#include "../headers/Interpreter.h"
+#include "../headers/ErrorReporter.h"
+#include "../headers/Lexer.h"
+#include "../headers/Parser.h"
+#include <chrono>
+#include <thread>
+
+void BobStdLib::addToEnvironment(std::shared_ptr<Environment> env, Interpreter& interpreter, ErrorReporter* errorReporter) {
+    // Create a built-in toString function
+    auto toStringFunc = std::make_shared<BuiltinFunction>("toString",
+        [&interpreter, errorReporter](std::vector<Value> args, int line, int column) -> Value {
+            if (args.size() != 1) {
+                if (errorReporter) {
+                    errorReporter->reportError(line, column, "StdLib Error", 
+                        "Expected 1 argument but got " + std::to_string(args.size()) + ".", "", true);
+                }
+                throw std::runtime_error("Expected 1 argument but got " + std::to_string(args.size()) + ".");
+            }
+            
+            return Value(interpreter.stringify(args[0]));
+        });
+    env->define("toString", Value(toStringFunc.get()));
+    
+    // Store the shared_ptr in the interpreter to keep it alive
+    interpreter.addBuiltinFunction(toStringFunc);
+
+    // Create a built-in print function
+    auto printFunc = std::make_shared<BuiltinFunction>("print", 
+        [&interpreter, errorReporter](std::vector<Value> args, int line, int column) -> Value {
+            if (args.size() != 1) {
+                if (errorReporter) {
+                    errorReporter->reportError(line, column, "StdLib Error", 
+                        "Expected 1 argument but got " + std::to_string(args.size()) + ".", "", true);
+                }
+                throw std::runtime_error("Expected 1 argument but got " + std::to_string(args.size()) + ".");
+            }
+            // Use the interpreter's stringify function
+            std::cout << interpreter.stringify(args[0]) << std::endl;
+            return NONE_VALUE;
+        });
+    env->define("print", Value(printFunc.get()));
+    
+    // Store the shared_ptr in the interpreter to keep it alive
+    interpreter.addBuiltinFunction(printFunc);
+
+    // Create a built-in printRaw function (no newline, for ANSI escape sequences)
+    auto printRawFunc = std::make_shared<BuiltinFunction>("printRaw", 
+        [&interpreter, errorReporter](std::vector<Value> args, int line, int column) -> Value {
+            if (args.size() != 1) {
+                if (errorReporter) {
+                    errorReporter->reportError(line, column, "StdLib Error", 
+                        "Expected 1 argument but got " + std::to_string(args.size()) + ".", "", true);
+                }
+                throw std::runtime_error("Expected 1 argument but got " + std::to_string(args.size()) + ".");
+            }
+            // Print without newline and flush immediately for ANSI escape sequences
+            std::cout << interpreter.stringify(args[0]) << std::flush;
+            return NONE_VALUE;
+        });
+    env->define("printRaw", Value(printRawFunc.get()));
+    
+    // Store the shared_ptr in the interpreter to keep it alive
+    interpreter.addBuiltinFunction(printRawFunc);
+
+    // Create a built-in len function for arrays and strings
+    auto lenFunc = std::make_shared<BuiltinFunction>("len", 
+        [&interpreter, errorReporter](std::vector<Value> args, int line, int column) -> Value {
+            if (args.size() != 1) {
+                if (errorReporter) {
+                    errorReporter->reportError(line, column, "StdLib Error", 
+                        "Expected 1 argument but got " + std::to_string(args.size()) + ".", "", true);
+                }
+                throw std::runtime_error("Expected 1 argument but got " + std::to_string(args.size()) + ".");
+            }
+            
+            if (args[0].isArray()) {
+                return Value(static_cast<double>(args[0].asArray().size()));
+            } else if (args[0].isString()) {
+                return Value(static_cast<double>(args[0].asString().length()));
+            } else {
+                if (errorReporter) {
+                    errorReporter->reportError(line, column, "StdLib Error", 
+                        "len() can only be used on arrays and strings", "", true);
+                }
+                throw std::runtime_error("len() can only be used on arrays and strings");
+            }
+        });
+    env->define("len", Value(lenFunc.get()));
+    
+    // Store the shared_ptr in the interpreter to keep it alive
+    interpreter.addBuiltinFunction(lenFunc);
+
+    // Create a built-in push function for arrays
+    auto pushFunc = std::make_shared<BuiltinFunction>("push", 
+        [&interpreter, errorReporter](std::vector<Value> args, int line, int column) -> Value {
+            if (args.size() < 2) {
+                if (errorReporter) {
+                    errorReporter->reportError(line, column, "StdLib Error", 
+                        "Expected at least 2 arguments but got " + std::to_string(args.size()) + ".", "", true);
+                }
+                throw std::runtime_error("Expected at least 2 arguments but got " + std::to_string(args.size()) + ".");
+            }
+            
+            if (!args[0].isArray()) {
+                if (errorReporter) {
+                    errorReporter->reportError(line, column, "StdLib Error", 
+                        "First argument to push() must be an array", "", true);
+                }
+                throw std::runtime_error("First argument to push() must be an array");
+            }
+            
+            // Get the array and modify it in place
+            std::vector<Value>& arr = args[0].asArray();
+            
+            // Add all arguments except the first one (which is the array)
+            for (size_t i = 1; i < args.size(); i++) {
+                arr.push_back(args[i]);
+            }
+            
+            return args[0]; // Return the modified array
+        });
+    env->define("push", Value(pushFunc.get()));
+    interpreter.addBuiltinFunction(pushFunc);
+
+    // Create a built-in pop function for arrays
+    auto popFunc = std::make_shared<BuiltinFunction>("pop", 
+        [&interpreter, errorReporter](std::vector<Value> args, int line, int column) -> Value {
+            if (args.size() != 1) {
+                if (errorReporter) {
+                    errorReporter->reportError(line, column, "StdLib Error", 
+                        "Expected 1 argument but got " + std::to_string(args.size()) + ".", "", true);
+                }
+                throw std::runtime_error("Expected 1 argument but got " + std::to_string(args.size()) + ".");
+            }
+            
+            if (!args[0].isArray()) {
+                if (errorReporter) {
+                    errorReporter->reportError(line, column, "StdLib Error", 
+                        "pop() can only be used on arrays", "", true);
+                }
+                throw std::runtime_error("pop() can only be used on arrays");
+            }
+            
+            std::vector<Value>& arr = args[0].asArray();
+            if (arr.empty()) {
+                if (errorReporter) {
+                    errorReporter->reportError(line, column, "StdLib Error", 
+                        "Cannot pop from empty array", "", true);
+                }
+                throw std::runtime_error("Cannot pop from empty array");
+            }
+            
+            // Get the last element and remove it from the array
+            Value lastElement = arr.back();
+            arr.pop_back();
+            
+            return lastElement; // Return the popped element
+        });
+    env->define("pop", Value(popFunc.get()));
+    interpreter.addBuiltinFunction(popFunc);
+
+    // Create a built-in assert function
+    auto assertFunc = std::make_shared<BuiltinFunction>("assert",
+        [errorReporter](std::vector<Value> args, int line, int column) -> Value {
+            if (args.size() != 1 && args.size() != 2) {
+                if (errorReporter) {
+                    errorReporter->reportError(line, column, "StdLib Error", 
+                        "Expected 1 or 2 arguments but got " + std::to_string(args.size()) + ".", "", true);
+                }
+                throw std::runtime_error("Expected 1 or 2 arguments but got " + std::to_string(args.size()) + ".");
+            }
+            
+            // Simple truthy check without calling interpreter.isTruthy
+            bool isTruthy = false;
+            if (args[0].isBoolean()) {
+                isTruthy = args[0].asBoolean();
+            } else if (args[0].isNone()) {
+                isTruthy = false;
+            } else {
+                isTruthy = true; // Numbers, strings, functions are truthy
+            }
+            
+            if (!isTruthy) {
+                std::string message = "Assertion failed: condition is false";
+                if (args.size() == 2) {
+                    if (args[1].isString()) {
+                        message += " - " + std::string(args[1].asString());
+                    }
+                }
+                if (errorReporter) {
+                    errorReporter->reportError(line, column, "StdLib Error", message, "", true);
+                }
+                throw std::runtime_error(message);
+            }
+            
+            return NONE_VALUE;
+        });
+    env->define("assert", Value(assertFunc.get()));
+    
+    // Store the shared_ptr in the interpreter to keep it alive
+    interpreter.addBuiltinFunction(assertFunc);
+
+    // Create a built-in time function (returns microseconds since Unix epoch)
+    auto timeFunc = std::make_shared<BuiltinFunction>("time",
+        [errorReporter](std::vector<Value> args, int line, int column) -> Value {
+            if (args.size() != 0) {
+                if (errorReporter) {
+                    errorReporter->reportError(line, column, "StdLib Error", 
+                        "Expected 0 arguments but got " + std::to_string(args.size()) + ".", "", true);
+                }
+                throw std::runtime_error("Expected 0 arguments but got " + std::to_string(args.size()) + ".");
+            }
+            
+            auto now = std::chrono::high_resolution_clock::now();
+            auto duration = now.time_since_epoch();
+            auto microseconds = std::chrono::duration_cast<std::chrono::microseconds>(duration).count();
+            
+            return Value(static_cast<double>(microseconds));
+        });
+    env->define("time", Value(timeFunc.get()));
+    
+    // Store the shared_ptr in the interpreter to keep it alive
+    interpreter.addBuiltinFunction(timeFunc);
+
+    // Create a built-in input function
+    auto inputFunc = std::make_shared<BuiltinFunction>("input",
+        [&interpreter, errorReporter](std::vector<Value> args, int line, int column) -> Value {
+            if (args.size() > 1) {
+                if (errorReporter) {
+                    errorReporter->reportError(line, column, "StdLib Error", 
+                        "Expected 0 or 1 arguments but got " + std::to_string(args.size()) + ".", "", true);
+                }
+                throw std::runtime_error("Expected 0 or 1 arguments but got " + std::to_string(args.size()) + ".");
+            }
+            
+            // Optional prompt
+            if (args.size() == 1) {
+                std::cout << interpreter.stringify(args[0]);
+            }
+            
+            // Get user input
+            std::string userInput;
+            std::getline(std::cin, userInput);
+            
+            return Value(userInput);
+        });
+    env->define("input", Value(inputFunc.get()));
+    
+    // Store the shared_ptr in the interpreter to keep it alive
+    interpreter.addBuiltinFunction(inputFunc);
+
+    // Create a built-in type function
+    auto typeFunc = std::make_shared<BuiltinFunction>("type",
+        [errorReporter](std::vector<Value> args, int line, int column) -> Value {
+            if (args.size() != 1) {
+                if (errorReporter) {
+                    errorReporter->reportError(line, column, "StdLib Error", 
+                        "Expected 1 argument but got " + std::to_string(args.size()) + ".", "", true);
+                }
+                throw std::runtime_error("Expected 1 argument but got " + std::to_string(args.size()) + ".");
+            }
+            
+            std::string typeName;
+            if (args[0].isNumber()) {
+                typeName = "number";
+            } else if (args[0].isString()) {
+                typeName = "string";
+            } else if (args[0].isBoolean()) {
+                typeName = "boolean";
+            } else if (args[0].isNone()) {
+                typeName = "none";
+            } else if (args[0].isFunction()) {
+                typeName = "function";
+            } else if (args[0].isBuiltinFunction()) {
+                typeName = "builtin_function";
+            } else if (args[0].isArray()) {
+                typeName = "array";
+            } else {
+                typeName = "unknown";
+            }
+            
+            return Value(typeName);
+        });
+    env->define("type", Value(typeFunc.get()));
+    
+    // Store the shared_ptr in the interpreter to keep it alive
+    interpreter.addBuiltinFunction(typeFunc);
+
+    // Create a built-in toNumber function for string-to-number conversion
+    auto toNumberFunc = std::make_shared<BuiltinFunction>("toNumber",
+        [](std::vector<Value> args, int line, int column) -> Value {
+            if (args.size() != 1) {
+                return NONE_VALUE;  // Return none for wrong argument count
+            }
+            
+            if (!args[0].isString()) {
+                return NONE_VALUE;  // Return none for wrong type
+            }
+            
+            std::string str = args[0].asString();
+            
+            // Remove leading/trailing whitespace
+            str.erase(0, str.find_first_not_of(" \t\n\r"));
+            str.erase(str.find_last_not_of(" \t\n\r") + 1);
+            
+            if (str.empty()) {
+                return NONE_VALUE;  // Return none for empty string
+            }
+            
+            try {
+                double value = std::stod(str);
+                return Value(value);
+            } catch (const std::invalid_argument&) {
+                return NONE_VALUE;  // Return none for invalid conversion
+            } catch (const std::out_of_range&) {
+                return NONE_VALUE;  // Return none for out of range
+            }
+        });
+    env->define("toNumber", Value(toNumberFunc.get()));
+    
+    // Store the shared_ptr in the interpreter to keep it alive
+    interpreter.addBuiltinFunction(toNumberFunc);
+
+    // Create a built-in toInt function for float-to-integer conversion
+    auto toIntFunc = std::make_shared<BuiltinFunction>("toInt",
+        [errorReporter](std::vector<Value> args, int line, int column) -> Value {
+            if (args.size() != 1) {
+                if (errorReporter) {
+                    errorReporter->reportError(line, column, "StdLib Error", 
+                        "Expected 1 argument but got " + std::to_string(args.size()) + ".", "", true);
+                }
+                throw std::runtime_error("Expected 1 argument but got " + std::to_string(args.size()) + ".");
+            }
+            
+            if (!args[0].isNumber()) {
+                if (errorReporter) {
+                    errorReporter->reportError(line, column, "StdLib Error", 
+                        "toInt() can only be used on numbers", "", true);
+                }
+                throw std::runtime_error("toInt() can only be used on numbers");
+            }
+            
+            // Convert to integer by truncating (same as | 0)
+            double value = args[0].asNumber();
+            return Value(static_cast<double>(static_cast<long long>(value)));
+        });
+    env->define("toInt", Value(toIntFunc.get()));
+    
+    // Store the shared_ptr in the interpreter to keep it alive
+    interpreter.addBuiltinFunction(toIntFunc);
+
+    // Create a built-in toBoolean function for explicit boolean conversion
+    auto toBooleanFunc = std::make_shared<BuiltinFunction>("toBoolean",
+        [errorReporter](std::vector<Value> args, int line, int column) -> Value {
+            if (args.size() != 1) {
+                if (errorReporter) {
+                    errorReporter->reportError(line, column, "StdLib Error", 
+                        "Expected 1 argument but got " + std::to_string(args.size()) + ".", "", true);
+                }
+                throw std::runtime_error("Expected 1 argument but got " + std::to_string(args.size()) + ".");
+            }
+            
+            // Use the same logic as isTruthy() for consistency
+            Value value = args[0];
+            
+            if (value.isNone()) {
+                return Value(false);
+            }
+            
+            if (value.isBoolean()) {
+                return value;  // Already a boolean
+            }
+            
+            if (value.isNumber()) {
+                return Value(value.asNumber() != 0.0);
+            }
+            
+            if (value.isString()) {
+                return Value(!value.asString().empty());
+            }
+            
+            // For any other type (functions, etc.), consider them truthy
+            return Value(true);
+        });
+    env->define("toBoolean", Value(toBooleanFunc.get()));
+    
+    // Store the shared_ptr in the interpreter to keep it alive
+    interpreter.addBuiltinFunction(toBooleanFunc);
+
+    // Create a built-in exit function to terminate the program
+    auto exitFunc = std::make_shared<BuiltinFunction>("exit",
+        [](std::vector<Value> args, int line, int column) -> Value {
+            int exitCode = 0;  // Default exit code
+            
+            if (args.size() > 0) {
+                if (args[0].isNumber()) {
+                    exitCode = static_cast<int>(args[0].asNumber());
+                }
+                // If not a number, just use default exit code 0
+            }
+            
+            std::exit(exitCode);
+            return NONE_VALUE;  // This line should never be reached
+        });
+    env->define("exit", Value(exitFunc.get()));
+    
+    // Store the shared_ptr in the interpreter to keep it alive
+    interpreter.addBuiltinFunction(exitFunc);
+
+    // Create a built-in sleep function for animations and timing
+    auto sleepFunc = std::make_shared<BuiltinFunction>("sleep",
+        [](std::vector<Value> args, int line, int column) -> Value {
+            if (args.size() != 1) {
+                return NONE_VALUE;  // Return none for wrong argument count
+            }
+            
+            if (!args[0].isNumber()) {
+                return NONE_VALUE;  // Return none for wrong type
+            }
+            
+            double seconds = args[0].asNumber();
+            if (seconds < 0) {
+                return NONE_VALUE;  // Return none for negative time
+            }
+            
+            // Convert to milliseconds and sleep
+            int milliseconds = static_cast<int>(seconds * 1000);
+            std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
+            
+            return NONE_VALUE;
+        });
+    env->define("sleep", Value(sleepFunc.get()));
+    
+    // Store the shared_ptr in the interpreter to keep it alive
+    interpreter.addBuiltinFunction(sleepFunc);
+
+    // Create a built-in random function
+    auto randomFunc = std::make_shared<BuiltinFunction>("random",
+        [errorReporter](std::vector<Value> args, int line, int column) -> Value {
+            if (args.size() != 0) {
+                if (errorReporter) {
+                    errorReporter->reportError(line, column, "StdLib Error", 
+                        "Expected 0 arguments but got " + std::to_string(args.size()) + ".", "", true);
+                }
+                throw std::runtime_error("Expected 0 arguments but got " + std::to_string(args.size()) + ".");
+            }
+            
+            return Value(static_cast<double>(rand()) / RAND_MAX);
+        });
+    env->define("random", Value(randomFunc.get()));
+    
+    // Store the shared_ptr in the interpreter to keep it alive
+    interpreter.addBuiltinFunction(randomFunc);
+
+    // Create a built-in eval function (like Python's eval)
+    auto evalFunc = std::make_shared<BuiltinFunction>("eval",
+        [&interpreter, errorReporter](std::vector<Value> args, int line, int column) -> Value {
+            if (args.size() != 1) {
+                if (errorReporter) {
+                    errorReporter->reportError(line, column, "Invalid Arguments", 
+                        "eval expects exactly 1 argument (string)", "eval");
+                }
+                throw std::runtime_error("eval expects exactly 1 argument");
+            }
+            
+            if (!args[0].isString()) {
+                if (errorReporter) {
+                    errorReporter->reportError(line, column, "Invalid Type", 
+                        "eval argument must be a string", "eval");
+                }
+                throw std::runtime_error("eval argument must be a string");
+            }
+            
+            std::string code = args[0].asString();
+            
+            try {
+                // Create a new lexer for the code string
+                Lexer lexer;
+                lexer.setErrorReporter(errorReporter);
+                std::vector<Token> tokens = lexer.Tokenize(code);
+                
+                // Create a new parser
+                Parser parser(tokens);
+                parser.setErrorReporter(errorReporter);
+                std::vector<std::shared_ptr<Stmt>> statements = parser.parse();
+                
+                // Execute the statements in the current environment
+                // Note: This runs in the current scope, so variables are shared
+                interpreter.interpret(statements);
+                
+                // For now, return NONE_VALUE since we don't have a way to get the last expression value
+                // In a more sophisticated implementation, we'd track the last expression result
+                return NONE_VALUE;
+                
+            } catch (const std::exception& e) {
+                if (errorReporter) {
+                    errorReporter->reportError(line, column, "Eval Error", 
+                        "Failed to evaluate code: " + std::string(e.what()), code);
+                }
+                throw std::runtime_error("eval failed: " + std::string(e.what()));
+            }
+        });
+    env->define("eval", Value(evalFunc.get()));
+    
+    // Store the shared_ptr in the interpreter to keep it alive
+    interpreter.addBuiltinFunction(evalFunc);
+
+} 

source/ErrorReporter.cpp

@@ -59,6 +59,7 @@ void ErrorReporter::loadSource(const std::string& source, const std::string& fil
 void ErrorReporter::reportError(int line, int column, const std::string& errorType, const std::string& message, const std::string& operator_, bool showArrow) {
     hadError = true;
     displaySourceContext(line, column, errorType, message, operator_, showArrow);
+    std::cout.flush(); // Ensure output is flushed before any exception is thrown
 }
 
 void ErrorReporter::reportErrorWithContext(const ErrorContext& context) {

source/Expression.cpp

@@ -1,5 +1,3 @@
-//
+
-// Created by Bobby Lucero on 5/21/23.
-//
 
 #include "../headers/Expression.h"

source/Lexer.cpp

@@ -35,6 +35,16 @@ std::vector<Token> Lexer::Tokenize(std::string source){
             tokens.push_back(Token{CLOSE_BRACE, std::string(1, t), line, column});
             advance();
         }
+        else if(t == '[')
+        {
+            tokens.push_back(Token{OPEN_BRACKET, std::string(1, t), line, column});
+            advance();
+        }
+        else if(t == ']')
+        {
+            tokens.push_back(Token{CLOSE_BRACKET, std::string(1, t), line, column});
+            advance();
+        }
         else if(t == ',')
         {
             tokens.push_back(Token{COMMA, std::string(1, t), line, column});
@@ -483,8 +493,11 @@ char Lexer::peekNext()
 std::string Lexer::parseEscapeCharacters(const std::string& input) {
     std::string output;
     bool escapeMode = false;
+    size_t i = 0;
+
+    while (i < input.length()) {
+        char c = input[i];
         
-    for (char c : input) {
         if (escapeMode) {
             switch (c) {
                 case 'n':
@@ -499,6 +512,28 @@ std::string Lexer::parseEscapeCharacters(const std::string& input) {
                 case '\\':
                     output += '\\';
                     break;
+                case '0':
+                    output += '\0';
+                    break;
+                case 'r':
+                    output += '\r';
+                    break;
+                case 'a':
+                    output += '\a';
+                    break;
+                case 'b':
+                    output += '\b';
+                    break;
+                case 'f':
+                    output += '\f';
+                    break;
+                case 'v':
+                    output += '\v';
+                    break;
+                case 'e':
+                    // ANSI escape sequence
+                    output += '\033';
+                    break;
                 default:
                     throw runtime_error("Invalid escape character: " + std::string(1, c));
             }
@@ -508,6 +543,7 @@ std::string Lexer::parseEscapeCharacters(const std::string& input) {
         } else {
             output += c;
         }
+        i++;
     }
 
     return output;

source/Parser.cpp

@@ -1,5 +1,5 @@
 //
-// Created by Bobby Lucero on 5/26/23.
+
 //
 #include "../headers/Parser.h"
 #include <stdexcept>
@@ -135,6 +135,11 @@ sptr(Expr) Parser::assignmentExpression()
             Token name = std::dynamic_pointer_cast<VarExpr>(expr)->name;
             return msptr(AssignExpr)(name, op, value);
         }
+        else if(std::dynamic_pointer_cast<ArrayIndexExpr>(expr))
+        {
+            auto arrayExpr = std::dynamic_pointer_cast<ArrayIndexExpr>(expr);
+            return msptr(ArrayAssignExpr)(arrayExpr->array, arrayExpr->index, value, arrayExpr->bracket);
+        }
         
         if (errorReporter) {
             errorReporter->reportError(op.line, op.column, "Parse Error",
@@ -216,13 +221,14 @@ sptr(Expr) Parser::unary()
         
         // Handle prefix increment/decrement
         if (op.type == PLUS_PLUS || op.type == MINUS_MINUS) {
-            // Ensure the operand is a variable
+            // Ensure the operand is a variable or array indexing
-            if (!std::dynamic_pointer_cast<VarExpr>(right)) {
+            if (!std::dynamic_pointer_cast<VarExpr>(right) && 
+                !std::dynamic_pointer_cast<ArrayIndexExpr>(right)) {
                 if (errorReporter) {
                     errorReporter->reportError(op.line, op.column, "Parse Error", 
-                        "Prefix increment/decrement can only be applied to variables", "");
+                        "Prefix increment/decrement can only be applied to variables or array elements", "");
                 }
-                throw std::runtime_error("Prefix increment/decrement can only be applied to variables.");
+                throw std::runtime_error("Prefix increment/decrement can only be applied to variables or array elements.");
             }
             return msptr(IncrementExpr)(right, op, true);  // true = prefix
         }
@@ -241,13 +247,14 @@ sptr(Expr) Parser::postfix()
     if (match({PLUS_PLUS, MINUS_MINUS})) {
         Token oper = previous();
         
-        // Ensure the expression is a variable
+        // Ensure the expression is a variable or array indexing
-        if (!std::dynamic_pointer_cast<VarExpr>(expr)) {
+        if (!std::dynamic_pointer_cast<VarExpr>(expr) && 
+            !std::dynamic_pointer_cast<ArrayIndexExpr>(expr)) {
             if (errorReporter) {
                 errorReporter->reportError(oper.line, oper.column, "Parse Error", 
-                    "Postfix increment/decrement can only be applied to variables", "");
+                    "Postfix increment/decrement can only be applied to variables or array elements", "");
             }
-            throw std::runtime_error("Postfix increment/decrement can only be applied to variables.");
+            throw std::runtime_error("Postfix increment/decrement can only be applied to variables or array elements.");
         }
         
         return msptr(IncrementExpr)(expr, oper, false);  // false = postfix
@@ -266,10 +273,7 @@ sptr(Expr) Parser::primary()
     if(match({STRING})) return msptr(LiteralExpr)(previous().lexeme, false, false, false);
 
     if(match( {IDENTIFIER})) {
-        if (check(OPEN_PAREN)) {
+        return call();
-            return finishCall(msptr(VarExpr)(previous()));
-        }
-        return msptr(VarExpr)(previous());
     }
 
     if(match({OPEN_PAREN}))
@@ -286,6 +290,10 @@ sptr(Expr) Parser::primary()
         return functionExpression();
     }
 
+    if(match({OPEN_BRACKET})) {
+        return arrayLiteral();
+    }
+
     if (errorReporter) {
         errorReporter->reportError(peek().line, peek().column, "Parse Error", 
             "Expression expected", "");
@@ -293,6 +301,37 @@ sptr(Expr) Parser::primary()
     throw std::runtime_error("Expression expected at: " + std::to_string(peek().line));
 }
 
+sptr(Expr) Parser::arrayLiteral()
+{
+    std::vector<sptr(Expr)> elements;
+    
+    if (!check(CLOSE_BRACKET)) {
+        do {
+            elements.push_back(expression());
+        } while (match({COMMA}));
+    }
+    
+    consume(CLOSE_BRACKET, "Expected ']' after array elements.");
+    return msptr(ArrayLiteralExpr)(elements);
+}
+
+sptr(Expr) Parser::call()
+{
+    sptr(Expr) expr = msptr(VarExpr)(previous());
+    
+    while (true) {
+        if (match({OPEN_PAREN})) {
+            expr = finishCall(expr);
+        } else if (match({OPEN_BRACKET})) {
+            expr = finishArrayIndex(expr);
+        } else {
+            break;
+        }
+    }
+    
+    return expr;
+}
+
 ///////////////////////////////////////////
 
 
@@ -406,12 +445,24 @@ sptr(Stmt) Parser::statement()
         // Look ahead to see if this is an assignment
         int currentPos = current;
         advance(); // consume identifier
+        
+        // Check for simple variable assignment
         if(match({EQUAL, PLUS_EQUAL, MINUS_EQUAL, STAR_EQUAL, SLASH_EQUAL, PERCENT_EQUAL,
                   BIN_AND_EQUAL, BIN_OR_EQUAL, BIN_XOR_EQUAL, BIN_SLEFT_EQUAL, BIN_SRIGHT_EQUAL})) {
             // Reset position and parse as assignment statement
             current = currentPos;
             return assignmentStatement();
         }
+        
+        // Check for array assignment (identifier followed by [)
+        if(match({OPEN_BRACKET})) {
+            // Reset position and parse as assignment expression
+            current = currentPos;
+            sptr(Expr) expr = assignmentExpression();
+            consume(SEMICOLON, "Expected ';' after assignment.");
+            return msptr(ExpressionStmt)(expr);
+        }
+        
         // Reset position and parse as expression statement
         current = currentPos;
     }
@@ -587,9 +638,6 @@ std::vector<sptr(Stmt)> Parser::block()
 sptr(Expr) Parser::finishCall(sptr(Expr) callee) {
     std::vector<sptr(Expr)> arguments;
     
-    // Consume the opening parenthesis
-    consume(OPEN_PAREN, "Expected '(' after function name.");
-    
     // Parse arguments if there are any
     if (!check(CLOSE_PAREN)) {
         do {
@@ -601,6 +649,12 @@ sptr(Expr) Parser::finishCall(sptr(Expr) callee) {
     return msptr(CallExpr)(callee, paren, arguments);
 }
 
+sptr(Expr) Parser::finishArrayIndex(sptr(Expr) array) {
+    sptr(Expr) index = expression();
+    Token bracket = consume(CLOSE_BRACKET, "Expected ']' after array index.");
+    return msptr(ArrayIndexExpr)(array, index, bracket);
+}
+
 bool Parser::match(const std::vector<TokenType>& types) {
     for(TokenType t : types)
     {

source/StdLib.cpp

@@ -1,263 +0,0 @@
-#include "../headers/StdLib.h"
-#include "../headers/Interpreter.h"
-#include "../headers/ErrorReporter.h"
-#include <chrono>
-
-void StdLib::addToEnvironment(std::shared_ptr<Environment> env, Interpreter& interpreter, ErrorReporter* errorReporter) {
-    // Create a built-in toString function
-    auto toStringFunc = std::make_shared<BuiltinFunction>("toString",
-        [&interpreter, errorReporter](std::vector<Value> args, int line, int column) -> Value {
-            if (args.size() != 1) {
-                if (errorReporter) {
-                    errorReporter->reportError(line, column, "StdLib Error", 
-                        "Expected 1 argument but got " + std::to_string(args.size()) + ".", "", true);
-                }
-                throw std::runtime_error("Expected 1 argument but got " + std::to_string(args.size()) + ".");
-            }
-            
-            return Value(interpreter.stringify(args[0]));
-        });
-    env->define("toString", Value(toStringFunc.get()));
-    
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(toStringFunc);
-
-    // Create a built-in print function
-    auto printFunc = std::make_shared<BuiltinFunction>("print", 
-        [&interpreter, errorReporter](std::vector<Value> args, int line, int column) -> Value {
-            if (args.size() != 1) {
-                if (errorReporter) {
-                    errorReporter->reportError(line, column, "StdLib Error", 
-                        "Expected 1 argument but got " + std::to_string(args.size()) + ".", "", true);
-                }
-                throw std::runtime_error("Expected 1 argument but got " + std::to_string(args.size()) + ".");
-            }
-            // Use the interpreter's stringify function
-            std::cout << interpreter.stringify(args[0]) << std::endl;
-            return NONE_VALUE;
-        });
-    env->define("print", Value(printFunc.get()));
-    
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(printFunc);
-
-    // Create a built-in assert function
-    auto assertFunc = std::make_shared<BuiltinFunction>("assert",
-        [errorReporter](std::vector<Value> args, int line, int column) -> Value {
-            if (args.size() != 1 && args.size() != 2) {
-                if (errorReporter) {
-                    errorReporter->reportError(line, column, "StdLib Error", 
-                        "Expected 1 or 2 arguments but got " + std::to_string(args.size()) + ".", "", true);
-                }
-                throw std::runtime_error("Expected 1 or 2 arguments but got " + std::to_string(args.size()) + ".");
-            }
-            
-            // Simple truthy check without calling interpreter.isTruthy
-            bool isTruthy = false;
-            if (args[0].isBoolean()) {
-                isTruthy = args[0].asBoolean();
-            } else if (args[0].isNone()) {
-                isTruthy = false;
-            } else {
-                isTruthy = true; // Numbers, strings, functions are truthy
-            }
-            
-            if (!isTruthy) {
-                std::string message = "Assertion failed: condition is false";
-                if (args.size() == 2) {
-                    if (args[1].isString()) {
-                        message += " - " + std::string(args[1].asString());
-                    }
-                }
-                if (errorReporter) {
-                    errorReporter->reportError(line, column, "StdLib Error", message, "", true);
-                }
-                throw std::runtime_error(message);
-            }
-            
-            return NONE_VALUE;
-        });
-    env->define("assert", Value(assertFunc.get()));
-    
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(assertFunc);
-
-    // Create a built-in time function (returns microseconds since Unix epoch)
-    auto timeFunc = std::make_shared<BuiltinFunction>("time",
-        [errorReporter](std::vector<Value> args, int line, int column) -> Value {
-            if (args.size() != 0) {
-                if (errorReporter) {
-                    errorReporter->reportError(line, column, "StdLib Error", 
-                        "Expected 0 arguments but got " + std::to_string(args.size()) + ".", "", true);
-                }
-                throw std::runtime_error("Expected 0 arguments but got " + std::to_string(args.size()) + ".");
-            }
-            
-            auto now = std::chrono::high_resolution_clock::now();
-            auto duration = now.time_since_epoch();
-            auto microseconds = std::chrono::duration_cast<std::chrono::microseconds>(duration).count();
-            
-            return Value(static_cast<double>(microseconds));
-        });
-    env->define("time", Value(timeFunc.get()));
-    
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(timeFunc);
-
-    // Create a built-in input function
-    auto inputFunc = std::make_shared<BuiltinFunction>("input",
-        [&interpreter, errorReporter](std::vector<Value> args, int line, int column) -> Value {
-            if (args.size() > 1) {
-                if (errorReporter) {
-                    errorReporter->reportError(line, column, "StdLib Error", 
-                        "Expected 0 or 1 arguments but got " + std::to_string(args.size()) + ".", "", true);
-                }
-                throw std::runtime_error("Expected 0 or 1 arguments but got " + std::to_string(args.size()) + ".");
-            }
-            
-            // Optional prompt
-            if (args.size() == 1) {
-                std::cout << interpreter.stringify(args[0]);
-            }
-            
-            // Get user input
-            std::string userInput;
-            std::getline(std::cin, userInput);
-            
-            return Value(userInput);
-        });
-    env->define("input", Value(inputFunc.get()));
-    
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(inputFunc);
-
-    // Create a built-in type function
-    auto typeFunc = std::make_shared<BuiltinFunction>("type",
-        [errorReporter](std::vector<Value> args, int line, int column) -> Value {
-            if (args.size() != 1) {
-                if (errorReporter) {
-                    errorReporter->reportError(line, column, "StdLib Error", 
-                        "Expected 1 argument but got " + std::to_string(args.size()) + ".", "", true);
-                }
-                throw std::runtime_error("Expected 1 argument but got " + std::to_string(args.size()) + ".");
-            }
-            
-            std::string typeName;
-            if (args[0].isNumber()) {
-                typeName = "number";
-            } else if (args[0].isString()) {
-                typeName = "string";
-            } else if (args[0].isBoolean()) {
-                typeName = "boolean";
-            } else if (args[0].isNone()) {
-                typeName = "none";
-            } else if (args[0].isFunction()) {
-                typeName = "function";
-            } else if (args[0].isBuiltinFunction()) {
-                typeName = "builtin_function";
-            } else {
-                typeName = "unknown";
-            }
-            
-            return Value(typeName);
-        });
-    env->define("type", Value(typeFunc.get()));
-    
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(typeFunc);
-
-    // Create a built-in toNumber function for string-to-number conversion
-    auto toNumberFunc = std::make_shared<BuiltinFunction>("toNumber",
-        [](std::vector<Value> args, int line, int column) -> Value {
-            if (args.size() != 1) {
-                return NONE_VALUE;  // Return none for wrong argument count
-            }
-            
-            if (!args[0].isString()) {
-                return NONE_VALUE;  // Return none for wrong type
-            }
-            
-            std::string str = args[0].asString();
-            
-            // Remove leading/trailing whitespace
-            str.erase(0, str.find_first_not_of(" \t\n\r"));
-            str.erase(str.find_last_not_of(" \t\n\r") + 1);
-            
-            if (str.empty()) {
-                return NONE_VALUE;  // Return none for empty string
-            }
-            
-            try {
-                double value = std::stod(str);
-                return Value(value);
-            } catch (const std::invalid_argument&) {
-                return NONE_VALUE;  // Return none for invalid conversion
-            } catch (const std::out_of_range&) {
-                return NONE_VALUE;  // Return none for out of range
-            }
-        });
-    env->define("toNumber", Value(toNumberFunc.get()));
-    
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(toNumberFunc);
-
-    // Create a built-in toBoolean function for explicit boolean conversion
-    auto toBooleanFunc = std::make_shared<BuiltinFunction>("toBoolean",
-        [errorReporter](std::vector<Value> args, int line, int column) -> Value {
-            if (args.size() != 1) {
-                if (errorReporter) {
-                    errorReporter->reportError(line, column, "StdLib Error", 
-                        "Expected 1 argument but got " + std::to_string(args.size()) + ".", "", true);
-                }
-                throw std::runtime_error("Expected 1 argument but got " + std::to_string(args.size()) + ".");
-            }
-            
-            // Use the same logic as isTruthy() for consistency
-            Value value = args[0];
-            
-            if (value.isNone()) {
-                return Value(false);
-            }
-            
-            if (value.isBoolean()) {
-                return value;  // Already a boolean
-            }
-            
-            if (value.isNumber()) {
-                return Value(value.asNumber() != 0.0);
-            }
-            
-            if (value.isString()) {
-                return Value(!value.asString().empty());
-            }
-            
-            // For any other type (functions, etc.), consider them truthy
-            return Value(true);
-        });
-    env->define("toBoolean", Value(toBooleanFunc.get()));
-    
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(toBooleanFunc);
-
-    // Create a built-in exit function to terminate the program
-    auto exitFunc = std::make_shared<BuiltinFunction>("exit",
-        [](std::vector<Value> args, int line, int column) -> Value {
-            int exitCode = 0;  // Default exit code
-            
-            if (args.size() > 0) {
-                if (args[0].isNumber()) {
-                    exitCode = static_cast<int>(args[0].asNumber());
-                }
-                // If not a number, just use default exit code 0
-            }
-            
-            std::exit(exitCode);
-            return NONE_VALUE;  // This line should never be reached
-        });
-    env->define("exit", Value(exitFunc.get()));
-    
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(exitFunc);
-
-
-} 

source/StdLib.cpp.backup

@@ -1,203 +0,0 @@
-#include "../headers/StdLib.h"
-#include "../headers/Interpreter.h"
-#include "../headers/ErrorReporter.h"
-#include <chrono>
-#include <iostream>
-#include <string>
-
-void StdLib::addToEnvironment(std::shared_ptr<Environment> env, Interpreter& interpreter, ErrorReporter* errorReporter) {
-    // toString function
-    auto toStringFunc = std::make_shared<BuiltinFunction>("toString",
-        [](std::vector<Value> args, int line, int column) -> Value {
-            if (args.size() != 1) {
-                throw std::runtime_error("toString() expects exactly 1 argument, got " + std::to_string(args.size()));
-            }
-            return Value(args[0].toString());
-        });
-
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(toStringFunc);
-    env->define("toString", Value(toStringFunc.get()));
-
-    // print function
-    auto printFunc = std::make_shared<BuiltinFunction>("print",
-        [](std::vector<Value> args, int line, int column) -> Value {
-            for (size_t i = 0; i < args.size(); i++) {
-                if (i > 0) std::cout << " ";
-                std::cout << args[i].toString();
-            }
-            std::cout << std::endl;
-            return NONE_VALUE;
-        });
-
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(printFunc);
-    env->define("print", Value(printFunc.get()));
-
-    // assert function
-    auto assertFunc = std::make_shared<BuiltinFunction>("assert",
-        [](std::vector<Value> args, int line, int column) -> Value {
-            if (args.size() < 1 || args.size() > 2) {
-                throw std::runtime_error("assert() expects 1 or 2 arguments, got " + std::to_string(args.size()));
-            }
-            
-            if (!args[0].isTruthy()) {
-                std::string message = args.size() == 2 ? args[1].toString() : "Assertion failed";
-                throw std::runtime_error("Assertion failed: " + message);
-            }
-            return NONE_VALUE;
-        });
-
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(assertFunc);
-    env->define("assert", Value(assertFunc.get()));
-
-    // time function
-    auto timeFunc = std::make_shared<BuiltinFunction>("time",
-        [](std::vector<Value> args, int line, int column) -> Value {
-            if (args.size() != 0) {
-                throw std::runtime_error("time() expects no arguments, got " + std::to_string(args.size()));
-            }
-            
-            auto now = std::chrono::high_resolution_clock::now();
-            auto duration = now.time_since_epoch();
-            auto seconds = std::chrono::duration_cast<std::chrono::seconds>(duration).count();
-            return Value(static_cast<double>(seconds));
-        });
-
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(timeFunc);
-    env->define("time", Value(timeFunc.get()));
-
-    // input function
-    auto inputFunc = std::make_shared<BuiltinFunction>("input",
-        [](std::vector<Value> args, int line, int column) -> Value {
-            if (args.size() > 1) {
-                throw std::runtime_error("input() expects 0 or 1 arguments, got " + std::to_string(args.size()));
-            }
-            
-            if (args.size() == 1) {
-                std::cout << args[0].toString();
-            }
-            
-            std::string line;
-            std::getline(std::cin, line);
-            return Value(line);
-        });
-
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(inputFunc);
-    env->define("input", Value(inputFunc.get()));
-
-    // type function
-    auto typeFunc = std::make_shared<BuiltinFunction>("type",
-        [](std::vector<Value> args, int line, int column) -> Value {
-            if (args.size() != 1) {
-                throw std::runtime_error("type() expects exactly 1 argument, got " + std::to_string(args.size()));
-            }
-            
-            if (args[0].isNumber()) return Value("number");
-            if (args[0].isString()) return Value("string");
-            if (args[0].isBoolean()) return Value("boolean");
-            if (args[0].isFunction()) return Value("function");
-            if (args[0].isBuiltinFunction()) return Value("builtin_function");
-            if (args[0].isThunk()) return Value("thunk");
-            if (args[0].isNone()) return Value("none");
-            
-            return Value("unknown");
-        });
-
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(typeFunc);
-    env->define("type", Value(typeFunc.get()));
-
-    // toNumber function
-    auto toNumberFunc = std::make_shared<BuiltinFunction>("toNumber",
-        [](std::vector<Value> args, int line, int column) -> Value {
-            if (args.size() != 1) {
-                throw std::runtime_error("toNumber() expects exactly 1 argument, got " + std::to_string(args.size()));
-            }
-            
-            if (args[0].isNumber()) return args[0];
-            if (args[0].isString()) {
-                try {
-                    return Value(std::stod(args[0].asString()));
-                } catch (...) {
-                    return Value(0.0);
-                }
-            }
-            if (args[0].isBoolean()) return Value(args[0].asBoolean() ? 1.0 : 0.0);
-            if (args[0].isNone()) return Value(0.0);
-            
-            return Value(0.0);
-        });
-
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(toNumberFunc);
-    env->define("toNumber", Value(toNumberFunc.get()));
-
-    // toBoolean function
-    auto toBooleanFunc = std::make_shared<BuiltinFunction>("toBoolean",
-        [](std::vector<Value> args, int line, int column) -> Value {
-            if (args.size() != 1) {
-                throw std::runtime_error("toBoolean() expects exactly 1 argument, got " + std::to_string(args.size()));
-            }
-            
-            return Value(args[0].isTruthy());
-        });
-
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(toBooleanFunc);
-    env->define("toBoolean", Value(toBooleanFunc.get()));
-
-    // exit function
-    auto exitFunc = std::make_shared<BuiltinFunction>("exit",
-        [](std::vector<Value> args, int line, int column) -> Value {
-            int code = 0;
-            if (args.size() == 1) {
-                if (args[0].isNumber()) {
-                    code = static_cast<int>(args[0].asNumber());
-                }
-            } else if (args.size() > 1) {
-                throw std::runtime_error("exit() expects 0 or 1 arguments, got " + std::to_string(args.size()));
-            }
-            std::exit(code);
-            return NONE_VALUE;
-        });
-
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(exitFunc);
-    env->define("exit", Value(exitFunc.get()));
-
-    // cleanup functions
-    auto cleanupFunc = std::make_shared<BuiltinFunction>("cleanup",
-        [&interpreter](std::vector<Value> args, int line, int column) -> Value {
-            if (args.size() != 0) {
-                throw std::runtime_error("cleanup() expects no arguments, got " + std::to_string(args.size()));
-            }
-            
-            interpreter.cleanupUnusedFunctions();
-            interpreter.cleanupUnusedThunks();
-            return NONE_VALUE;
-        });
-
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(cleanupFunc);
-    env->define("cleanup", Value(cleanupFunc.get()));
-
-    // getFunctionCount function
-    auto getFunctionCountFunc = std::make_shared<BuiltinFunction>("getFunctionCount",
-        [&interpreter](std::vector<Value> args, int line, int column) -> Value {
-            if (args.size() != 0) {
-                throw std::runtime_error("getFunctionCount() expects no arguments, got " + std::to_string(args.size()));
-            }
-            
-            // This would need to be exposed through the interpreter
-            // For now, return a placeholder
-            return Value(0.0);
-        });
-
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(getFunctionCountFunc);
-    env->define("getFunctionCount", Value(getFunctionCountFunc.get()));
-} 

source/StdLib.cpp.original

@@ -1,261 +0,0 @@
-#include "../headers/StdLib.h"
-#include "../headers/Interpreter.h"
-#include "../headers/ErrorReporter.h"
-#include <chrono>
-
-void StdLib::addToEnvironment(std::shared_ptr<Environment> env, Interpreter& interpreter, ErrorReporter* errorReporter) {
-    // Create a built-in toString function
-    auto toStringFunc = std::make_shared<BuiltinFunction>("toString",
-        [&interpreter, errorReporter](std::vector<Value> args, int line, int column) -> Value {
-            if (args.size() != 1) {
-                if (errorReporter) {
-                    errorReporter->reportError(line, column, "StdLib Error", 
-                        "Expected 1 argument but got " + std::to_string(args.size()) + ".", "", true);
-                }
-                throw std::runtime_error("Expected 1 argument but got " + std::to_string(args.size()) + ".");
-            }
-            
-            return Value(interpreter.stringify(args[0]));
-        });
-    env->define("toString", Value(toStringFunc.get()));
-    
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(toStringFunc);
-
-    // Create a built-in print function
-    auto printFunc = std::make_shared<BuiltinFunction>("print", 
-        [&interpreter, errorReporter](std::vector<Value> args, int line, int column) -> Value {
-            if (args.size() != 1) {
-                if (errorReporter) {
-                    errorReporter->reportError(line, column, "StdLib Error", 
-                        "Expected 1 argument but got " + std::to_string(args.size()) + ".", "", true);
-                }
-                throw std::runtime_error("Expected 1 argument but got " + std::to_string(args.size()) + ".");
-            }
-            // Use the interpreter's stringify function
-            std::cout << interpreter.stringify(args[0]) << std::endl;
-            return NONE_VALUE;
-        });
-    env->define("print", Value(printFunc.get()));
-    
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(printFunc);
-
-    // Create a built-in assert function
-    auto assertFunc = std::make_shared<BuiltinFunction>("assert",
-        [errorReporter](std::vector<Value> args, int line, int column) -> Value {
-            if (args.size() != 1 && args.size() != 2) {
-                if (errorReporter) {
-                    errorReporter->reportError(line, column, "StdLib Error", 
-                        "Expected 1 or 2 arguments but got " + std::to_string(args.size()) + ".", "", true);
-                }
-                throw std::runtime_error("Expected 1 or 2 arguments but got " + std::to_string(args.size()) + ".");
-            }
-            
-            // Simple truthy check without calling interpreter.isTruthy
-            bool isTruthy = false;
-            if (args[0].isBoolean()) {
-                isTruthy = args[0].asBoolean();
-            } else if (args[0].isNone()) {
-                isTruthy = false;
-            } else {
-                isTruthy = true; // Numbers, strings, functions are truthy
-            }
-            
-            if (!isTruthy) {
-                std::string message = "Assertion failed: condition is false";
-                if (args.size() == 2) {
-                    if (args[1].isString()) {
-                        message += " - " + std::string(args[1].asString());
-                    }
-                }
-                if (errorReporter) {
-                    errorReporter->reportError(line, column, "StdLib Error", message, "", true);
-                }
-                throw std::runtime_error(message);
-            }
-            
-            return NONE_VALUE;
-        });
-    env->define("assert", Value(assertFunc.get()));
-    
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(assertFunc);
-
-    // Create a built-in time function (returns microseconds since Unix epoch)
-    auto timeFunc = std::make_shared<BuiltinFunction>("time",
-        [errorReporter](std::vector<Value> args, int line, int column) -> Value {
-            if (args.size() != 0) {
-                if (errorReporter) {
-                    errorReporter->reportError(line, column, "StdLib Error", 
-                        "Expected 0 arguments but got " + std::to_string(args.size()) + ".", "", true);
-                }
-                throw std::runtime_error("Expected 0 arguments but got " + std::to_string(args.size()) + ".");
-            }
-            
-            auto now = std::chrono::high_resolution_clock::now();
-            auto duration = now.time_since_epoch();
-            auto microseconds = std::chrono::duration_cast<std::chrono::microseconds>(duration).count();
-            
-            return Value(static_cast<double>(microseconds));
-        });
-    env->define("time", Value(timeFunc.get()));
-    
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(timeFunc);
-
-    // Create a built-in input function
-    auto inputFunc = std::make_shared<BuiltinFunction>("input",
-        [&interpreter, errorReporter](std::vector<Value> args, int line, int column) -> Value {
-            if (args.size() > 1) {
-                if (errorReporter) {
-                    errorReporter->reportError(line, column, "StdLib Error", 
-                        "Expected 0 or 1 arguments but got " + std::to_string(args.size()) + ".", "", true);
-                }
-                throw std::runtime_error("Expected 0 or 1 arguments but got " + std::to_string(args.size()) + ".");
-            }
-            
-            // Optional prompt
-            if (args.size() == 1) {
-                std::cout << interpreter.stringify(args[0]);
-            }
-            
-            // Get user input
-            std::string userInput;
-            std::getline(std::cin, userInput);
-            
-            return Value(userInput);
-        });
-    env->define("input", Value(inputFunc.get()));
-    
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(inputFunc);
-
-    // Create a built-in type function
-    auto typeFunc = std::make_shared<BuiltinFunction>("type",
-        [errorReporter](std::vector<Value> args, int line, int column) -> Value {
-            if (args.size() != 1) {
-                if (errorReporter) {
-                    errorReporter->reportError(line, column, "StdLib Error", 
-                        "Expected 1 argument but got " + std::to_string(args.size()) + ".", "", true);
-                }
-                throw std::runtime_error("Expected 1 argument but got " + std::to_string(args.size()) + ".");
-            }
-            
-            std::string typeName;
-            if (args[0].isNumber()) {
-                typeName = "number";
-            } else if (args[0].isString()) {
-                typeName = "string";
-            } else if (args[0].isBoolean()) {
-                typeName = "boolean";
-            } else if (args[0].isNone()) {
-                typeName = "none";
-            } else if (args[0].isFunction()) {
-                typeName = "function";
-            } else if (args[0].isBuiltinFunction()) {
-                typeName = "builtin_function";
-            } else {
-                typeName = "unknown";
-            }
-            
-            return Value(typeName);
-        });
-    env->define("type", Value(typeFunc.get()));
-    
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(typeFunc);
-
-    // Create a built-in toNumber function for string-to-number conversion
-    auto toNumberFunc = std::make_shared<BuiltinFunction>("toNumber",
-        [](std::vector<Value> args, int line, int column) -> Value {
-            if (args.size() != 1) {
-                return NONE_VALUE;  // Return none for wrong argument count
-            }
-            
-            if (!args[0].isString()) {
-                return NONE_VALUE;  // Return none for wrong type
-            }
-            
-            std::string str = args[0].asString();
-            
-            // Remove leading/trailing whitespace
-            str.erase(0, str.find_first_not_of(" \t\n\r"));
-            str.erase(str.find_last_not_of(" \t\n\r") + 1);
-            
-            if (str.empty()) {
-                return NONE_VALUE;  // Return none for empty string
-            }
-            
-            try {
-                double value = std::stod(str);
-                return Value(value);
-            } catch (const std::invalid_argument&) {
-                return NONE_VALUE;  // Return none for invalid conversion
-            } catch (const std::out_of_range&) {
-                return NONE_VALUE;  // Return none for out of range
-            }
-        });
-    env->define("toNumber", Value(toNumberFunc.get()));
-    
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(toNumberFunc);
-
-    // Create a built-in toBoolean function for explicit boolean conversion
-    auto toBooleanFunc = std::make_shared<BuiltinFunction>("toBoolean",
-        [errorReporter](std::vector<Value> args, int line, int column) -> Value {
-            if (args.size() != 1) {
-                if (errorReporter) {
-                    errorReporter->reportError(line, column, "StdLib Error", 
-                        "Expected 1 argument but got " + std::to_string(args.size()) + ".", "", true);
-                }
-                throw std::runtime_error("Expected 1 argument but got " + std::to_string(args.size()) + ".");
-            }
-            
-            // Use the same logic as isTruthy() for consistency
-            Value value = args[0];
-            
-            if (value.isNone()) {
-                return Value(false);
-            }
-            
-            if (value.isBoolean()) {
-                return value;  // Already a boolean
-            }
-            
-            if (value.isNumber()) {
-                return Value(value.asNumber() != 0.0);
-            }
-            
-            if (value.isString()) {
-                return Value(!value.asString().empty());
-            }
-            
-            // For any other type (functions, etc.), consider them truthy
-            return Value(true);
-        });
-    env->define("toBoolean", Value(toBooleanFunc.get()));
-    
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(toBooleanFunc);
-
-    // Create a built-in exit function to terminate the program
-    auto exitFunc = std::make_shared<BuiltinFunction>("exit",
-        [](std::vector<Value> args, int line, int column) -> Value {
-            int exitCode = 0;  // Default exit code
-            
-            if (args.size() > 0) {
-                if (args[0].isNumber()) {
-                    exitCode = static_cast<int>(args[0].asNumber());
-                }
-                // If not a number, just use default exit code 0
-            }
-            
-            std::exit(exitCode);
-            return NONE_VALUE;  // This line should never be reached
-        });
-    env->define("exit", Value(exitFunc.get()));
-    
-    // Store the shared_ptr in the interpreter to keep it alive
-    interpreter.addBuiltinFunction(exitFunc);
-} 

source/TypeWrapper.cpp

@@ -1,6 +1,4 @@
-//
+
-// Created by Bobby Lucero on 5/27/23.
-//
 #include "../headers/TypeWrapper.h"
 #include <iostream>
 

source/bob.cpp

@@ -45,6 +45,9 @@ void Bob::runPrompt()
             break;
         }
 
+        // Reset error state before each REPL command
+        errorReporter.resetErrorState();
+        
         // Load source code into error reporter for context
         errorReporter.loadSource(line, "REPL");
         

source/main.cpp

@@ -1,5 +1,5 @@
 //
-// Created by Bobby Lucero on 5/21/23.
+
 //
 #include "../headers/bob.h"
 

test_bob_language.bob

@@ -1528,15 +1528,6 @@ var edge_func = func() {
 };
 assert(type(edge_func()) == "none", "Anonymous function returning none should work");
 
-var edge_func2 = func(x) {
-    if (x == 0) {
-        return 0;
-    } else {
-        return edge_func2(x - 1) + 1;
-    }
-};
-assert(edge_func2(3) == 3, "Recursive anonymous function should work");
-
 print("Edge cases for new operators: PASS");
 
 // ========================================
@@ -2318,6 +2309,496 @@ assert(result15 == "valid range", "Ternary with multiple operators");
 
 print("Ternary operator: PASS");
 
+// ========================================
+// TEST 50: ARRAYS
+// ========================================
+print("\n--- Test 50: Arrays ---");
+
+// Array creation
+var emptyArray = [];
+assert(len(emptyArray) == 0, "Empty array length");
+
+var numberArray = [1, 2, 3, 4, 5];
+assert(len(numberArray) == 5, "Number array length");
+assert(numberArray[0] == 1, "Array indexing - first element");
+assert(numberArray[4] == 5, "Array indexing - last element");
+
+var mixedArray = [1, "hello", true, 3.14];
+assert(len(mixedArray) == 4, "Mixed array length");
+assert(mixedArray[0] == 1, "Mixed array - number");
+assert(mixedArray[1] == "hello", "Mixed array - string");
+assert(mixedArray[2] == true, "Mixed array - boolean");
+assert(mixedArray[3] == 3.14, "Mixed array - float");
+
+// Array assignment
+numberArray[2] = 99;
+assert(numberArray[2] == 99, "Array assignment");
+
+mixedArray[1] = "world";
+assert(mixedArray[1] == "world", "Array string assignment");
+
+// Array operations
+var testArray = [1, 2, 3];
+push(testArray, 4);
+assert(len(testArray) == 4, "Array push - length");
+assert(testArray[3] == 4, "Array push - value");
+
+var poppedValue = pop(testArray);
+assert(poppedValue == 4, "Array pop - returned value");
+assert(len(testArray) == 3, "Array pop - length");
+
+// Array with nested arrays
+var nestedArray = [[1, 2], [3, 4], [5, 6]];
+assert(len(nestedArray) == 3, "Nested array length");
+assert(nestedArray[0][0] == 1, "Nested array indexing");
+
+// Array with function calls
+var funcArray = [func() { return 42; }, func() { return "hello"; }];
+assert(len(funcArray) == 2, "Function array length");
+assert(funcArray[0]() == 42, "Function array - first function");
+assert(funcArray[1]() == "hello", "Function array - second function");
+
+// Array edge cases
+var singleElement = [42];
+assert(len(singleElement) == 1, "Single element array");
+assert(singleElement[0] == 42, "Single element access");
+
+var largeArray = [];
+for (var i = 0; i < 100; i = i + 1) {
+    push(largeArray, i);
+}
+assert(len(largeArray) == 100, "Large array creation");
+assert(largeArray[50] == 50, "Large array access");
+
+print("Arrays: PASS");
+
+// ========================================
+// TEST 51: ARRAY BUILT-IN FUNCTIONS
+// ========================================
+print("\n--- Test 51: Array Built-in Functions ---");
+
+// len() function
+var testLenArray = [1, 2, 3, 4, 5];
+assert(len(testLenArray) == 5, "len() with array");
+
+var emptyLenArray = [];
+assert(len(emptyLenArray) == 0, "len() with empty array");
+
+// len() with strings
+assert(len("hello") == 5, "len() with string");
+assert(len("") == 0, "len() with empty string");
+
+// push() function
+var pushArray = [1, 2, 3];
+push(pushArray, 4);
+assert(len(pushArray) == 4, "push() - length check");
+assert(pushArray[3] == 4, "push() - value check");
+
+push(pushArray, "hello");
+assert(len(pushArray) == 5, "push() - mixed types");
+assert(pushArray[4] == "hello", "push() - string value");
+
+// pop() function
+var popArray = [1, 2, 3, 4];
+var popped1 = pop(popArray);
+assert(popped1 == 4, "pop() - returned value");
+assert(len(popArray) == 3, "pop() - length after pop");
+
+var popped2 = pop(popArray);
+assert(popped2 == 3, "pop() - second pop");
+assert(len(popArray) == 2, "pop() - length after second pop");
+
+// pop() edge cases
+var singlePopArray = [42];
+var singlePopped = pop(singlePopArray);
+assert(singlePopped == 42, "pop() - single element");
+assert(len(singlePopArray) == 0, "pop() - empty after single pop");
+
+print("Array built-in functions: PASS");
+
+// ========================================
+// TEST 52: NEW BUILT-IN FUNCTIONS
+// ========================================
+print("\n--- Test 52: New Built-in Functions ---");
+
+// sleep() function
+var startTime = time();
+sleep(1);  // Sleep for 10ms
+var endTime = time();
+assert(endTime > startTime, "sleep() - time elapsed");
+
+// random() function
+var random1 = random();
+var random2 = random();
+assert(random1 >= 0 && random1 <= 1, "random() - range check 1");
+assert(random2 >= 0 && random2 <= 1, "random() - range check 2");
+// Note: random1 and random2 might be equal, which is valid
+
+// printRaw() function
+// This is tested by the fact that it doesn't crash
+printRaw("printRaw test");
+
+// eval() function
+eval("var evalVar = 42;");
+assert(evalVar == 42, "eval() - variable creation");
+
+eval("print(\"eval test\");");  // Should print "eval test"
+
+var evalResult = eval("2 + 2;");
+// eval() currently returns none, so we just test it doesn't crash
+
+print("New built-in functions: PASS");
+
+// ========================================
+// TEST 53: ARRAY ERROR HANDLING
+// ========================================
+print("\n--- Test 53: Array Error Handling ---");
+
+var errorArray = [1, 2, 3];
+
+// Test array bounds checking
+// Note: These would cause runtime errors in the actual implementation
+// For now, we test that the array operations work correctly
+assert(len(errorArray) == 3, "Array bounds - valid length");
+
+// Test with valid indices
+assert(errorArray[0] == 1, "Array bounds - valid index 0");
+assert(errorArray[2] == 3, "Array bounds - valid index 2");
+
+print("Array error handling: PASS");
+
+// ========================================
+// TEST 54: ARRAY PERFORMANCE
+// ========================================
+print("\n--- Test 54: Array Performance ---");
+
+// Test large array operations
+var perfArray = [];
+var startTime = time();
+
+// Create large array
+for (var i = 0; i < 1000; i = i + 1) {
+    push(perfArray, i);
+}
+
+var midTime = time();
+assert(len(perfArray) == 1000, "Array performance - creation");
+
+// Access elements
+for (var j = 0; j < 100; j = j + 1) {
+    var value = perfArray[j * 10];
+    assert(value == j * 10, "Array performance - access");
+}
+
+var endTime = time();
+assert(endTime > startTime, "Array performance - time check");
+
+print("Array performance: PASS");
+
+// ========================================
+// TEST 55: ARRAY WITH FUNCTIONS
+// ========================================
+print("\n--- Test 55: Array with Functions ---");
+
+// Array of functions
+var funcArray2 = [
+    func() { return 1; },
+    func() { return 2; },
+    func() { return 3; }
+];
+
+assert(len(funcArray2) == 3, "Function array length");
+assert(funcArray2[0]() == 1, "Function array - call 1");
+assert(funcArray2[1]() == 2, "Function array - call 2");
+assert(funcArray2[2]() == 3, "Function array - call 3");
+
+// Function that returns array
+func createArray() {
+    return [1, 2, 3, 4, 5];
+}
+
+var returnedArray = createArray();
+assert(len(returnedArray) == 5, "Function returning array");
+assert(returnedArray[0] == 1, "Function returning array - first element");
+
+// Function that modifies array
+func modifyArray(arr) {
+    push(arr, 999);
+    return arr;
+}
+
+var modArray = [1, 2, 3];
+var modifiedArray = modifyArray(modArray);
+assert(len(modifiedArray) == 4, "Function modifying array");
+assert(modifiedArray[3] == 999, "Function modifying array - new value");
+
+print("Array with functions: PASS");
+
+// ========================================
+// TEST 56: ARRAY EDGE CASES AND ADVANCED FEATURES
+// ========================================
+print("\n--- Test 56: Array Edge Cases and Advanced Features ---");
+
+// Array with none values
+var noneArray = [1, none, 3, none, 5];
+assert(len(noneArray) == 5, "Array with none values - length");
+// Note: Bob doesn't support comparing none values with ==
+// We can test that the array contains the expected number of elements
+var noneCount = 0;
+for (var i = 0; i < len(noneArray); i = i + 1) {
+    if (type(noneArray[i]) == "none") {
+        noneCount = noneCount + 1;
+    }
+}
+assert(noneCount == 2, "Array with none values - none count");
+
+// Array with complex expressions
+var complexArray = [1 + 1, 2 * 3, 10 / 2, 5 - 2];
+assert(len(complexArray) == 4, "Complex array - length");
+assert(complexArray[0] == 2, "Complex array - addition");
+assert(complexArray[1] == 6, "Complex array - multiplication");
+assert(complexArray[2] == 5, "Complex array - division");
+assert(complexArray[3] == 3, "Complex array - subtraction");
+
+// Array with string operations
+var stringArray = ["hello" + " world", "test" * 2, "a" + "b" + "c"];
+assert(len(stringArray) == 3, "String array - length");
+assert(stringArray[0] == "hello world", "String array - concatenation");
+assert(stringArray[1] == "testtest", "String array - multiplication");
+assert(stringArray[2] == "abc", "String array - multiple concatenation");
+
+// Array with function results
+func getValue() { return 42; }
+func getString() { return "hello"; }
+
+var funcResultArray = [getValue(), getString(), 1 + 2];
+assert(len(funcResultArray) == 3, "Function result array - length");
+assert(funcResultArray[0] == 42, "Function result array - function call");
+assert(funcResultArray[1] == "hello", "Function result array - string function");
+assert(funcResultArray[2] == 3, "Function result array - expression");
+
+// Array with ternary operators
+var ternaryArray = [true ? 1 : 0, false ? "yes" : "no", 5 > 3 ? "big" : "small"];
+assert(len(ternaryArray) == 3, "Ternary array - length");
+assert(ternaryArray[0] == 1, "Ternary array - true condition");
+assert(ternaryArray[1] == "no", "Ternary array - false condition");
+assert(ternaryArray[2] == "big", "Ternary array - comparison condition");
+
+// Array with nested arrays and operations
+var nestedOpArray = [[1, 2], [3, 4], [5, 6]];
+nestedOpArray[0][0] = 99;
+assert(nestedOpArray[0][0] == 99, "Nested array operations - assignment");
+
+// Array with push/pop in expressions
+var exprArray = [1, 2, 3];
+var pushResult = push(exprArray, 4);
+assert(len(exprArray) == 4, "Array push in expression");
+assert(exprArray[3] == 4, "Array push result");
+
+var popResult = pop(exprArray);
+assert(popResult == 4, "Array pop result");
+assert(len(exprArray) == 3, "Array length after pop");
+
+print("Array edge cases and advanced features: PASS");
+
+// ========================================
+// TEST 57: ARRAY STRESS TESTING
+// ========================================
+print("\n--- Test 57: Array Stress Testing ---");
+
+// Large array creation and manipulation
+var stressArray = [];
+var startTime = time();
+
+// Create large array with mixed types
+for (var i = 0; i < 500; i = i + 1) {
+    if (i % 3 == 0) {
+        push(stressArray, i);
+    } else if (i % 3 == 1) {
+        push(stressArray, "string" + toString(i));
+    } else {
+        push(stressArray, i > 250);
+    }
+}
+
+var midTime = time();
+assert(len(stressArray) == 500, "Stress test - array creation");
+
+// Access and modify elements
+for (var j = 0; j < 100; j = j + 1) {
+    var index = j * 5;
+    if (index < len(stressArray)) {
+        stressArray[index] = "modified" + toString(j);
+    }
+}
+
+var endTime = time();
+assert(endTime > startTime, "Stress test - time validation");
+
+// Verify modifications
+assert(stressArray[0] == "modified0", "Stress test - modification verification");
+assert(stressArray[5] == "modified1", "Stress test - modification verification 2");
+
+print("Array stress testing: PASS");
+
+// ========================================
+// ARRAY INCREMENT/DECREMENT
+// ========================================
+print("\n--- Test 58: Array Increment/Decrement ---");
+var arr = [1, 2, 3, 4, 5];
+print("Original array: " + arr);
+
+// Test postfix increment
+arr[0]++;
+assert(arr[0] == 2, "Postfix increment failed");
+
+// Test prefix increment
+++arr[1];
+assert(arr[1] == 3, "Prefix increment failed");
+
+// Test postfix decrement
+arr[2]--;
+assert(arr[2] == 2, "Postfix decrement failed");
+
+// Test prefix decrement
+--arr[3];
+assert(arr[3] == 3, "Prefix decrement failed");
+
+print("Final array: " + arr);
+assert(arr[4] == 5, "Unmodified element changed");
+
+print("Array increment/decrement: PASS");
+
+// ========================================
+// CROSS-TYPE COMPARISON OPERATORS
+// ========================================
+print("\nTesting cross-type comparison operators...");
+
+// Test none comparisons
+var x = none;
+assert(x == none, "none == none should be true");
+assert(none == x, "none == x should be true");
+assert(x != 42, "none != 42 should be true");
+assert(42 != x, "42 != none should be true");
+assert(x != "hello", "none != string should be true");
+assert("hello" != x, "string != none should be true");
+assert(x != true, "none != true should be true");
+assert(true != x, "true != none should be true");
+
+// Test number and boolean comparisons
+assert(0 == false, "0 == false should be true");
+assert(false == 0, "false == 0 should be true");
+assert(1 == true, "1 == true should be true");
+assert(true == 1, "true == 1 should be true");
+assert(42 == true, "42 == true should be true");
+assert(true == 42, "true == 42 should be true");
+assert(0 != true, "0 != true should be true");
+assert(true != 0, "true != 0 should be true");
+
+// Test array comparisons
+var arr1 = [1, 2, 3];
+var arr2 = [1, 2, 3];
+var arr3 = [1, 2, 4];
+assert(arr1 == arr2, "Identical arrays should be equal");
+assert(arr1 != arr3, "Different arrays should not be equal");
+assert(arr1 != none, "Array != none should be true");
+assert(none != arr1, "none != array should be true");
+
+// Test function comparisons
+func testFunc() { return 42; }
+var func1 = testFunc;
+var func2 = testFunc;
+assert(func1 == func2, "Same function should be equal");
+assert(func1 != none, "Function != none should be true");
+assert(none != func1, "none != function should be true");
+
+// Test mixed type comparisons that should return false
+assert(42 != "42", "Number != string should be true");
+assert("42" != 42, "String != number should be true");
+assert(true != "true", "Boolean != string should be true");
+assert("true" != true, "String != boolean should be true");
+assert(arr1 != 42, "Array != number should be true");
+assert(42 != arr1, "Number != array should be true");
+
+print("Cross-type comparison operators: PASS");
+
+// ========================================
+// TEST 59: TOINT FUNCTION
+// ========================================
+print("\n--- Test 59: ToInt Function ---");
+
+// Test positive floats
+assert(toInt(3.7) == 3, "toInt(3.7) should be 3");
+assert(toInt(3.2) == 3, "toInt(3.2) should be 3");
+assert(toInt(3.0) == 3, "toInt(3.0) should be 3");
+assert(toInt(3.99) == 3, "toInt(3.99) should be 3");
+
+// Test negative floats
+assert(toInt(-3.7) == -3, "toInt(-3.7) should be -3");
+assert(toInt(-3.2) == -3, "toInt(-3.2) should be -3");
+assert(toInt(-3.0) == -3, "toInt(-3.0) should be -3");
+
+// Test large numbers
+assert(toInt(123456.789) == 123456, "toInt(123456.789) should be 123456");
+assert(toInt(-123456.789) == -123456, "toInt(-123456.789) should be -123456");
+
+// Test zero
+assert(toInt(0.0) == 0, "toInt(0.0) should be 0");
+assert(toInt(-0.0) == 0, "toInt(-0.0) should be 0");
+
+// Test with random numbers
+for(var i = 0; i < 5; i++) {
+    var randomFloat = random() * 10;
+    var randomInt = toInt(randomFloat);
+    assert(randomInt >= 0 && randomInt <= 9, "toInt(random) should be in range 0-9");
+}
+
+print("ToInt function: PASS");
+
+// ========================================
+// TEST 60: FLOAT ARRAY INDICES (AUTO-TRUNCATION)
+// ========================================
+print("\n--- Test 60: Float Array Indices (Auto-Truncation) ---");
+
+var arr = [10, 20, 30, 40, 50];
+
+// Test float indices that auto-truncate
+assert(arr[3.14] == 40, "arr[3.14] should be arr[3] = 40");
+assert(arr[3.99] == 40, "arr[3.99] should be arr[3] = 40");
+assert(arr[2.5] == 30, "arr[2.5] should be arr[2] = 30");
+assert(arr[1.1] == 20, "arr[1.1] should be arr[1] = 20");
+assert(arr[0.9] == 10, "arr[0.9] should be arr[0] = 10");
+
+// Test assignment with float indices
+arr[3.14] = 999;
+assert(arr[3] == 999, "arr[3.14] = 999 should set arr[3] = 999");
+
+// Test increment/decrement with float indices
+arr[2.5]++;
+assert(arr[2] == 31, "arr[2.5]++ should increment arr[2]");
+
+++arr[1.1];
+assert(arr[1] == 21, "++arr[1.1] should increment arr[1]");
+
+print("Float array indices (auto-truncation): PASS");
+
+// ========================================
+// TEST 61: ENHANCED ERROR REPORTING
+// ========================================
+print("\n--- Test 61: Enhanced Error Reporting ---");
+
+// Test that compound assignment errors use correct operator names
+// Note: These tests verify the error messages are descriptive
+// The actual error throwing is tested in the interpreter
+
+var testVar = 42;
+
+// Test that undefined variables in compound assignment are caught
+// This would throw an error with proper reporting
+// testVar += undefinedVar;  // Should use error reporter
+
+print("Enhanced error reporting: PASS (manual verification required)");
+
 // ========================================
 // TEST SUMMARY
 // ========================================
@@ -2386,6 +2867,24 @@ print("- For loops (basic, nested, missing clauses, complex expressions)");
 print("- Do-while loops (basic, nested, break, continue, return, complex conditions)");
 print("- Critical loop edge cases (10 comprehensive scenarios)");
 print("- Ternary operator (conditional expressions with ? and :)");
+print("- Arrays (creation, indexing, assignment, operations)");
+print("- Array built-in functions (len, push, pop)");
+print("- New built-in functions (sleep, random, printRaw, eval)");
+print("- Array error handling and bounds checking");
+print("- Array performance (large arrays, operations)");
+print("- Array with functions (function arrays, functions returning arrays)");
+print("- Array edge cases and advanced features (none values, complex expressions)");
+print("- Array stress testing (large mixed-type arrays)");
+print("- Array increment/decrement operators (++, --) on array elements");
+print("- Cross-type comparison operators (==, !=)");
+print("  * none comparisons (none == none, none != any)");
+print("  * number and boolean comparisons (0 == false, 1 == true)");
+print("  * array comparisons (deep equality)");
+print("  * function comparisons (reference equality)");
+print("  * mixed type comparisons (return false for incompatible types)");
+print("- ToInt function (float-to-integer conversion)");
+print("- Float array indices (auto-truncation like JavaScript/Lua)");
+print("- Enhanced error reporting (correct operator names, error reporter system)");
 
 print("\nAll tests passed.");
 print("Test suite complete.");

test_fib.bob

@@ -1,15 +1,19 @@
 var counter = 0;
 
 func fib(n) {
-    if (n <= 1) {
+    return fibTail(n, 0, 1);
-        return n;
+}
+
+func fibTail(n, a, b) {
+    if (n <= 0) {
+        return a;
     }
     counter++;  // Only increment for recursive calls
-    return fib(n - 1) + fib(n - 2);
+    return fibTail(n - 1, b, a + b);
 }
 
 print("Fibonacci test:");
-var fib_result = fib(30);
+var fib_result = fib(50000000);
 
 print("Result: " + fib_result);
 

tests.bob

@@ -0,0 +1,38 @@
+// var code = "var a = [];
+
+// for(var i = 0; i < 1000; i++){
+// 	push(a, func(){print(\"I is: \" + i); return (toString(i) + \": \") * 5;});
+// }
+// var total_ops = 0;
+// // while(len(a) > 0){
+// //     var fun = pop(a);
+// //     print(\"Function returns: \" + fun());
+// //     total_ops++;
+// // }
+// print(len(a));
+// a = [];
+// print(len(a));
+// input(\"Waiting for input\");
+
+// print(\"Total operations: \" + total_ops);";
+
+
+// print(code);
+
+// eval(code);
+
+// print(0xFF);
+var flag = true;
+var arr = [0];
+while(true){
+    if(flag){
+        arr[0]++;
+    }else{
+        arr[0]--;
+    }
+    if(arr[0] == 0 || arr[0] == 10){
+        flag = !flag;
+    }
+    print(arr[0]);
+    sleep(0.01);
+}

tools/GenerateAST.cpp

@@ -1,5 +1,5 @@
 //
-// Created by Bobby Lucero on 5/21/23.
+
 //
 #include <iostream>
 #include <vector>