1 files changed, 0 insertions, 730 deletions
diff --git a/js/scripting-lang/test.txt b/js/scripting-lang/test.txt
deleted file mode 100644
index 79555b0..0000000
--- a/js/scripting-lang/test.txt
+++ /dev/null
@@ -1,730 +0,0 @@
-/* ========================================
-   COMPREHENSIVE LANGUAGE TEST SUITE
-   ======================================== */
-
-..out "=== COMPREHENSIVE LANGUAGE TEST SUITE ===";
-..out "";
-
-/* ========================================
-   SECTION 1: BASIC ARITHMETIC OPERATIONS
-   ======================================== */
-
-..out "1. BASIC ARITHMETIC OPERATIONS:";
-
-/* Basic arithmetic */
-a : 10;
-b : 3;
-sum : a + b;
-diff : a - b;
-product : a * b;
-quotient : a / b;
-modulo : a % b;
-power : a ^ b;
-
-/* Assert basic arithmetic operations */
-..assert sum = 13;
-..assert diff = 7;
-..assert product = 30;
-..assert quotient = 3.3333333333333335;
-..assert modulo = 1;
-..assert power = 1000;
-
-..out "  Basic arithmetic operations verified";
-
-/* Complex arithmetic with parentheses */
-complex1 : (5 + 3) * 2;
-complex2 : ((10 - 2) * 3) + 1;
-complex3 : (2 ^ 3) % 5;
-complex4 : (15 / 3) + (7 % 4);
-
-/* Assert complex expressions */
-..assert complex1 = 16;
-..assert complex2 = 25;
-..assert complex3 = 3;
-..assert complex4 = 8;
-
-..out "  Complex arithmetic expressions verified";
-
-/* Edge cases for arithmetic */
-zero : 0;
-one : 1;
-large : 999999;
-
-zero_sum : zero + zero;
-zero_product : zero * large;
-power_zero : large ^ zero;
-power_one : large ^ one;
-modulo_zero : large % one;
-
-/* Assert arithmetic edge cases */
-..assert zero_sum = 0;
-..assert zero_product = 0;
-..assert power_zero = 1;
-..assert power_one = 999999;
-..assert modulo_zero = 0;
-
-..out "  Arithmetic edge cases verified";
-
-..out "";
-
-/* ========================================
-   SECTION 2: COMPARISON OPERATORS
-   ======================================== */
-
-..out "2. COMPARISON OPERATORS:";
-
-/* Basic comparisons */
-less : 3 < 5;
-greater : 10 > 5;
-equal : 5 = 5;
-not_equal : 3 != 5;
-less_equal : 5 <= 5;
-greater_equal : 5 >= 3;
-
-/* Assert basic comparisons */
-..assert less = true;
-..assert greater = true;
-..assert equal = true;
-..assert not_equal = true;
-..assert less_equal = true;
-..assert greater_equal = true;
-
-..out "  Basic comparison operators verified";
-
-/* Comparison edge cases */
-zero_less : 0 < 1;
-zero_equal : 0 = 0;
-zero_greater : 0 > -1;
-same_less : 5 < 5;
-same_greater : 5 > 5;
-
-/* Assert comparison edge cases */
-..assert zero_less = true;
-..assert zero_equal = true;
-..assert zero_greater = true;
-..assert same_less = false;
-..assert same_greater = false;
-
-..out "  Comparison edge cases verified";
-
-..out "";
-
-/* ========================================
-   SECTION 3: LOGICAL OPERATORS
-   ======================================== */
-
-..out "3. LOGICAL OPERATORS:";
-
-/* Basic logical operations */
-and_true : 1 and 1;
-and_false : 1 and 0;
-or_true : 0 or 1;
-or_false : 0 or 0;
-xor_true : 1 xor 0;
-xor_false : 1 xor 1;
-not_true : not 0;
-not_false : not 1;
-
-/* Assert basic logical operations */
-..assert and_true = true;
-..assert and_false = false;
-..assert or_true = true;
-..assert or_false = false;
-..assert xor_true = true;
-..assert xor_false = false;
-..assert not_true = true;
-..assert not_false = false;
-
-..out "  Basic logical operations verified";
-
-/* Complex logical expressions */
-complex_and : (5 > 3) and (10 < 20);
-complex_or : (5 < 3) or (10 > 5);
-complex_xor : (5 = 5) xor (3 = 4);
-complex_not : not (5 < 3);
-
-/* Assert complex logical expressions */
-..assert complex_and = true;
-..assert complex_or = true;
-..assert complex_xor = true;
-..assert complex_not = true;
-
-..out "  Complex logical expressions verified";
-
-..out "";
-
-/* ========================================
-   SECTION 4: VARIABLE ASSIGNMENT
-   ======================================== */
-
-..out "4. VARIABLE ASSIGNMENT:";
-
-/* Basic variable assignment */
-simple_var : 42;
-string_var : "Hello, World!";
-bool_true : true;
-bool_false : false;
-
-/* Assert basic variables */
-..assert simple_var = 42;
-..assert string_var = "Hello, World!";
-..assert bool_true = true;
-..assert bool_false = false;
-
-..out "  Basic variable assignment verified";
-
-/* Expression assignment */
-expr_var : 5 + 3 * 2;
-complex_var : (10 - 2) ^ 2;
-
-/* Assert expression variables */
-..assert expr_var = 11;
-..assert complex_var = 64;
-
-..out "  Expression variable assignment verified";
-
-..out "";
-
-/* ========================================
-   SECTION 5: FUNCTION DEFINITIONS
-   ======================================== */
-
-..out "5. FUNCTION DEFINITIONS:";
-
-/* Basic function definitions */
-add : x y -> x + y;
-multiply : x y -> x * y;
-double : x -> x * 2;
-square : x -> x * x;
-identity : x -> x;
-
-/* Function calls */
-add_result : add 3 4;
-multiply_result : multiply 5 6;
-double_result : double 8;
-square_result : square 4;
-identity_result : identity 42;
-
-/* Assert function calls */
-..assert add_result = 7;
-..assert multiply_result = 30;
-..assert double_result = 16;
-..assert square_result = 16;
-..assert identity_result = 42;
-
-..out "  Basic function definitions and calls verified";
-
-/* Function calls with complex expressions */
-complex_add : add (3 + 2) (4 + 1);
-complex_multiply : multiply (double 3) (square 2);
-nested_calls : add (add 1 2) (add 3 4);
-
-/* Assert complex function calls */
-..assert complex_add = 15;
-..assert complex_multiply = 48;
-..assert nested_calls = 10;
-
-..out "  Complex function calls verified";
-
-..out "";
-
-/* ========================================
-   SECTION 6: PATTERN MATCHING
-   ======================================== */
-
-..out "6. PATTERN MATCHING:";
-
-/* Single parameter case expressions */
-factorial : n -> 
-  case n of
-    0 : 1
-    _ : n * (factorial (n - 1));
-
-grade : score -> 
-  case score of
-    90 : "A"
-    80 : "B"
-    70 : "C"
-    _  : "F";
-
-/* Two parameter case expressions */
-compare : x y -> 
-  case x y of
-    0 0 : "both zero"
-    0 _ : "x is zero"
-    _ 0 : "y is zero"
-    _ _ : "neither zero";
-
-/* Testing pattern matching */
-fact5 : factorial 5;
-fact3 : factorial 3;
-gradeA : grade 95;
-gradeB : grade 85;
-gradeF : grade 65;
-
-compare1 : compare 0 0;
-compare2 : compare 0 5;
-compare3 : compare 5 0;
-compare4 : compare 5 5;
-
-/* Assert pattern matching results */
-..assert fact5 = 120;
-..assert fact3 = 6;
-..assert gradeA = "A";
-..assert gradeB = "B";
-..assert gradeF = "F";
-
-..assert compare1 = "both zero";
-..assert compare2 = "x is zero";
-..assert compare3 = "y is zero";
-..assert compare4 = "neither zero";
-
-..out "  Pattern matching verified";
-
-..out "";
-
-/* ========================================
-   SECTION 7: TABLES
-   ======================================== */
-
-..out "7. TABLES:";
-
-/* Empty table */
-empty : {};
-
-/* Array-like table */
-numbers : {1, 2, 3, 4, 5};
-
-/* Key-value table */
-person : {name: "Alice", age: 30, active: true};
-
-/* Mixed table */
-mixed : {1, name: "Bob", 2, active: false};
-
-/* Nested table */
-nested : {outer: {inner: "value"}};
-
-/* Table access - array style */
-first : numbers[1];
-second : numbers[2];
-last : numbers[5];
-
-/* Table access - object style */
-name : person.name;
-age : person.age;
-active : person.active;
-
-/* Table access - mixed style */
-mixed_first : mixed[1];
-mixed_name : mixed.name;
-mixed_second : mixed[2];
-
-/* Table access - nested */
-nested_value : nested.outer.inner;
-
-/* Assert table access */
-..assert first = 1;
-..assert second = 2;
-..assert last = 5;
-
-..assert name = "Alice";
-..assert age = 30;
-..assert active = true;
-
-..assert mixed_first = 1;
-..assert mixed_name = "Bob";
-..assert mixed_second = 2;
-
-..assert nested_value = "value";
-
-..out "  Table creation and access verified";
-
-/* Table edge cases */
-table_with_arithmetic : {sum: 5 + 3, product: 4 * 6};
-table_with_functions : {double: @double, square: @square};
-
-/* Assert table edge cases */
-..assert table_with_arithmetic.sum = 8;
-..assert table_with_arithmetic.product = 24;
-
-..out "  Table edge cases verified";
-
-..out "";
-
-/* ========================================
-   SECTION 8: FIRST-CLASS FUNCTIONS
-   ======================================== */
-
-..out "8. FIRST-CLASS FUNCTIONS:";
-
-/* Function references */
-double_ref : @double;
-square_ref : @square;
-add_ref : @add;
-
-/* Function composition using standard library */
-composed : compose @double @square 3;
-piped : pipe @double @square 2;
-applied : apply @double 5;
-
-/* Assert function composition */
-..assert composed = 18;
-..assert piped = 16;
-..assert applied = 10;
-
-..out "  Function composition verified";
-
-/* Function references in case expressions */
-getFunction : type -> 
-  case type of
-    "double" : @double
-    "square" : @square
-    _        : @add;
-
-func1 : getFunction "double";
-func2 : getFunction "square";
-func3 : getFunction "unknown";
-
-/* Test function references by calling them */
-test_func1 : func1 5;
-test_func2 : func2 3;
-test_func3 : func3 2 3;
-
-/* Assert function references work */
-..assert test_func1 = 10;
-..assert test_func2 = 9;
-..assert test_func3 = 5;
-
-..out "  Function references from case expressions verified";
-
-..out "";
-
-/* ========================================
-   SECTION 9: STANDARD LIBRARY
-   ======================================== */
-
-..out "9. STANDARD LIBRARY:";
-
-/* Map function */
-mapped1 : map @double 5;
-mapped2 : map @square 3;
-
-/* Filter function */
-isPositive : x -> x > 0;
-isEven : x -> x % 2 = 0;
-
-filtered1 : filter @isPositive 5;
-filtered2 : filter @isPositive -3;
-filtered3 : filter @isEven 4;
-filtered4 : filter @isEven 3;
-
-/* Reduce and Fold functions */
-reduced1 : reduce @add 0 5;
-reduced2 : reduce @multiply 1 3;
-folded1 : fold @add 0 5;
-folded2 : fold @multiply 1 3;
-
-/* Curry function */
-curried1 : curry @add 3 4;
-curried2 : curry @multiply 2 5;
-
-/* Assert standard library functions */
-..assert mapped1 = 10;
-..assert mapped2 = 9;
-
-..assert filtered1 = 5;
-..assert filtered2 = 0;
-..assert filtered3 = 4;
-..assert filtered4 = 0;
-
-..assert reduced1 = 5;
-..assert reduced2 = 3;
-..assert folded1 = 5;
-..assert folded2 = 3;
-
-..assert curried1 = 7;
-..assert curried2 = 10;
-
-..out "  Standard library functions verified";
-
-..out "";
-
-/* ========================================
-   SECTION 10: COMMENTS
-   ======================================== */
-
-..out "10. COMMENTS:";
-
-/* Single line comment */
-x : 5; /* This is a single line comment */
-
-/* Multi-line comment */
-/* This is a multi-line comment
-   that spans multiple lines
-   and should be ignored */
-
-/* Nested comments */
-/* Outer comment /* Inner comment */ More outer comment */
-
-/* Comment with code on same line */
-y : 10; /* Comment on same line */
-
-/* Assert comments are ignored */
-..assert x = 5;
-..assert y = 10;
-
-..out "  Comments work correctly - all ignored by parser";
-
-..out "";
-
-/* ========================================
-   SECTION 11: EDGE CASES AND STRESS TESTS
-   ======================================== */
-
-..out "11. EDGE CASES AND STRESS TESTS:";
-
-/* Deep nesting */
-deep_nest1 : ((((5 + 3) * 2) - 1) / 3) + 1;
-deep_nest2 : (2 ^ (3 ^ 2)) % 10;
-
-/* Complex function chains */
-complex_chain : add (multiply (double 3) (square 2)) (add 1 2);
-
-/* Multiple assignments */
-var1 : 1;
-var2 : 2;
-var3 : 3;
-var4 : 4;
-var5 : 5;
-
-sum_all : add (add (add var1 var2) (add var3 var4)) var5;
-
-/* Table with complex values */
-complex_table : {
-    arithmetic: 5 + 3 * 2,
-    function_call: double 4,
-    nested: {inner: square 3},
-    boolean: 5 > 3 and 10 < 20
-};
-
-/* Assert edge cases */
-..assert deep_nest1 = 6;
-..assert deep_nest2 = 2;
-..assert complex_chain = 27;
-..assert sum_all = 15;
-
-..assert complex_table.arithmetic = 11;
-..assert complex_table.function_call = 8;
-..assert complex_table.nested.inner = 9;
-..assert complex_table.boolean = true;
-
-..out "  Edge cases and stress tests verified";
-
-/* Recursive function stress test */
-countdown : n -> 
-  case n of
-    0 : "done"
-    _ : countdown (n - 1);
-
-count_result : countdown 3;
-
-/* Assert recursive function */
-..assert count_result = "done";
-
-..out "  Recursive function stress test verified";
-
-..out "";
-
-/* ========================================
-   SECTION 12: ASSERTIONS
-   ======================================== */
-
-..out "12. ASSERTIONS:";
-
-/* Basic assertions */
-..assert 5 = 5;
-..assert 3 < 5;
-..assert 10 > 5;
-..assert 5 <= 5;
-..assert 5 >= 3;
-..assert 3 != 5;
-
-/* Complex assertions */
-..assert (5 + 3) = 8;
-..assert (10 - 2) > 5;
-..assert (2 ^ 3) = 8;
-..assert (15 / 3) = 5;
-
-/* Function call assertions */
-..assert (add 3 4) = 7;
-..assert (double 5) = 10;
-..assert (square 3) = 9;
-
-/* Logical assertions */
-..assert 1 and 1;
-..assert 0 or 1;
-..assert 1 xor 0;
-..assert not 0;
-
-/* String assertions */
-..assert "hello" = "hello";
-..assert "world" != "hello";
-
-/* Table assertions */
-..assert numbers[1] = 1;
-..assert person.name = "Alice";
-..assert mixed[1] = 1;
-
-/* Function reference assertions */
-..assert (func1 4) = 8;
-..assert (func2 5) = 25;
-
-..out "  All assertions passed successfully!";
-
-..out "";
-
-/* ========================================
-   SECTION 13: COMPREHENSIVE INTEGRATION TEST
-   ======================================== */
-
-..out "13. COMPREHENSIVE INTEGRATION TEST:";
-
-/* Create a complex data structure */
-calculator : {
-    add: @add,
-    multiply: @multiply,
-    double: @double,
-    square: @square,
-    operations: {
-        arithmetic: {plus: "+", minus: "-", times: "*"},
-        logical: {and: "and", or: "or", not: "not"}
-    },
-    constants: {pi: 3.14159, e: 2.71828}
-};
-
-/* Use the data structure */
-calc_add : calculator.add 5 3;
-calc_mult : calculator.multiply 4 6;
-calc_double : calculator.double 7;
-calc_square : calculator.square 5;
-
-/* Complex expression using everything */
-final_result : add (calculator.double (calculator.square 3)) (calculator.multiply 2 4);
-
-/* Assert integration test results */
-..assert calc_add = 8;
-..assert calc_mult = 24;
-..assert calc_double = 14;
-..assert calc_square = 25;
-..assert final_result = 26;
-
-/* Assert nested table access */
-..assert calculator.operations.arithmetic.plus = "+";
-..assert calculator.operations.logical.and = "and";
-..assert calculator.constants.pi = 3.14159;
-
-..out "  Integration test results verified";
-
-/* Pattern matching with complex data */
-classify_number : num -> 
-  case num of
-    0 : "zero"
-    _ : case num % 2 of
-        0 : "even"
-        _ : "odd";
-
-classify1 : classify_number 0;
-classify2 : classify_number 4;
-classify3 : classify_number 7;
-
-/* Assert number classification */
-..assert classify1 = "zero";
-..assert classify2 = "even";
-..assert classify3 = "odd";
-
-..out "  Number classification verified";
-
-..out "";
-
-/* ========================================
-   SECTION 14: ERROR HANDLING AND EDGE CASES
-   ======================================== */
-
-..out "14. ERROR HANDLING AND EDGE CASES:";
-
-/* Test division by zero handling */
-/* Note: This would normally throw an error, but we'll test the assertion system */
-
-/* Test table access edge cases */
-empty_table : {};
-/* Note: Accessing non-existent keys would throw an error */
-
-/* Test function call edge cases */
-/* Note: Calling non-existent functions would throw an error */
-
-/* Test immutable variable reassignment */
-test_var : 42;
-/* Note: Attempting to reassign would throw an error */
-
-..out "  Error handling edge cases noted";
-
-..out "";
-
-/* ========================================
-   SECTION 15: PERFORMANCE AND SCALE TESTS
-   ======================================== */
-
-..out "15. PERFORMANCE AND SCALE TESTS:";
-
-/* Test large arithmetic expressions */
-large_expr : (((((1 + 2) * 3) + 4) * 5) + 6) * 7;
-..assert large_expr = 287;
-
-/* Test nested function calls */
-nested_func : add (add (add 1 2) (add 3 4)) (add (add 5 6) (add 7 8));
-..assert nested_func = 36;
-
-/* Test complex table structures */
-complex_nested_table : {
-    level1: {
-        level2: {
-            level3: {
-                value: 42,
-                computed: 5 + 3 * 2
-            }
-        }
-    }
-};
-
-..assert complex_nested_table.level1.level2.level3.value = 42;
-..assert complex_nested_table.level1.level2.level3.computed = 11;
-
-..out "  Performance and scale tests verified";
-
-..out "";
-
-/* ========================================
-   FINAL SUMMARY
-   ======================================== */
-
-..out "=== TEST SUITE COMPLETED SUCCESSFULLY ===";
-..out "";
-..out "All language features tested and verified:";
-..out "  Arithmetic operations (+, -, *, /, %, ^)";
-..out "  Comparison operators (=, <, >, <=, >=, !=)";
-..out "  Logical operators (and, or, xor, not)";
-..out "  Variable assignment";
-..out "  Function definitions and calls";
-..out "  Pattern matching with case expressions";
-..out "  Tables (arrays and objects)";
-..out "  First-class functions and composition";
-..out "  Standard library functions";
-..out "  Comments (single-line, multi-line, nested)";
-..out "  Input/Output operations";
-..out "  Assertions";
-..out "  Edge cases and stress tests";
-..out "  Complex integration scenarios";
-..out "  Error handling edge cases";
-..out "  Performance and scale tests";
-..out "";
-..out "Language implementation is fully functional and verified!"; 
\ No newline at end of file