diff options
Diffstat (limited to 'js/scripting-lang/tests')
33 files changed, 1486 insertions, 590 deletions
diff --git a/js/scripting-lang/tests/01_lexer_basic.txt b/js/scripting-lang/tests/01_lexer_basic.txt index bdf7397..90693f1 100644 --- a/js/scripting-lang/tests/01_lexer_basic.txt +++ b/js/scripting-lang/tests/01_lexer_basic.txt @@ -18,8 +18,8 @@ prod : x * y; quot : x / y; /* Test keywords */ -result : case x of - 42 : "correct" - _ : "wrong"; +result : when x is + 42 then "correct" + _ then "wrong"; ..out "Lexer basic test completed"; \ No newline at end of file diff --git a/js/scripting-lang/tests/02_arithmetic_operations.txt b/js/scripting-lang/tests/02_arithmetic_operations.txt index 9c6ab37..d4c0648 100644 --- a/js/scripting-lang/tests/02_arithmetic_operations.txt +++ b/js/scripting-lang/tests/02_arithmetic_operations.txt @@ -8,16 +8,16 @@ sum : a + b; diff : a - b; product : a * b; quotient : a / b; -modulo : a % b; -power : a ^ b; +moduloResult : a % b; +powerResult : a ^ b; /* Test results */ ..assert sum = 13; ..assert diff = 7; ..assert product = 30; ..assert quotient = 3.3333333333333335; -..assert modulo = 1; -..assert power = 1000; +..assert moduloResult = 1; +..assert powerResult = 1000; /* Complex expressions with parentheses */ complex1 : (5 + 3) * 2; diff --git a/js/scripting-lang/tests/05_io_operations.txt b/js/scripting-lang/tests/05_io_operations.txt index a16bf94..6d05dfe 100644 --- a/js/scripting-lang/tests/05_io_operations.txt +++ b/js/scripting-lang/tests/05_io_operations.txt @@ -1,5 +1,5 @@ /* Unit Test: IO Operations */ -/* Tests: ..out, ..assert operations */ +/* Tests: ..out, ..assert, ..listen, ..emit operations */ /* Test basic output */ ..out "Testing IO operations"; @@ -25,4 +25,39 @@ sum : x + y; ..assert (x * y) = 15; ..assert (x > y) = true; +/* Test ..listen functionality */ +state : ..listen; +..assert state.status = "placeholder"; +..assert state.message = "State not available in standalone mode"; + +/* Test ..listen in when expression */ +result : when ..listen is + { status: "placeholder" } then "Placeholder detected" + { status: "active" } then "Active state detected" + _ then "Unknown state"; +..assert result = "Placeholder detected"; + +/* Test ..emit with different data types */ +..emit "String value"; +..emit 42; +..emit true; +..emit { key: "value", number: 123 }; + +/* Test ..emit with computed expressions */ +computed_table : { a: 10, b: 20 }; +computed_sum : computed_table.a + computed_table.b; +..emit computed_sum; + +/* Test ..emit with conditional logic */ +condition : 10 > 5; +message : when condition is + true then "Condition is true" + false then "Condition is false"; +..emit message; + +/* Test that ..emit doesn't interfere with ..out */ +..out "This should appear via ..out"; +..emit "This should appear via ..emit"; +..out "Another ..out message"; + ..out "IO operations test completed"; \ No newline at end of file diff --git a/js/scripting-lang/tests/06_function_definitions.txt b/js/scripting-lang/tests/06_function_definitions.txt index 6ce8677..b0e591f 100644 --- a/js/scripting-lang/tests/06_function_definitions.txt +++ b/js/scripting-lang/tests/06_function_definitions.txt @@ -2,18 +2,18 @@ /* Tests: Function syntax, parameters, calls */ /* Basic function definitions */ -add : x y -> x + y; -multiply : x y -> x * y; -double : x -> x * 2; -square : x -> x * x; -identity : x -> x; +add_func : x y -> x + y; +multiply_func : x y -> x * y; +double_func : x -> x * 2; +square_func : x -> x * x; +identity_func : x -> x; /* Test function calls */ -result1 : add 3 4; -result2 : multiply 5 6; -result3 : double 8; -result4 : square 4; -result5 : identity 42; +result1 : add_func 3 4; +result2 : multiply_func 5 6; +result3 : double_func 8; +result4 : square_func 4; +result5 : identity_func 42; /* Test results */ ..assert result1 = 7; @@ -23,8 +23,8 @@ result5 : identity 42; ..assert result5 = 42; /* Test function calls with parentheses */ -result6 : add (3 + 2) (4 + 1); -result7 : multiply (double 3) (square 2); +result6 : add_func @(3 + 2) @(4 + 1); +result7 : multiply_func @(double_func 3) @(square_func 2); ..assert result6 = 10; ..assert result7 = 24; diff --git a/js/scripting-lang/tests/07_case_expressions.txt b/js/scripting-lang/tests/07_case_expressions.txt index 82d458c..ccc447c 100644 --- a/js/scripting-lang/tests/07_case_expressions.txt +++ b/js/scripting-lang/tests/07_case_expressions.txt @@ -3,16 +3,16 @@ /* Basic case expressions */ factorial : n -> - case n of - 0 : 1 - _ : n * (factorial (n - 1)); + when n is + 0 then 1 + _ then n * (@factorial (n - 1)); grade : score -> - case score of - 90 : "A" - 80 : "B" - 70 : "C" - _ : "F"; + when score is + score >= 90 then "A" + score >= 80 then "B" + score >= 70 then "C" + _ then "F"; /* Test case expressions */ fact5 : factorial 5; @@ -22,17 +22,17 @@ grade3 : grade 65; /* Test results */ ..assert fact5 = 120; -..assert grade1 = "F"; /* 95 doesn't match 90, so falls through to wildcard */ -..assert grade2 = "F"; /* 85 doesn't match 80, so falls through to wildcard */ -..assert grade3 = "F"; +..assert grade1 = "A"; /* 95 >= 90, so matches first case */ +..assert grade2 = "B"; /* 85 >= 80, so matches second case */ +..assert grade3 = "F"; /* 65 < 70, so falls through to wildcard */ /* Multi-parameter case expressions */ compare : x y -> - case x y of - 0 0 : "both zero" - 0 _ : "x is zero" - _ 0 : "y is zero" - _ _ : "neither zero"; + when x y is + 0 0 then "both zero" + 0 _ then "x is zero" + _ 0 then "y is zero" + _ _ then "neither zero"; test1 : compare 0 0; test2 : compare 0 5; diff --git a/js/scripting-lang/tests/08_first_class_functions.txt b/js/scripting-lang/tests/08_first_class_functions.txt index f228ccd..75fda40 100644 --- a/js/scripting-lang/tests/08_first_class_functions.txt +++ b/js/scripting-lang/tests/08_first_class_functions.txt @@ -31,10 +31,10 @@ applied : apply @double 7; /* Function references in case expressions */ getFunction : type -> - case type of - "double" : @double - "square" : @square - _ : @add1; + when type is + "double" then @double + "square" then @square + _ then @add1; func1 : getFunction "double"; func2 : getFunction "square"; diff --git a/js/scripting-lang/tests/10_standard_library.txt b/js/scripting-lang/tests/10_standard_library.txt index e6f7160..221d5ca 100644 --- a/js/scripting-lang/tests/10_standard_library.txt +++ b/js/scripting-lang/tests/10_standard_library.txt @@ -2,48 +2,39 @@ /* Tests: All built-in higher-order functions */ /* Basic functions for testing */ -double : x -> x * 2; -square : x -> x * x; -add : x y -> x + y; +double_func : x -> x * 2; +square_func : x -> x * x; +add_func : x y -> x + y; isPositive : x -> x > 0; -/* Filter function - TESTING FAILING CASE */ -filtered1 : filter @isPositive 5; -filtered2 : filter @isPositive -3; - -..out "filtered1 = "; -..out filtered1; -..out "filtered2 = "; -..out filtered2; - /* Map function */ -mapped1 : map @double 5; -mapped2 : map @square 3; +mapped1 : map @double_func 5; +mapped2 : map @square_func 3; ..assert mapped1 = 10; ..assert mapped2 = 9; /* Compose function */ -composed : compose @double @square 3; +composed : compose @double_func @square_func 3; ..assert composed = 18; /* Pipe function */ -piped : pipe @double @square 2; +piped : pipe @double_func @square_func 2; ..assert piped = 16; /* Apply function */ -applied : apply @double 7; +applied : apply @double_func 7; ..assert applied = 14; /* Reduce and Fold functions */ -reduced : reduce @add 0 5; -folded : fold @add 0 5; +reduced : reduce @add_func 0 5; +folded : fold @add_func 0 5; ..assert reduced = 5; ..assert folded = 5; /* Curry function */ -curried : curry @add 3 4; +curried : curry @add_func 3 4; ..assert curried = 7; ..out "Standard library test completed"; \ No newline at end of file diff --git a/js/scripting-lang/tests/11_edge_cases.txt b/js/scripting-lang/tests/11_edge_cases.txt index ceb39b4..bff51ef 100644 --- a/js/scripting-lang/tests/11_edge_cases.txt +++ b/js/scripting-lang/tests/11_edge_cases.txt @@ -13,18 +13,18 @@ negative3 : -0; /* Test complex unary minus expressions */ complex_negative1 : -(-5); complex_negative2 : -(-(-3)); -complex_negative3 : -5 + 3; +complex_negative3 : (-5) + 3; ..assert complex_negative1 = 5; ..assert complex_negative2 = -3; ..assert complex_negative3 = -2; /* Test unary minus in function calls */ -abs : x -> case x of - x < 0 : -x - _ : x; +abs : x -> when x is + x < 0 then -x + _ then x; -abs1 : abs -5; +abs1 : abs (-5); abs2 : abs 5; ..assert abs1 = 5; @@ -40,9 +40,9 @@ nested3 : -((2 + 3) * 4); ..assert nested3 = -20; /* Test unary minus with function references */ -negate : x -> -x; -negated1 : negate 5; -negated2 : negate -3; +myNegate : x -> -x; +negated1 : myNegate 5; +negated2 : myNegate (-3); ..assert negated1 = -5; ..assert negated2 = 3; diff --git a/js/scripting-lang/tests/13_standard_library_complete.txt b/js/scripting-lang/tests/13_standard_library_complete.txt index ed7749a..451dc0a 100644 --- a/js/scripting-lang/tests/13_standard_library_complete.txt +++ b/js/scripting-lang/tests/13_standard_library_complete.txt @@ -2,71 +2,71 @@ /* Tests: All built-in higher-order functions including reduce, fold, curry */ /* Basic functions for testing */ -double : x -> x * 2; -square : x -> x * x; -add : x y -> x + y; +double_func : x -> x * 2; +square_func : x -> x * x; +add_func : x y -> x + y; isPositive : x -> x > 0; isEven : x -> x % 2 = 0; /* Map function */ -mapped1 : map @double 5; -mapped2 : map @square 3; +mapped1 : map @double_func 5; +mapped2 : map @square_func 3; ..assert mapped1 = 10; ..assert mapped2 = 9; /* Compose function */ -composed : compose @double @square 3; +composed : compose @double_func @square_func 3; ..assert composed = 18; /* Pipe function */ -piped : pipe @double @square 2; +piped : pipe @double_func @square_func 2; ..assert piped = 16; /* Apply function */ -applied : apply @double 7; +applied : apply @double_func 7; ..assert applied = 14; /* Filter function */ filtered1 : filter @isPositive 5; -filtered2 : filter @isPositive -3; +filtered2 : filter @isPositive (-3); ..assert filtered1 = 5; ..assert filtered2 = 0; /* Reduce function */ -reduced : reduce @add 0 5; +reduced : reduce @add_func 0 5; ..assert reduced = 5; /* Fold function */ -folded : fold @add 0 5; +folded : fold @add_func 0 5; ..assert folded = 5; /* Curry function */ -curried : curry @add 3 4; +curried : curry @add_func 3 4; ..assert curried = 7; /* Test partial application */ -compose_partial : compose @double @square; +compose_partial : compose @double_func @square_func; compose_result : compose_partial 3; ..assert compose_result = 18; -pipe_partial : pipe @double @square; +pipe_partial : pipe @double_func @square_func; pipe_result : pipe_partial 2; ..assert pipe_result = 16; /* Test with negative numbers */ -negate : x -> -x; -negative_compose : compose @double @negate 5; -negative_pipe : pipe @negate @double 5; +negate_func : x -> -x; +negative_compose : compose @double_func @negate_func 5; +negative_pipe : pipe @negate_func @double_func 5; ..assert negative_compose = -10; ..assert negative_pipe = -10; /* Test with complex functions */ complex_func : x -> x * x + 1; -complex_compose : compose @double @complex_func 3; -complex_pipe : pipe @complex_func @double 3; +complex_compose : compose @double_func @complex_func 3; +complex_pipe : pipe @complex_func @double_func 3; ..assert complex_compose = 20; ..assert complex_pipe = 20; @@ -80,16 +80,16 @@ filtered_small : filter @isLarge 5; ..assert filtered_small = 0; /* Test reduce with different initial values */ -multiply : x y -> x * y; -reduced_sum : reduce @add 10 5; -reduced_mult : reduce @multiply 1 5; +multiply_func : x y -> x * y; +reduced_sum : reduce @add_func 10 5; +reduced_mult : reduce @multiply_func 1 5; ..assert reduced_sum = 15; ..assert reduced_mult = 5; /* Test fold with different initial values */ -folded_sum : fold @add 10 5; -folded_mult : fold @multiply 1 5; +folded_sum : fold @add_func 10 5; +folded_mult : fold @multiply_func 1 5; ..assert folded_sum = 15; ..assert folded_mult = 5; diff --git a/js/scripting-lang/tests/14_error_handling.txt b/js/scripting-lang/tests/14_error_handling.txt index ce485f7..09e414d 100644 --- a/js/scripting-lang/tests/14_error_handling.txt +++ b/js/scripting-lang/tests/14_error_handling.txt @@ -7,9 +7,9 @@ valid_test : 5 + 3; /* Test division by zero handling */ /* This should be handled gracefully */ -safe_div : x y -> case y of - 0 : "division by zero" - _ : x / y; +safe_div : x y -> when y is + 0 then "division by zero" + _ then x / y; div_result1 : safe_div 10 2; div_result2 : safe_div 10 0; @@ -18,30 +18,30 @@ div_result2 : safe_div 10 0; ..assert div_result2 = "division by zero"; /* Test edge cases with proper handling */ -edge_case1 : case 0 of - 0 : "zero" - _ : "other"; +edge_case1 : when 0 is + 0 then "zero" + _ then "other"; -edge_case2 : case "" of - "" : "empty string" - _ : "other"; +edge_case2 : when "" is + "" then "empty string" + _ then "other"; -edge_case3 : case false of - false : "false" - _ : "other"; +edge_case3 : when false is + false then "false" + _ then "other"; ..assert edge_case1 = "zero"; ..assert edge_case2 = "empty string"; ..assert edge_case3 = "false"; /* Test complex error scenarios */ -complex_error_handling : input -> case input of - input < 0 : "negative" - input = 0 : "zero" - input > 100 : "too large" - _ : "valid"; +complex_error_handling : input -> when input is + input < 0 then "negative" + input = 0 then "zero" + input > 100 then "too large" + _ then "valid"; -complex_result1 : complex_error_handling -5; +complex_result1 : complex_error_handling (-5); complex_result2 : complex_error_handling 0; complex_result3 : complex_error_handling 150; complex_result4 : complex_error_handling 50; @@ -52,9 +52,9 @@ complex_result4 : complex_error_handling 50; ..assert complex_result4 = "valid"; /* Test safe arithmetic operations */ -safe_add : x y -> case y of - 0 : x - _ : x + y; +safe_add : x y -> when y is + 0 then x + _ then x + y; safe_result1 : safe_add 5 3; safe_result2 : safe_add 5 0; diff --git a/js/scripting-lang/tests/15_performance_stress.txt b/js/scripting-lang/tests/15_performance_stress.txt index 7dab1f5..4ea961b 100644 --- a/js/scripting-lang/tests/15_performance_stress.txt +++ b/js/scripting-lang/tests/15_performance_stress.txt @@ -2,12 +2,11 @@ /* Tests: Large computations, nested functions, complex expressions */ /* Test large arithmetic computations */ -large_sum : 0; -large_sum : large_sum + 1; -large_sum : large_sum + 2; -large_sum : large_sum + 3; -large_sum : large_sum + 4; -large_sum : large_sum + 5; +sum1 : 0 + 1; +sum2 : sum1 + 2; +sum3 : sum2 + 3; +sum4 : sum3 + 4; +large_sum : sum4 + 5; ..assert large_sum = 15; @@ -19,7 +18,7 @@ nested_func4 : x -> nested_func3 x; nested_func5 : x -> nested_func4 x; deep_nested : nested_func5 10; -..assert deep_nested = 15; +..assert deep_nested = 11; /* Test complex mathematical expressions */ complex_math1 : (1 + 2) * (3 + 4) - (5 + 6); @@ -28,34 +27,34 @@ complex_math3 : -((1 + 2 + 3) * (4 + 5 + 6)); ..assert complex_math1 = 10; ..assert complex_math2 = 7; -..assert complex_math3 = -126; +..assert complex_math3 = -90; /* Test large table operations */ -large_table : {}; -large_table : {1: "one", 2: "two", 3: "three", 4: "four", 5: "five"}; -large_table : {large_table, 6: "six", 7: "seven", 8: "eight"}; +table1 : {}; +table2 : {1: "one", 2: "two", 3: "three", 4: "four", 5: "five"}; +large_table : {table2, 6: "six", 7: "seven", 8: "eight"}; table_size : 8; ..assert table_size = 8; /* Test recursive-like patterns with functions */ -accumulate : n -> case n of - 0 : 0 - _ : n + accumulate (n - 1); +accumulate : n -> when n is + 0 then 0 + _ then n + accumulate (n - 1); sum_10 : accumulate 10; ..assert sum_10 = 55; /* Test complex case expressions */ -complex_case : x -> case x of - x < 0 : "negative" - x = 0 : "zero" - x < 10 : "small" - x < 100 : "medium" - x < 1000 : "large" - _ : "huge"; - -case_test1 : complex_case -5; +complex_case : x -> when x is + x < 0 then "negative" + x = 0 then "zero" + x < 10 then "small" + x < 100 then "medium" + x < 1000 then "large" + _ then "huge"; + +case_test1 : complex_case (-5); case_test2 : complex_case 0; case_test3 : complex_case 5; case_test4 : complex_case 50; @@ -72,11 +71,11 @@ case_test6 : complex_case 5000; /* Test standard library with complex operations */ double : x -> x * 2; square : x -> x * x; -add : x y -> x + y; +myAdd : x y -> x + y; complex_std1 : compose @double @square 3; complex_std2 : pipe @square @double 4; -complex_std3 : apply @add 5 3; +complex_std3 : curry @myAdd 5 3; ..assert complex_std1 = 18; ..assert complex_std2 = 32; @@ -122,8 +121,9 @@ f2 : x -> x * 2; f3 : x -> x - 1; f4 : x -> x / 2; -composed1 : compose @f1 @f2 @f3 @f4 10; -composed2 : pipe @f4 @f3 @f2 @f1 10; +/* Test simple compositions that should cancel each other out */ +composed1 : compose @f1 @f3 10; /* f1(f3(10)) = f1(9) = 10 */ +composed2 : pipe @f3 @f1 10; /* f3(f1(10)) = f3(11) = 10 */ ..assert composed1 = 10; ..assert composed2 = 10; diff --git a/js/scripting-lang/tests/16_advanced_functional.txt b/js/scripting-lang/tests/16_advanced_functional.txt deleted file mode 100644 index 3da9d76..0000000 --- a/js/scripting-lang/tests/16_advanced_functional.txt +++ /dev/null @@ -1,169 +0,0 @@ -/* Unit Test: Advanced Functional Programming Patterns */ -/* Tests: Higher-order functions, currying, partial application, monadic patterns */ - -/* Test function composition with multiple functions */ -id : x -> x; -const : x y -> x; -flip : f x y -> f y x; - -/* Test identity function */ -id_test : id 42; -..assert id_test = 42; - -/* Test constant function */ -const_test : const 5 10; -..assert const_test = 5; - -/* Test function flipping */ -sub : x y -> x - y; -flipped_sub : flip @sub; -flipped_result : flipped_sub 5 10; -..assert flipped_result = 5; - -/* Test partial application patterns */ -partial1 : f x -> y -> f x y; -partial2 : f x y -> f x y; - -add : x y -> x + y; -add5 : partial1 @add 5; -add5_result : add5 3; -..assert add5_result = 8; - -/* Test function composition with multiple arguments */ -compose2 : f g x y -> f (g x y); -compose3 : f g h x -> f (g (h x)); - -double : x -> x * 2; -square : x -> x * x; -increment : x -> x + 1; - -composed1 : compose2 @double @add 3 4; -composed2 : compose3 @double @square @increment 2; -..assert composed1 = 14; -..assert composed2 = 18; - -/* Test monadic-like patterns with Maybe simulation */ -maybe : x -> case x of - undefined : "Nothing" - null : "Nothing" - _ : "Just " + x; - -maybe_map : f m -> case m of - "Nothing" : "Nothing" - _ : f m; - -maybe_bind : m f -> case m of - "Nothing" : "Nothing" - _ : f m; - -maybe_test1 : maybe undefined; -maybe_test2 : maybe 42; -maybe_test3 : maybe_map @double "Just 5"; -maybe_test4 : maybe_bind "Just 3" @double; - -..assert maybe_test1 = "Nothing"; -..assert maybe_test2 = "Just 42"; -..assert maybe_test3 = "Just 10"; -..assert maybe_test4 = "Just 6"; - -/* Test list-like operations with tables */ -list_map : f table -> { - f table[1], - f table[2], - f table[3] -}; - -list_filter : p table -> case p table[1] of - true : {table[1]} - false : {}; - -list_reduce : f init table -> case table[1] of - undefined : init - _ : f init table[1]; - -test_list : {1, 2, 3}; -mapped_list : list_map @double test_list; -filtered_list : list_filter (x -> x > 1) test_list; -reduced_list : list_reduce @add 0 test_list; - -..assert mapped_list[1] = 2; -..assert mapped_list[2] = 4; -..assert mapped_list[3] = 6; -..assert filtered_list[1] = 2; -..assert reduced_list = 1; - -/* Test point-free style programming */ -pointfree_add : add; -pointfree_double : double; -pointfree_compose : compose @pointfree_double @pointfree_add; - -pointfree_result : pointfree_compose 5 3; -..assert pointfree_result = 16; - -/* Test function memoization pattern */ -memoize : f -> { - cache: {}, - call: x -> case cache[x] of - undefined : cache[x] = f x - _ : cache[x] -}; - -expensive_func : x -> x * x + x + 1; -memoized_func : memoize @expensive_func; - -memo_result1 : memoized_func.call 5; -memo_result2 : memoized_func.call 5; /* Should use cache */ -..assert memo_result1 = 31; -..assert memo_result2 = 31; - -/* Test continuation-passing style (CPS) */ -cps_add : x y k -> k (x + y); -cps_multiply : x y k -> k (x * y); -cps_square : x k -> k (x * x); - -cps_example : cps_add 3 4 (sum -> - cps_multiply sum 2 (product -> - cps_square product (result -> result) - ) -); -..assert cps_example = 98; - -/* Test trampoline pattern for tail recursion simulation */ -trampoline : f -> case f of - f is function : trampoline (f) - _ : f; - -bounce : n -> case n of - 0 : 0 - _ : n + (n - 1); - -trampoline_result : trampoline @bounce 5; -..assert trampoline_result = 15; - -/* Test applicative functor pattern */ -applicative : f x -> case f of - f is function : f x - _ : x; - -applicative_test : applicative @double 5; -..assert applicative_test = 10; - -/* Test function pipelines */ -pipeline : x f1 f2 f3 -> f3 (f2 (f1 x)); -pipeline_result : pipeline 2 @increment @double @square; -..assert pipeline_result = 36; - -/* Test function combinators */ -S : f g x -> f x (g x); -K : x y -> x; -I : x -> x; - -S_test : S @add @double 3; -K_test : K 5 10; -I_test : I 42; - -..assert S_test = 9; -..assert K_test = 5; -..assert I_test = 42; - -..out "Advanced functional programming test completed successfully"; \ No newline at end of file diff --git a/js/scripting-lang/tests/16_function_composition.txt b/js/scripting-lang/tests/16_function_composition.txt new file mode 100644 index 0000000..6b1b13f --- /dev/null +++ b/js/scripting-lang/tests/16_function_composition.txt @@ -0,0 +1,59 @@ +/* Function Composition Test Suite */ + +/* Test basic function definitions */ +double : x -> x * 2; +add1 : x -> x + 1; +square : x -> x * x; + +/* Test 1: Basic composition with compose */ +result1 : compose @double @add1 5; +..out result1; + +/* Test 2: Multiple composition with compose */ +result2 : compose @double (compose @add1 @square) 3; +..out result2; + +/* Test 3: Function references */ +ref1 : @double; +..out ref1; + +/* Test 4: Function references in composition */ +result3 : compose @double @add1 5; +..out result3; + +/* Test 5: Pipe function (binary) */ +result4 : pipe @double @add1 5; +..out result4; + +/* Test 6: Compose function (binary) */ +result5 : compose @double @add1 2; +..out result5; + +/* Test 7: Multiple composition with pipe */ +result6 : pipe @square (pipe @add1 @double) 2; +..out result6; + +/* Test 8: Backward compatibility - arithmetic */ +x : 10; +result7 : x + 5; +..out result7; + +/* Test 9: Backward compatibility - function application */ +result8 : double x; +..out result8; + +/* Test 10: Backward compatibility - nested application */ +result9 : double (add1 x); +..out result9; + +/* Test 11: Backward compatibility - unary operators */ +result10 : -x; +..out result10; + +/* Test 12: Backward compatibility - logical operators */ +result11 : not true; +..out result11; + +/* Test 13: Complex composition chain */ +result12 : compose @square (compose @add1 (compose @double @add1)) 3; +..out result12; \ No newline at end of file diff --git a/js/scripting-lang/tests/17_real_world_scenarios.txt b/js/scripting-lang/tests/17_real_world_scenarios.txt deleted file mode 100644 index 0a9fc49..0000000 --- a/js/scripting-lang/tests/17_real_world_scenarios.txt +++ /dev/null @@ -1,219 +0,0 @@ -/* Unit Test: Real-World Programming Scenarios */ -/* Tests: Practical use cases, data processing, business logic */ - -/* Scenario 1: User Management System */ -/* Define user types and validation */ -isValidEmail : email -> case email of - email contains "@" : true - _ : false; - -isValidAge : age -> case age of - age >= 0 and age <= 120 : true - _ : false; - -createUser : name email age -> case (isValidEmail email) and (isValidAge age) of - true : { - name: name, - email: email, - age: age, - status: "active" - } - false : "invalid user data"; - -user1 : createUser "Alice" "alice@example.com" 25; -user2 : createUser "Bob" "invalid-email" 30; -user3 : createUser "Charlie" "charlie@test.com" 150; - -..assert user1.name = "Alice"; -..assert user2 = "invalid user data"; -..assert user3 = "invalid user data"; - -/* Scenario 2: Shopping Cart System */ -/* Product definitions */ -product1 : {id: 1, name: "Laptop", price: 999.99, category: "electronics"}; -product2 : {id: 2, name: "Book", price: 19.99, category: "books"}; -product3 : {id: 3, name: "Coffee", price: 4.99, category: "food"}; - -/* Cart operations */ -addToCart : cart product -> { - cart, - product -}; - -calculateTotal : cart -> case cart of - cart is table : cart.product.price - _ : 0; - -applyDiscount : total discount -> case discount of - discount > 0 and discount <= 100 : total * (1 - discount / 100) - _ : total; - -cart : addToCart {} product1; -cart : addToCart cart product2; -total : calculateTotal cart; -discounted : applyDiscount total 10; - -..assert total = 1019.98; -..assert discounted = 917.982; - -/* Scenario 3: Data Processing Pipeline */ -/* Sample data */ -sales_data : { - {month: "Jan", sales: 1000, region: "North"}, - {month: "Feb", sales: 1200, region: "North"}, - {month: "Mar", sales: 800, region: "South"}, - {month: "Apr", sales: 1500, region: "North"}, - {month: "May", sales: 900, region: "South"} -}; - -/* Data processing functions */ -filterByRegion : data region -> case data of - data.region = region : data - _ : null; - -sumSales : data -> case data of - data is table : data.sales - _ : 0; - -calculateAverage : total count -> case count of - count > 0 : total / count - _ : 0; - -/* Process North region sales */ -north_sales : filterByRegion sales_data "North"; -north_total : sumSales north_sales; -north_avg : calculateAverage north_total 3; - -..assert north_total = 3700; -..assert north_avg = 1233.3333333333333; - -/* Scenario 4: Configuration Management */ -/* Environment configuration */ -getConfig : env -> case env of - "development" : { - database: "dev_db", - port: 3000, - debug: true, - log_level: "debug" - } - "production" : { - database: "prod_db", - port: 80, - debug: false, - log_level: "error" - } - "testing" : { - database: "test_db", - port: 3001, - debug: true, - log_level: "info" - } - _ : "unknown environment"; - -dev_config : getConfig "development"; -prod_config : getConfig "production"; - -..assert dev_config.debug = true; -..assert prod_config.debug = false; -..assert dev_config.port = 3000; -..assert prod_config.port = 80; - -/* Scenario 5: Error Handling and Recovery */ -/* Robust function with error handling */ -safeDivide : x y -> case y of - 0 : "division by zero error" - _ : x / y; - -safeParseNumber : str -> case str of - str is number : str - _ : "invalid number"; - -processData : data -> case data of - data is number : data * 2 - data is string : safeParseNumber data - _ : "unsupported data type"; - -safe_result1 : safeDivide 10 2; -safe_result2 : safeDivide 10 0; -safe_result3 : processData 5; -safe_result4 : processData "abc"; - -..assert safe_result1 = 5; -..assert safe_result2 = "division by zero error"; -..assert safe_result3 = 10; -..assert safe_result4 = "invalid number"; - -/* Scenario 6: Event Handling System */ -/* Event types and handlers */ -eventHandlers : { - "user.login": x -> "User logged in: " + x, - "user.logout": x -> "User logged out: " + x, - "order.created": x -> "Order created: " + x, - "order.completed": x -> "Order completed: " + x -}; - -handleEvent : event data -> case eventHandlers[event] of - handler : handler data - _ : "Unknown event: " + event; - -login_event : handleEvent "user.login" "alice@example.com"; -logout_event : handleEvent "user.logout" "bob@example.com"; -unknown_event : handleEvent "unknown.event" "data"; - -..assert login_event = "User logged in: alice@example.com"; -..assert logout_event = "User logged out: bob@example.com"; -..assert unknown_event = "Unknown event: unknown.event"; - -/* Scenario 7: Caching System */ -/* Simple cache implementation */ -cache : {}; - -setCache : key value -> cache[key] = value; -getCache : key -> case cache[key] of - undefined : "not found" - value : value; -clearCache : key -> cache[key] = undefined; - -setCache "user.1" "Alice"; -setCache "user.2" "Bob"; -cache_result1 : getCache "user.1"; -cache_result2 : getCache "user.999"; -clearCache "user.1"; -cache_result3 : getCache "user.1"; - -..assert cache_result1 = "Alice"; -..assert cache_result2 = "not found"; -..assert cache_result3 = "not found"; - -/* Scenario 8: API Response Processing */ -/* Mock API responses */ -apiResponse : { - status: 200, - data: { - users: { - {id: 1, name: "Alice", active: true}, - {id: 2, name: "Bob", active: false}, - {id: 3, name: "Charlie", active: true} - }, - total: 3 - } -}; - -processApiResponse : response -> case response.status of - 200 : response.data - 404 : "not found" - 500 : "server error" - _ : "unknown status"; - -getActiveUsers : data -> case data.users of - users : case users.active of - true : users - _ : null; - -api_data : processApiResponse apiResponse; -active_users : getActiveUsers api_data; - -..assert api_data.total = 3; -..assert active_users = null; /* Simplified for this example */ - -..out "Real-world scenarios test completed successfully"; \ No newline at end of file diff --git a/js/scripting-lang/tests/17_table_enhancements.txt b/js/scripting-lang/tests/17_table_enhancements.txt new file mode 100644 index 0000000..d935153 --- /dev/null +++ b/js/scripting-lang/tests/17_table_enhancements.txt @@ -0,0 +1,234 @@ +/* Unit Test: Table Enhancements */ +/* Tests: Enhanced combinators, t namespace, each combinator, embedded functions */ + +/* ===== ENHANCED COMBINATORS ===== */ + +/* Enhanced map with tables */ +numbers : {1, 2, 3, 4, 5}; +double : x -> x * 2; + +/* Test map with single table */ +doubled : map @double numbers; +/* Note: Using dot notation for array-like tables */ +first : doubled[1]; +second : doubled[2]; +third : doubled[3]; +fourth : doubled[4]; +fifth : doubled[5]; +..assert first = 2; +..assert second = 4; +..assert third = 6; +..assert fourth = 8; +..assert fifth = 10; + +/* Test map with key-value table */ +person : {name: "Alice", age: 30, active: true}; +add_ten : x -> x + 10; + +mapped_person : map @add_ten person; +/* Note: This will add 10 to all values, including strings */ +name_result : mapped_person.name; +age_result : mapped_person.age; +active_result : mapped_person.active; +..assert name_result = "Alice10"; +..assert age_result = 40; +..assert active_result = 11; + +/* Enhanced filter with tables */ +is_even : x -> x % 2 = 0; +evens : filter @is_even numbers; +even_2 : evens[2]; +even_4 : evens[4]; +/* Note: Keys 1, 3, 5 don't exist in filtered result */ +..assert even_2 = 2; +..assert even_4 = 4; + +/* Enhanced reduce with tables */ +sum : x y -> x + y; +total : reduce @sum 0 numbers; +..assert total = 15; + +/* ===== T NAMESPACE OPERATIONS ===== */ + +/* t.map */ +t_doubled : t.map @double numbers; +t_first : t_doubled[1]; +t_second : t_doubled[2]; +t_third : t_doubled[3]; +..assert t_first = 2; +..assert t_second = 4; +..assert t_third = 6; + +/* t.filter */ +t_evens : t.filter @is_even numbers; +t_even_2 : t_evens[2]; +t_even_4 : t_evens[4]; +/* Note: Keys 1, 3, 5 don't exist in filtered result */ +..assert t_even_2 = 2; +..assert t_even_4 = 4; + +/* t.reduce */ +t_total : t.reduce @sum 0 numbers; +..assert t_total = 15; + +/* t.set - immutable update */ +updated_person : t.set person "age" 31; +..assert updated_person.age = 31; +..assert person.age = 30; /* Original unchanged */ + +/* t.delete - immutable deletion */ +person_without_age : t.delete person "age"; +..assert person_without_age.name = "Alice"; +..assert person_without_age.active = true; +/* Note: age key doesn't exist in person_without_age */ +..assert person.age = 30; /* Original unchanged */ + +/* t.merge - immutable merge */ +person1 : {name: "Alice", age: 30}; +person2 : {age: 31, city: "NYC"}; +merged : t.merge person1 person2; +..assert merged.name = "Alice"; +..assert merged.age = 31; +..assert merged.city = "NYC"; + +/* t.length */ +length : t.length person; +..assert length = 3; + +/* t.has */ +has_name : t.has person "name"; +has_email : t.has person "email"; +..assert has_name = true; +..assert has_email = false; + +/* t.get */ +name_value : t.get person "name" "unknown"; +email_value : t.get person "email" "unknown"; +..assert name_value = "Alice"; +..assert email_value = "unknown"; + +/* ===== EACH COMBINATOR ===== */ + +/* each with table and scalar */ +each_add : each @add numbers 10; +each_1 : each_add[1]; +each_2 : each_add[2]; +each_3 : each_add[3]; +..assert each_1 = 11; +..assert each_2 = 12; +..assert each_3 = 13; + +/* each with two tables */ +table1 : {a: 1, b: 2, c: 3}; +table2 : {a: 10, b: 20, c: 30}; +each_sum : each @add table1 table2; +..assert each_sum.a = 11; +..assert each_sum.b = 22; +..assert each_sum.c = 33; + +/* each with scalar and table */ +each_add_scalar : each @add 10 numbers; +scalar_1 : each_add_scalar[1]; +scalar_2 : each_add_scalar[2]; +scalar_3 : each_add_scalar[3]; +..assert scalar_1 = 11; +..assert scalar_2 = 12; +..assert scalar_3 = 13; + +/* each with partial application */ +add_to_ten : each @add 10; +partial_result : add_to_ten numbers; +partial_1 : partial_result[1]; +partial_2 : partial_result[2]; +partial_3 : partial_result[3]; +..assert partial_1 = 11; +..assert partial_2 = 12; +..assert partial_3 = 13; + +/* each with different operations */ +each_multiply : each @multiply numbers 2; +mult_1 : each_multiply[1]; +mult_2 : each_multiply[2]; +mult_3 : each_multiply[3]; +..assert mult_1 = 2; +..assert mult_2 = 4; +..assert mult_3 = 6; + +/* each with comparison */ +each_greater : each @greaterThan numbers 3; +greater_1 : each_greater[1]; +greater_2 : each_greater[2]; +greater_3 : each_greater[3]; +greater_4 : each_greater[4]; +greater_5 : each_greater[5]; +..assert greater_1 = false; +..assert greater_2 = false; +..assert greater_3 = false; +..assert greater_4 = true; +..assert greater_5 = true; + +/* ===== EMBEDDED FUNCTIONS ===== */ + +/* Table with embedded arrow functions */ +calculator : { + add: x y -> x + y, + multiply: x y -> x * y, + double: x -> x * 2 +}; + +/* Test embedded function calls */ +add_result : calculator.add 5 3; +multiply_result : calculator.multiply 4 6; +double_result : calculator.double 7; +..assert add_result = 8; +..assert multiply_result = 24; +..assert double_result = 14; + +/* Table with embedded when expressions */ +classifier : { + classify: x -> when x is + 0 then "zero" + 1 then "one" + _ then "other" +}; + +/* Test embedded when expressions */ +zero_class : classifier.classify 0; +one_class : classifier.classify 1; +other_class : classifier.classify 42; +..assert zero_class = "zero"; +..assert one_class = "one"; +..assert other_class = "other"; + +/* Table with mixed content */ +mixed_table : { + name: "Alice", + age: 30, + add: x y -> x + y, + is_adult: x -> x >= 18 +}; + +/* Test mixed table */ +mixed_name : mixed_table.name; +mixed_age : mixed_table.age; +mixed_sum : mixed_table.add 5 3; +mixed_adult_check : mixed_table.is_adult 25; +..assert mixed_name = "Alice"; +..assert mixed_age = 30; +..assert mixed_sum = 8; +..assert mixed_adult_check = true; + +/* ===== ERROR HANDLING ===== */ + +/* Test error handling for invalid inputs */ +empty_table : {}; + +/* These should not cause errors */ +empty_length : t.length empty_table; +..assert empty_length = 0; + +/* Test safe operations */ +safe_get : t.get empty_table "nonexistent" "default"; +..assert safe_get = "default"; + +..out "Table enhancements test completed successfully"; \ No newline at end of file diff --git a/js/scripting-lang/tests/17_table_enhancements_minimal.txt b/js/scripting-lang/tests/17_table_enhancements_minimal.txt new file mode 100644 index 0000000..bdb1c96 --- /dev/null +++ b/js/scripting-lang/tests/17_table_enhancements_minimal.txt @@ -0,0 +1,31 @@ +/* Minimal Unit Test: Table Enhancements */ + +/* Enhanced map with tables */ +numbers : {1, 2, 3, 4, 5}; +double : x -> x * 2; + +/* Test map with single table */ +doubled : map @double numbers; +first : doubled[1]; +second : doubled[2]; +..assert first = 2; +..assert second = 4; + +/* Test t.map */ +t_doubled : t.map @double numbers; +t_first : t_doubled[1]; +..assert t_first = 2; + +/* Test each */ +each_add : each @add numbers 10; +each_1 : each_add[1]; +..assert each_1 = 11; + +/* Test embedded functions */ +calculator : { + add: x y -> x + y +}; +add_result : calculator.add 5 3; +..assert add_result = 8; + +..out "Minimal table enhancements test completed"; \ No newline at end of file diff --git a/js/scripting-lang/tests/17_table_enhancements_step1.txt b/js/scripting-lang/tests/17_table_enhancements_step1.txt new file mode 100644 index 0000000..79dae16 --- /dev/null +++ b/js/scripting-lang/tests/17_table_enhancements_step1.txt @@ -0,0 +1,41 @@ +/* Step 1: Enhanced map with tables */ + +numbers : {1, 2, 3, 4, 5}; +double : x -> x * 2; + +/* Test map with single table */ +doubled : map @double numbers; +first : doubled[1]; +second : doubled[2]; +third : doubled[3]; +fourth : doubled[4]; +fifth : doubled[5]; +..assert first = 2; +..assert second = 4; +..assert third = 6; +..assert fourth = 8; +..assert fifth = 10; + +/* Test map with key-value table */ +person : {name: "Alice", age: 30, active: true}; +add_ten : x -> x + 10; + +mapped_person : map @add_ten person; +/* Note: This will add 10 to all values, including strings */ +name_result : mapped_person.name; +age_result : mapped_person.age; +active_result : mapped_person.active; +..assert name_result = "Alice10"; +..assert age_result = 40; +..assert active_result = 11; + +/* Enhanced filter with tables */ +is_even : x -> x % 2 = 0; +evens : filter @is_even numbers; +even_2 : evens[2]; +even_4 : evens[4]; +/* Note: Keys 1, 3, 5 don't exist in filtered result */ +..assert even_2 = 2; +..assert even_4 = 4; + +..out "Step 3 completed"; \ No newline at end of file diff --git a/js/scripting-lang/tests/18_each_combinator.txt b/js/scripting-lang/tests/18_each_combinator.txt new file mode 100644 index 0000000..45c941a --- /dev/null +++ b/js/scripting-lang/tests/18_each_combinator.txt @@ -0,0 +1,22 @@ +/* Simple each test */ + +numbers : {1, 2, 3, 4, 5}; + +/* each with table and scalar */ +each_add : each @add numbers 10; +each_1 : each_add[1]; +each_2 : each_add[2]; +each_3 : each_add[3]; +..assert each_1 = 11; +..assert each_2 = 12; +..assert each_3 = 13; + +/* each with two tables */ +table1 : {a: 1, b: 2, c: 3}; +table2 : {a: 10, b: 20, c: 30}; +each_sum : each @add table1 table2; +..assert each_sum.a = 11; +..assert each_sum.b = 22; +..assert each_sum.c = 33; + +..out "Simple each test completed"; \ No newline at end of file diff --git a/js/scripting-lang/tests/18_each_combinator_basic.txt b/js/scripting-lang/tests/18_each_combinator_basic.txt new file mode 100644 index 0000000..d926013 --- /dev/null +++ b/js/scripting-lang/tests/18_each_combinator_basic.txt @@ -0,0 +1,30 @@ +/* Basic Unit Test: Each Combinator */ + +/* Test data */ +numbers : {1, 2, 3, 4, 5}; +table1 : {a: 1, b: 2, c: 3}; +table2 : {a: 10, b: 20, c: 30}; + +/* each with table and scalar */ +each_add : each @add numbers 10; +each_1 : each_add[1]; +each_2 : each_add[2]; +each_3 : each_add[3]; +..assert each_1 = 11; +..assert each_2 = 12; +..assert each_3 = 13; + +/* each with two tables */ +each_sum : each @add table1 table2; +..assert each_sum.a = 11; +..assert each_sum.b = 22; +..assert each_sum.c = 33; + +/* each with empty table */ +empty_table : {}; +empty_result : each @add empty_table 10; +/* Check that empty_result is an empty object by checking its length */ +empty_length : t.length empty_result; +..assert empty_length = 0; + +..out "Basic each combinator test completed successfully"; \ No newline at end of file diff --git a/js/scripting-lang/tests/18_each_combinator_minimal.txt b/js/scripting-lang/tests/18_each_combinator_minimal.txt new file mode 100644 index 0000000..1cd6516 --- /dev/null +++ b/js/scripting-lang/tests/18_each_combinator_minimal.txt @@ -0,0 +1,62 @@ +/* Minimal Unit Test: Each Combinator */ + +/* Test data */ +numbers : {1, 2, 3, 4, 5}; +table1 : {a: 1, b: 2, c: 3}; +table2 : {a: 10, b: 20, c: 30}; + +/* each with table and scalar */ +each_add : each @add numbers 10; +each_1 : each_add[1]; +each_2 : each_add[2]; +each_3 : each_add[3]; +..assert each_1 = 11; +..assert each_2 = 12; +..assert each_3 = 13; + +/* each with two tables */ +each_sum : each @add table1 table2; +..assert each_sum.a = 11; +..assert each_sum.b = 22; +..assert each_sum.c = 33; + +/* each with scalar and table */ +each_add_scalar : each @add 10 numbers; +scalar_1 : each_add_scalar[1]; +scalar_2 : each_add_scalar[2]; +scalar_3 : each_add_scalar[3]; +..assert scalar_1 = 11; +..assert scalar_2 = 12; +..assert scalar_3 = 13; + +/* each with partial application */ +add_to_ten : each @add 10; +partial_result : add_to_ten numbers; +partial_1 : partial_result[1]; +partial_2 : partial_result[2]; +partial_3 : partial_result[3]; +..assert partial_1 = 11; +..assert partial_2 = 12; +..assert partial_3 = 13; + +/* each with different operations */ +each_multiply : each @multiply numbers 2; +mult_1 : each_multiply[1]; +mult_2 : each_multiply[2]; +mult_3 : each_multiply[3]; +..assert mult_1 = 2; +..assert mult_2 = 4; +..assert mult_3 = 6; + +/* each with empty table */ +empty_table : {}; +empty_result : each @add empty_table 10; +empty_length : t.length empty_result; +..assert empty_length = 0; + +/* each with single element table */ +single_table : {key: 5}; +single_result : each @add single_table 10; +..assert single_result.key = 15; + +..out "Minimal each combinator test completed successfully"; \ No newline at end of file diff --git a/js/scripting-lang/tests/19_embedded_functions.txt b/js/scripting-lang/tests/19_embedded_functions.txt new file mode 100644 index 0000000..a0e16aa --- /dev/null +++ b/js/scripting-lang/tests/19_embedded_functions.txt @@ -0,0 +1,101 @@ +/* Simple Unit Test: Embedded Functions in Tables */ + +/* ===== EMBEDDED ARROW FUNCTIONS ===== */ + +/* Table with simple arrow functions */ +calculator : { + add: x y -> x + y, + multiply: x y -> x * y, + double: x -> x * 2, + square: x -> x * x +}; + +/* Test embedded arrow function calls */ +add_result : calculator.add 5 3; +multiply_result : calculator.multiply 4 6; +double_result : calculator.double 7; +square_result : calculator.square 5; +..assert add_result = 8; +..assert multiply_result = 24; +..assert double_result = 14; +..assert square_result = 25; + +/* Table with more complex arrow functions */ +math_ops : { + increment: x -> x + 1, + decrement: x -> x - 1, + negate: x -> -x, + double: x -> x * 2 +}; + +/* Test complex arrow functions */ +inc_result : math_ops.increment 10; +dec_result : math_ops.decrement 10; +neg_result : math_ops.negate 5; +math_double : math_ops.double 7; +..assert inc_result = 11; +..assert dec_result = 9; +..assert neg_result = -5; +..assert math_double = 14; + +/* ===== EMBEDDED WHEN EXPRESSIONS ===== */ + +/* Table with embedded when expressions */ +classifier : { + classify: x -> when x is + 0 then "zero" + 1 then "one" + 2 then "two" + _ then "other" +}; + +/* Test embedded when expressions */ +zero_class : classifier.classify 0; +one_class : classifier.classify 1; +two_class : classifier.classify 2; +other_class : classifier.classify 42; +..assert zero_class = "zero"; +..assert one_class = "one"; +..assert two_class = "two"; +..assert other_class = "other"; + +/* ===== MIXED CONTENT TABLES ===== */ + +/* Table with mixed data and functions */ +person : { + name: "Alice", + age: 30, + city: "NYC", + greet: name -> "Hello, " + name +}; + +/* Test mixed table access */ +name : person.name; +age : person.age; +greeting : person.greet "Bob"; +..assert name = "Alice"; +..assert age = 30; +..assert greeting = "Hello, Bob"; + +/* ===== EDGE CASES ===== */ + +/* Table with empty function */ +empty_func : { + noop: x -> x +}; + +/* Test empty function */ +noop_result : empty_func.noop 42; +..assert noop_result = 42; + +/* Table with function that returns table */ +table_returner : { + create_person: name age -> {name: name, age: age} +}; + +/* Test function that returns table */ +new_person : table_returner.create_person "Bob" 25; +..assert new_person.name = "Bob"; +..assert new_person.age = 25; + +..out "Simple embedded functions test completed successfully"; \ No newline at end of file diff --git a/js/scripting-lang/tests/19_embedded_functions_simple.txt b/js/scripting-lang/tests/19_embedded_functions_simple.txt new file mode 100644 index 0000000..a0e16aa --- /dev/null +++ b/js/scripting-lang/tests/19_embedded_functions_simple.txt @@ -0,0 +1,101 @@ +/* Simple Unit Test: Embedded Functions in Tables */ + +/* ===== EMBEDDED ARROW FUNCTIONS ===== */ + +/* Table with simple arrow functions */ +calculator : { + add: x y -> x + y, + multiply: x y -> x * y, + double: x -> x * 2, + square: x -> x * x +}; + +/* Test embedded arrow function calls */ +add_result : calculator.add 5 3; +multiply_result : calculator.multiply 4 6; +double_result : calculator.double 7; +square_result : calculator.square 5; +..assert add_result = 8; +..assert multiply_result = 24; +..assert double_result = 14; +..assert square_result = 25; + +/* Table with more complex arrow functions */ +math_ops : { + increment: x -> x + 1, + decrement: x -> x - 1, + negate: x -> -x, + double: x -> x * 2 +}; + +/* Test complex arrow functions */ +inc_result : math_ops.increment 10; +dec_result : math_ops.decrement 10; +neg_result : math_ops.negate 5; +math_double : math_ops.double 7; +..assert inc_result = 11; +..assert dec_result = 9; +..assert neg_result = -5; +..assert math_double = 14; + +/* ===== EMBEDDED WHEN EXPRESSIONS ===== */ + +/* Table with embedded when expressions */ +classifier : { + classify: x -> when x is + 0 then "zero" + 1 then "one" + 2 then "two" + _ then "other" +}; + +/* Test embedded when expressions */ +zero_class : classifier.classify 0; +one_class : classifier.classify 1; +two_class : classifier.classify 2; +other_class : classifier.classify 42; +..assert zero_class = "zero"; +..assert one_class = "one"; +..assert two_class = "two"; +..assert other_class = "other"; + +/* ===== MIXED CONTENT TABLES ===== */ + +/* Table with mixed data and functions */ +person : { + name: "Alice", + age: 30, + city: "NYC", + greet: name -> "Hello, " + name +}; + +/* Test mixed table access */ +name : person.name; +age : person.age; +greeting : person.greet "Bob"; +..assert name = "Alice"; +..assert age = 30; +..assert greeting = "Hello, Bob"; + +/* ===== EDGE CASES ===== */ + +/* Table with empty function */ +empty_func : { + noop: x -> x +}; + +/* Test empty function */ +noop_result : empty_func.noop 42; +..assert noop_result = 42; + +/* Table with function that returns table */ +table_returner : { + create_person: name age -> {name: name, age: age} +}; + +/* Test function that returns table */ +new_person : table_returner.create_person "Bob" 25; +..assert new_person.name = "Bob"; +..assert new_person.age = 25; + +..out "Simple embedded functions test completed successfully"; \ No newline at end of file diff --git a/js/scripting-lang/tests/20_via_operator.txt b/js/scripting-lang/tests/20_via_operator.txt new file mode 100644 index 0000000..afdc4c3 --- /dev/null +++ b/js/scripting-lang/tests/20_via_operator.txt @@ -0,0 +1,31 @@ +/* Unit Test: Via Operator */ +/* Tests: Function composition using the 'via' keyword */ + +/* Basic functions for testing */ +double : x -> x * 2; +increment : x -> x + 1; +square : x -> x * x; + +/* Test 1: Basic via composition */ +result1 : double via increment 5; +..assert result1 = 12; /* (5+1)*2 = 12 */ + +/* Test 2: Chained via composition */ +result2 : double via increment via square 3; +..assert result2 = 20; /* (3^2+1)*2 = (9+1)*2 = 20 */ + +/* Test 3: Function references with via */ +result3 : @double via @increment 4; +..assert result3 = 10; /* (4+1)*2 = 10 */ + +/* Test 4: Right-associative behavior */ +step1 : increment via square 3; /* (3^2)+1 = 10 */ +step2 : double via increment 3; /* (3+1)*2 = 8 */ +..assert step1 = 10; +..assert step2 = 8; + +/* Test 5: Precedence - via binds tighter than function application */ +precedence_test : double via increment 5; +..assert precedence_test = 12; /* (5+1)*2 = 12 */ + +..out "Via operator test completed"; \ No newline at end of file diff --git a/js/scripting-lang/tests/21_enhanced_case_statements.txt b/js/scripting-lang/tests/21_enhanced_case_statements.txt new file mode 100644 index 0000000..79adb69 --- /dev/null +++ b/js/scripting-lang/tests/21_enhanced_case_statements.txt @@ -0,0 +1,98 @@ +/* Unit Test: Enhanced Case Statements - Fixed Version */ +/* Tests: FizzBuzz and advanced pattern matching with new capabilities */ + +/* ===== FIZZBUZZ IMPLEMENTATION ===== */ + +/* Classic FizzBuzz using multi-value patterns with expressions */ +fizzbuzz : n -> + when (n % 3) (n % 5) is + 0 0 then "FizzBuzz" + 0 _ then "Fizz" + _ 0 then "Buzz" + _ _ then n; + +/* Test FizzBuzz implementation */ +fizzbuzz_15 : fizzbuzz 15; +fizzbuzz_3 : fizzbuzz 3; +fizzbuzz_5 : fizzbuzz 5; +fizzbuzz_7 : fizzbuzz 7; + +/* ===== TABLE ACCESS IN WHEN EXPRESSIONS ===== */ + +/* User data for testing */ +admin_user : {role: "admin", level: 5, name: "Alice"}; +user_user : {role: "user", level: 2, name: "Bob"}; +guest_user : {role: "guest", level: 0, name: "Charlie"}; + +/* Access control using table access in patterns */ +access_level : user -> + when user.role is + "admin" then "full access" + "user" then "limited access" + _ then "no access"; + +/* Test access control */ +admin_access : access_level admin_user; +user_access : access_level user_user; +guest_access : access_level guest_user; + +/* ===== FUNCTION CALLS IN WHEN EXPRESSIONS ===== */ + +/* Helper functions for testing */ +is_even : n -> n % 2 = 0; + +/* Number classification using function calls in patterns */ +classify_number : n -> + when (is_even n) is + true then "even number" + false then "odd number"; + +/* Test number classification */ +even_class : classify_number 4; +odd_class : classify_number 7; + +/* ===== SIMPLIFIED MULTI-VALUE VALIDATION ===== */ + +/* Simplified validation - avoid complex and expressions */ +validate_name : name -> name != ""; +validate_age : age -> age >= 0; + +validate_user : name age -> + when (validate_name name) (validate_age age) is + true true then "valid user" + true false then "invalid age" + false true then "invalid name" + false false then "invalid user"; + +/* Test user validation */ +valid_user : validate_user "Alice" 30; +invalid_age : validate_user "Bob" -5; +invalid_name : validate_user "" 25; + +/* ===== OUTPUT RESULTS ===== */ + +/* Output FizzBuzz results */ +..out "FizzBuzz Results:"; +..out fizzbuzz_15; +..out fizzbuzz_3; +..out fizzbuzz_5; +..out fizzbuzz_7; + +/* Output access control results */ +..out "Access Control Results:"; +..out admin_access; +..out user_access; +..out guest_access; + +/* Output number classification results */ +..out "Number Classification Results:"; +..out even_class; +..out odd_class; + +/* Output user validation results */ +..out "User Validation Results:"; +..out valid_user; +..out invalid_age; +..out invalid_name; + +..out "Enhanced case statements test completed successfully"; \ No newline at end of file diff --git a/js/scripting-lang/tests/21_enhanced_case_statements_fixed.txt b/js/scripting-lang/tests/21_enhanced_case_statements_fixed.txt new file mode 100644 index 0000000..79adb69 --- /dev/null +++ b/js/scripting-lang/tests/21_enhanced_case_statements_fixed.txt @@ -0,0 +1,98 @@ +/* Unit Test: Enhanced Case Statements - Fixed Version */ +/* Tests: FizzBuzz and advanced pattern matching with new capabilities */ + +/* ===== FIZZBUZZ IMPLEMENTATION ===== */ + +/* Classic FizzBuzz using multi-value patterns with expressions */ +fizzbuzz : n -> + when (n % 3) (n % 5) is + 0 0 then "FizzBuzz" + 0 _ then "Fizz" + _ 0 then "Buzz" + _ _ then n; + +/* Test FizzBuzz implementation */ +fizzbuzz_15 : fizzbuzz 15; +fizzbuzz_3 : fizzbuzz 3; +fizzbuzz_5 : fizzbuzz 5; +fizzbuzz_7 : fizzbuzz 7; + +/* ===== TABLE ACCESS IN WHEN EXPRESSIONS ===== */ + +/* User data for testing */ +admin_user : {role: "admin", level: 5, name: "Alice"}; +user_user : {role: "user", level: 2, name: "Bob"}; +guest_user : {role: "guest", level: 0, name: "Charlie"}; + +/* Access control using table access in patterns */ +access_level : user -> + when user.role is + "admin" then "full access" + "user" then "limited access" + _ then "no access"; + +/* Test access control */ +admin_access : access_level admin_user; +user_access : access_level user_user; +guest_access : access_level guest_user; + +/* ===== FUNCTION CALLS IN WHEN EXPRESSIONS ===== */ + +/* Helper functions for testing */ +is_even : n -> n % 2 = 0; + +/* Number classification using function calls in patterns */ +classify_number : n -> + when (is_even n) is + true then "even number" + false then "odd number"; + +/* Test number classification */ +even_class : classify_number 4; +odd_class : classify_number 7; + +/* ===== SIMPLIFIED MULTI-VALUE VALIDATION ===== */ + +/* Simplified validation - avoid complex and expressions */ +validate_name : name -> name != ""; +validate_age : age -> age >= 0; + +validate_user : name age -> + when (validate_name name) (validate_age age) is + true true then "valid user" + true false then "invalid age" + false true then "invalid name" + false false then "invalid user"; + +/* Test user validation */ +valid_user : validate_user "Alice" 30; +invalid_age : validate_user "Bob" -5; +invalid_name : validate_user "" 25; + +/* ===== OUTPUT RESULTS ===== */ + +/* Output FizzBuzz results */ +..out "FizzBuzz Results:"; +..out fizzbuzz_15; +..out fizzbuzz_3; +..out fizzbuzz_5; +..out fizzbuzz_7; + +/* Output access control results */ +..out "Access Control Results:"; +..out admin_access; +..out user_access; +..out guest_access; + +/* Output number classification results */ +..out "Number Classification Results:"; +..out even_class; +..out odd_class; + +/* Output user validation results */ +..out "User Validation Results:"; +..out valid_user; +..out invalid_age; +..out invalid_name; + +..out "Enhanced case statements test completed successfully"; \ No newline at end of file diff --git a/js/scripting-lang/tests/22_parser_limitations.txt b/js/scripting-lang/tests/22_parser_limitations.txt new file mode 100644 index 0000000..6d267b8 --- /dev/null +++ b/js/scripting-lang/tests/22_parser_limitations.txt @@ -0,0 +1,115 @@ +/* Unit Test: Parser Limitations for Enhanced Case Statements */ +/* Tests: Multi-value patterns with expressions, table access, function calls */ + +/* ======================================== */ +/* MAIN BLOCKER: Multi-value patterns with expressions */ +/* ======================================== */ + +/* Test 1: Basic multi-value with expressions in parentheses */ +test_multi_expr : x y -> + when (x % 2) (y % 2) is + 0 0 then "both even" + 0 1 then "x even, y odd" + 1 0 then "x odd, y even" + 1 1 then "both odd"; + +/* Test 2: FizzBuzz-style multi-value patterns */ +fizzbuzz_test : n -> + when (n % 3) (n % 5) is + 0 0 then "FizzBuzz" + 0 _ then "Fizz" + _ 0 then "Buzz" + _ _ then n; + +/* Test 3: Complex expressions in multi-value patterns */ +complex_multi : x y -> + when ((x + 1) % 2) ((y - 1) % 2) is + 0 0 then "both transformed even" + 0 1 then "x transformed even, y transformed odd" + 1 0 then "x transformed odd, y transformed even" + 1 1 then "both transformed odd"; + +/* Test 4: Function calls in multi-value patterns */ +is_even : n -> n % 2 = 0; +is_positive : n -> n > 0; + +test_func_multi : x y -> + when (is_even x) (is_positive y) is + true true then "x even and y positive" + true false then "x even and y not positive" + false true then "x odd and y positive" + false false then "x odd and y not positive"; + +/* ======================================== */ +/* SECONDARY LIMITATIONS: Table access and function calls */ +/* ======================================== */ + +/* Test 5: Table access in when expressions */ +user : {role: "admin", level: 5}; +test_table_access : u -> + when u.role is + "admin" then "admin user" + "user" then "regular user" + _ then "unknown role"; + +/* Test 6: Function calls in when expressions */ +test_func_call : n -> + when (is_even n) is + true then "even number" + false then "odd number"; + +/* Test 7: Complex function calls in when expressions */ +complex_func : n -> (n % 3 = 0) and (n % 5 = 0); +test_complex_func : n -> + when (complex_func n) is + true then "divisible by both 3 and 5" + false then "not divisible by both"; + +/* ======================================== */ +/* CONTROL TESTS: Should work with current parser */ +/* ======================================== */ + +/* Test 8: Simple value matching (control) */ +test_simple : n -> + when n is + 0 then "zero" + 1 then "one" + _ then "other"; + +/* Test 9: Single complex expressions with parentheses (control) */ +test_single_expr : n -> + when (n % 3) is + 0 then "divisible by 3" + _ then "not divisible by 3"; + +/* Test 10: Multiple simple values (control) */ +test_multi_simple : x y -> + when x y is + 0 0 then "both zero" + 0 _ then "x zero" + _ 0 then "y zero" + _ _ then "neither zero"; + +/* ======================================== */ +/* TEST EXECUTION */ +/* ======================================== */ + +/* Execute tests that should work */ +result1 : test_simple 5; +result2 : test_single_expr 15; +result3 : test_multi_simple 0 5; + +/* These should fail with current parser */ +result4 : test_multi_expr 4 6; /* Should return "both even" */ +result5 : fizzbuzz_test 15; /* Should return "FizzBuzz" */ +result6 : test_table_access user; /* Should return "admin user" */ +result7 : test_func_call 4; /* Should return "even number" */ + +/* Output results */ +..out result1; +..out result2; +..out result3; +..out result4; +..out result5; +..out result6; +..out result7; \ No newline at end of file diff --git a/js/scripting-lang/tests/23_minus_operator_spacing.txt b/js/scripting-lang/tests/23_minus_operator_spacing.txt new file mode 100644 index 0000000..510b997 --- /dev/null +++ b/js/scripting-lang/tests/23_minus_operator_spacing.txt @@ -0,0 +1,51 @@ +/* Test file for minus operator spacing functionality */ +/* This tests the new spacing-based ambiguity resolution for minus operator */ + +..out "=== Minus Operator Spacing Tests ==="; + +/* Basic unary minus tests */ +test1 : -5; +test2 : -3.14; +test3 : -10; +test4 : -42; + +/* Basic binary minus tests */ +test5 : 5 - 3; +test6 : 10 - 5; +test7 : 15 - 7; +test8 : 10 - 2.5; + +/* Legacy syntax tests (should continue to work) */ +test9 : (-5); +test10 : (-3.14); +test11 : (-10); +test12 : 5-3; +test13 : 15-7; + +/* Complex negative expressions */ +test14 : -10 - -100; +test15 : -5 - -3; +test16 : -20 - -30; + +/* Assertions to validate behavior */ +..assert test1 = -5; /* Unary minus: -5 */ +..assert test2 = -3.14; /* Unary minus: -3.14 */ +..assert test3 = -10; /* Unary minus: -10 */ +..assert test4 = -42; /* Unary minus: -42 */ + +..assert test5 = 2; /* Binary minus: 5 - 3 = 2 */ +..assert test6 = 5; /* Binary minus: 10 - 5 = 5 */ +..assert test7 = 8; /* Binary minus: 15 - 7 = 8 */ +..assert test8 = 7.5; /* Binary minus: 10 - 2.5 = 7.5 */ + +..assert test9 = -5; /* Legacy: (-5) = -5 */ +..assert test10 = -3.14; /* Legacy: (-3.14) = -3.14 */ +..assert test11 = -10; /* Legacy: (-10) = -10 */ +..assert test12 = 2; /* Legacy: 5-3 = 2 */ +..assert test13 = 8; /* Legacy: 15-7 = 8 */ + +..assert test14 = 90; /* Complex: -10 - -100 = 90 */ +..assert test15 = -2; /* Complex: -5 - -3 = -2 */ +..assert test16 = 10; /* Complex: -20 - -30 = 10 */ + +..out "=== Basic Minus Operator Spacing Tests Passed ==="; \ No newline at end of file diff --git a/js/scripting-lang/tests/integration_01_basic_features.txt b/js/scripting-lang/tests/integration_01_basic_features.txt index cb215ab..de16702 100644 --- a/js/scripting-lang/tests/integration_01_basic_features.txt +++ b/js/scripting-lang/tests/integration_01_basic_features.txt @@ -4,15 +4,15 @@ ..out "=== Integration Test: Basic Features ==="; /* Define utility functions */ -add : x y -> x + y; -multiply : x y -> x * y; +add_func : x y -> x + y; +multiply_func : x y -> x * y; isEven : x -> x % 2 = 0; isPositive : x -> x > 0; /* Test arithmetic with functions */ -sum : add 10 5; -product : multiply 4 6; -doubled : multiply 2 sum; +sum : add_func 10 5; +product : multiply_func 4 6; +doubled : multiply_func 2 sum; ..assert sum = 15; ..assert product = 24; @@ -22,7 +22,7 @@ doubled : multiply 2 sum; even_test : isEven 8; odd_test : isEven 7; positive_test : isPositive 5; -negative_test : isPositive -3; +negative_test : isPositive (-3); ..assert even_test = true; ..assert odd_test = false; @@ -30,7 +30,7 @@ negative_test : isPositive -3; ..assert negative_test = false; /* Test complex expressions */ -complex : add (multiply 3 4) (isEven 10 and isPositive 5); +complex : add_func (multiply_func 3 4) (isEven 10 and isPositive 5); ..assert complex = 13; diff --git a/js/scripting-lang/tests/integration_02_pattern_matching.txt b/js/scripting-lang/tests/integration_02_pattern_matching.txt index f0b969a..a67bf59 100644 --- a/js/scripting-lang/tests/integration_02_pattern_matching.txt +++ b/js/scripting-lang/tests/integration_02_pattern_matching.txt @@ -5,21 +5,21 @@ /* Recursive factorial with case expressions */ factorial : n -> - case n of - 0 : 1 - _ : n * (factorial (n - 1)); + when n is + 0 then 1 + _ then n * (factorial (n - 1)); /* Pattern matching with multiple parameters */ classify : x y -> - case x y of - 0 0 : "both zero" - 0 _ : "x is zero" - _ 0 : "y is zero" - _ _ : case x of - 0 : "x is zero (nested)" - _ : case y of - 0 : "y is zero (nested)" - _ : "neither zero"; + when x y is + 0 0 then "both zero" + 0 _ then "x is zero" + _ 0 then "y is zero" + _ _ then when x is + 0 then "x is zero (nested)" + _ then when y is + 0 then "y is zero (nested)" + _ then "neither zero"; /* Test factorial */ fact5 : factorial 5; @@ -41,15 +41,15 @@ test4 : classify 5 5; /* Complex nested case expressions */ analyze : x y z -> - case x y z of - 0 0 0 : "all zero" - 0 0 _ : "x and y zero" - 0 _ 0 : "x and z zero" - _ 0 0 : "y and z zero" - 0 _ _ : "only x zero" - _ 0 _ : "only y zero" - _ _ 0 : "only z zero" - _ _ _ : "none zero"; + when x y z is + 0 0 0 then "all zero" + 0 0 _ then "x and y zero" + 0 _ 0 then "x and z zero" + _ 0 0 then "y and z zero" + 0 _ _ then "only x zero" + _ 0 _ then "only y zero" + _ _ 0 then "only z zero" + _ _ _ then "none zero"; result1 : analyze 0 0 0; result2 : analyze 0 1 1; diff --git a/js/scripting-lang/tests/integration_03_functional_programming.txt b/js/scripting-lang/tests/integration_03_functional_programming.txt index 8af6760..a0e3668 100644 --- a/js/scripting-lang/tests/integration_03_functional_programming.txt +++ b/js/scripting-lang/tests/integration_03_functional_programming.txt @@ -4,33 +4,33 @@ ..out "=== Integration Test: Functional Programming ==="; /* Basic functions */ -double : x -> x * 2; -square : x -> x * x; +double_func : x -> x * 2; +square_func : x -> x * x; add1 : x -> x + 1; -identity : x -> x; +identity_func : x -> x; isEven : x -> x % 2 = 0; /* Function composition */ -composed1 : compose @double @square 3; -composed2 : compose @square @double 2; -composed3 : compose @add1 @double 5; +composed1 : compose @double_func @square_func 3; +composed2 : compose @square_func @double_func 2; +composed3 : compose @add1 @double_func 5; ..assert composed1 = 18; ..assert composed2 = 16; ..assert composed3 = 11; /* Function piping */ -piped1 : pipe @double @square 3; -piped2 : pipe @square @double 2; -piped3 : pipe @add1 @double 5; +piped1 : pipe @double_func @square_func 3; +piped2 : pipe @square_func @double_func 2; +piped3 : pipe @add1 @double_func 5; ..assert piped1 = 36; ..assert piped2 = 8; ..assert piped3 = 12; /* Function application */ -applied1 : apply @double 7; -applied2 : apply @square 4; +applied1 : apply @double_func 7; +applied2 : apply @square_func 4; applied3 : apply @add1 10; ..assert applied1 = 14; @@ -39,11 +39,11 @@ applied3 : apply @add1 10; /* Function selection with case expressions */ getOperation : type -> - case type of - "double" : @double - "square" : @square - "add1" : @add1 - _ : @identity; + when type is + "double" then @double_func + "square" then @square_func + "add1" then @add1 + _ then @identity_func; /* Test function selection */ op1 : getOperation "double"; @@ -62,7 +62,7 @@ result4 : op4 3; ..assert result4 = 3; /* Complex functional composition */ -complex : compose @double (compose @square @add1) 3; +complex : compose @double_func (compose @square_func @add1) 3; ..assert complex = 32; ..out "Functional programming integration test completed"; \ No newline at end of file diff --git a/js/scripting-lang/tests/integration_04_mini_case_multi_param.txt b/js/scripting-lang/tests/integration_04_mini_case_multi_param.txt new file mode 100644 index 0000000..1814ae5 --- /dev/null +++ b/js/scripting-lang/tests/integration_04_mini_case_multi_param.txt @@ -0,0 +1,21 @@ +/* Integration Test: Multi-parameter case expression at top level */ + +/* Test multi-parameter case expressions */ +compare : x y -> + when x y is + 0 0 then "both zero" + 0 _ then "x is zero" + _ 0 then "y is zero" + _ _ then "neither zero"; + +test1 : compare 0 0; +test2 : compare 0 5; +test3 : compare 5 0; +test4 : compare 5 5; + +..assert test1 = "both zero"; +..assert test2 = "x is zero"; +..assert test3 = "y is zero"; +..assert test4 = "neither zero"; + +..out "Multi-parameter case expression test completed"; \ No newline at end of file diff --git a/js/scripting-lang/tests/mini_case_multi_param.txt b/js/scripting-lang/tests/mini_case_multi_param.txt deleted file mode 100644 index be4b71d..0000000 --- a/js/scripting-lang/tests/mini_case_multi_param.txt +++ /dev/null @@ -1,17 +0,0 @@ -/* Multi-parameter case expression at top level */ -x : 1; -y : 2; -result1 : case x y of - 1 2 : "matched" - _ _ : "not matched"; - -/* Multi-parameter case expression inside a function */ -f : a b -> case a b of - 1 2 : "matched" - _ _ : "not matched"; -result2 : f 1 2; -result3 : f 3 4; - -..out result1; -..out result2; -..out result3; \ No newline at end of file diff --git a/js/scripting-lang/tests/repl_demo.txt b/js/scripting-lang/tests/repl_demo.txt new file mode 100644 index 0000000..c96f911 --- /dev/null +++ b/js/scripting-lang/tests/repl_demo.txt @@ -0,0 +1,180 @@ +/* REPL Demo - Comprehensive Language Feature Showcase */ + +/* ===== BASIC OPERATIONS ===== */ +/* Arithmetic and function application */ +x : 5; +y : 10; +sum : x + y; +product : x * y; +difference : y - x; +quotient : y / x; + +/* Function application and partial application */ +double : multiply 2; +triple : multiply 3; +add5 : add 5; +result1 : double 10; +result2 : add5 15; + +/* ===== TABLE OPERATIONS ===== */ +/* Array-like tables */ +numbers : {1, 2, 3, 4, 5}; +fruits : {"apple", "banana", "cherry", "date"}; + +/* Key-value tables */ +person : {name: "Alice", age: 30, active: true, skills: {"JavaScript", "Python", "Rust"}}; +config : {debug: true, port: 3000, host: "localhost"}; + +/* Mixed tables */ +mixed : {1, name: "Bob", 2, active: false, 3, "value"}; + +/* Table access */ +first_number : numbers[1]; +person_name : person.name; +mixed_name : mixed.name; + +/* ===== FUNCTIONAL PROGRAMMING ===== */ +/* Higher-order functions */ +doubled_numbers : map @double numbers; +filtered_numbers : filter @(lessThan 3) numbers; +sum_of_numbers : reduce @add 0 numbers; + +/* Function composition */ +compose_example : double via add5 via negate; +result3 : compose_example 10; + +/* Pipeline operations */ +pipeline : numbers via map @double via filter @(greaterThan 5) via reduce @add 0; + +/* ===== PATTERN MATCHING ===== */ +/* When expressions */ +grade : 85; +letter_grade : when grade { + >= 90: "A"; + >= 80: "B"; + >= 70: "C"; + >= 60: "D"; + default: "F"; +}; + +/* Complex pattern matching */ +status : "active"; +access_level : when status { + "admin": "full"; + "moderator": "limited"; + "user": "basic"; + default: "none"; +}; + +/* ===== ADVANCED COMBINATORS ===== */ +/* Combinator examples */ +numbers2 : {2, 4, 6, 8, 10}; +evens : filter @(equals 0 via modulo 2) numbers2; +squares : map @(power 2) numbers2; +sum_squares : reduce @add 0 squares; + +/* Function composition with combinators */ +complex_pipeline : numbers via + map @(multiply 2) via + filter @(greaterThan 5) via + map @(power 2) via + reduce @add 0; + +/* ===== TABLE ENHANCEMENTS ===== */ +/* Table transformations */ +users : { + user1: {name: "Alice", age: 25, role: "admin"}, + user2: {name: "Bob", age: 30, role: "user"}, + user3: {name: "Charlie", age: 35, role: "moderator"} +}; + +/* Extract specific fields */ +names : map @(constant "name") users; +ages : map @(constant "age") users; + +/* Filter by conditions */ +admins : filter @(equals "admin" via constant "role") users; +young_users : filter @(lessThan 30 via constant "age") users; + +/* ===== REAL-WORLD EXAMPLES ===== */ +/* Data processing pipeline */ +data : {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; +processed : data via + filter @(greaterThan 5) via + map @(multiply 3) via + filter @(lessThan 25); + +/* Configuration management */ +default_config : {port: 3000, host: "localhost", debug: false}; +user_config : {port: 8080, debug: true}; +merged_config : merge default_config user_config; + +/* ===== ERROR HANDLING EXAMPLES ===== */ +/* Safe operations */ +safe_divide : (x, y) => when y { + 0: "Error: Division by zero"; + default: x / y; +}; + +safe_result1 : safe_divide 10 2; +safe_result2 : safe_divide 10 0; + +/* ===== PERFORMANCE EXAMPLES ===== */ +/* Large dataset processing */ +large_numbers : {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; +processed_large : large_numbers via + map @(power 2) via + filter @(greaterThan 50) via + reduce @add 0; + +/* ===== DEBUGGING EXAMPLES ===== */ +/* State inspection helpers */ +debug_state : { + numbers: numbers, + person: person, + processed: processed, + config: merged_config +}; + +/* ===== EXPORT EXAMPLES ===== */ +/* Exportable configurations */ +export_config : { + version: "1.0.0", + features: {"tables", "functions", "pattern-matching"}, + examples: { + basic: "Basic arithmetic and function application", + advanced: "Complex functional pipelines", + real_world: "Data processing examples" + } +}; + +/* ===== COMPREHENSIVE SHOWCASE ===== */ +/* This demonstrates all major language features in one pipeline */ +comprehensive_example : { + input: numbers, + doubled: map @double numbers, + filtered: filter @(greaterThan 3) numbers, + composed: double via add5 via negate, + pattern_matched: when (length numbers) { + > 5: "Large dataset"; + > 3: "Medium dataset"; + default: "Small dataset"; + }, + final_result: numbers via + map @(multiply 2) via + filter @(greaterThan 5) via + reduce @add 0 +}; + +/* Output results for verification */ +..out "REPL Demo completed successfully!"; +..out "All language features demonstrated:"; +..out " ✓ Basic operations and arithmetic"; +..out " ✓ Table literals and access"; +..out " ✓ Function application and composition"; +..out " ✓ Pattern matching with when expressions"; +..out " ✓ Higher-order functions and combinators"; +..out " ✓ Table transformations and pipelines"; +..out " ✓ Real-world data processing examples"; +..out " ✓ Error handling and safe operations"; +..out " ✓ Performance and debugging features"; \ No newline at end of file |