#*
 * Examples of how to use bitwise operators
 *#

# Prints "01\n"
assert 0 == (put 1 and 0); 
assert 1 == (say 1 and 1); 

# Prints "01\n"
assert 0 == (put 0 or 0);
assert 1 == (say 0 or 1);

# Prints "01\n"
assert 0 == (put 1 xor 1);
assert 1 == (say 1 xor 0);

# Prints "82\n"
assert 8 == (put 2 :< 2);
assert 2 == (say 8 :> 2);

# A bit more complex, prints "9\n"
assert 9 == (say 1 :< 5 :> 5 or 2 and 5 xor 8);

# Same result, but with parenthesis:
assert 9 == (say ((((1 :< 5) :> 5) or 2) and 5) xor 8);

# Different parenthesis, different result: "1\n"
assert 1 == (say 1 :< 5 :> 5 or 2 and (5 xor 8));

# Prints "-1" 
assert (neg 1) == (say neg not 0);


# break exits the while loop early when i reaches 5
my i = 0;
while i < 10 {
    i = i + 1;
    if i == 5 { break; }
}
assert 5 == say i;          # expected: 5

# next skips adding j when j == 3, so sum = 1+2+4+5 = 12
my sum = 0;
my j = 0;
while j < 5 {
    j = j + 1;
    if j == 3 { next; }
    sum = sum + j;
}
assert 12 == say sum;        # expected: 12

# break inside an until loop stops when k reaches 7
my k = 0;
until k == 10 {
    k = k + 1;
    if k == 7 { break; }
}
assert 7 == say k;          # expected: 7

#*
 * Simple examples how to write comments
 *#

# This is a single lined comment

say 1 + 1; # This is a comment at the end of the line

say 1 #* This is an embedded comment *# + 1;

#* This is
	a
		multiline
			comment *#

#* 
 * This is
 * a nicer looking
 * multiline comment
 *#


#* 
 * Simple conditional tests
 *#

# "0010\n"
assert 0 == (put 1 < 1); 
assert 0 == (put 1 < 0); 
assert 1 == (put 0 < 1); 
assert 0 == (say 0 < 0);

# "0100\n"
assert 0 == (put 1 > 1); 
assert 1 == (put 1 > 0); 
assert 0 == (put 0 > 1); 
assert 0 == (say 0 > 0);

# "1001\n"
assert 1 == (put 1 == 1); 
assert 0 == (put 1 == 0); 
assert 0 == (put 0 == 1);
assert 1 == (say 0 == 0);
 
# "0110\n"
assert 0 == (put 1 != 1);
assert 1 == (put 1 != 0); 
assert 1 == (put 0 != 1); 
assert 0 == (say 0 != 0);

# "1011\n"
assert 1 == (put 1 <= 1); 
assert 0 == (put 1 <= 0); 
assert 1 == (put 0 <= 1); 
assert 1 == (say 0 <= 0);

## "1101\n"
assert 1 == (put 1 >= 1); 
assert 1 == (put 1 >= 0); 
assert 0 == (put 0 >= 1); 
assert 1 == (say 0 >= 0);



#*
 * Examples of how to use control statements
 *#

if 1 { 
	say "if 1";
} 

ifnot 0 == 1 { 
	say "ifnot 0 == 1";
} 

# Calculate 10!

my n = 10, fac = 0;

while n > 1 {
	ifnot fac {
		fac = 1;
	}
	say fac = (fac * n);
	decr n;
}

# Count up to 10

n = 0;

until n == 10 {
	say incr n;
}


#* 
 * Simple expression tests
 *#

# Result 10 
assert 10 == say (8 / 2) + 2 * 3; 

# Result 12 
assert 12 == say 2 * (4 + 2);  

# Result 4 
assert 4 == say 2 * (4 / 2);  

# Result 4 
assert 4 == say 2 * (4 / 2);  

# Result 4 
assert 4 == say 2 * (4 / 2);  

# Result 46 
assert 46 == say "12" + "34";

# Result 1231
assert 1231 == say "1234" - "3";

# Result 24
assert "24" == say "2ab" * "12";

# Result 5.0
assert 5 == say "10 bla" / 2;


#*
 * Examples of how to use fork
 *#

my pid = fork;

if pid {
	put "I am the parent process and the child has the pid ";
	say pid;
}

ifnot pid {
	say "I am the child process";
}

# Test: function named arguments, explicit ret, and multiple return values

# zero-arg function with explicit return
fun answer() {
    ret 42;
}
assert 42 == say answer();

# single-arg function — factorial with a while loop and ret
fun factorial(n) {
    my result = 1;
    while n > 1 {
        result = result * n;
        decr n;
    }
    ret result;
}
assert 120 == say factorial(5);

# two-arg function
fun add(a, b) {
    ret a + b;
}
assert 8 == say add(3, 5);

# conditional return inside if
fun absval(n) {
    if n < 0 { ret neg n; }
    ret n;
}
assert 5 == say absval(5);
assert 5 == say absval(neg 5);

# multiple return values — both land on the caller's stack
fun minmax(a, b) {
    if a < b { ret a, b; }
    ret b, a;
}
say minmax(3, 7);

# old-style zero-arg function without parens still works
fun greet {
    say "hello";
}
greet;

#*
 * Examples of how to use functions
 *#

fun foo {
	say 1 + a * 3 + b;

	fun bar {
		say "Hello i am nested";
	}

	bar; # Calling nested
}

my a = 2, b = 4; # Create global variables
foo;
assert 0 == (defined bar); # bar is not available anymore

fun baz {
	say "I am baz";
	undef baz; 
}

baz; # Baz deletes itself
assert 0 == (defined baz); # baz is not available anymore

#*
 * Simple builtin function tests
 *#

# Print "-20\n"
assert (neg 20) == (say neg 20);

# Print "30\n"
assert 30 == (say 10 - neg 20);

# Print "-30\n"
assert (neg 30) == (say neg neg neg 10 - neg 20);

# Print "Hello\n"
put "Hello";
ln;

# Exit with exit code 0
exit 10 + 10 - 5 - 15;


#*
 * Simple I/O examples. Currently only output is supported.
 *#

# Print out 10 followed by a newline
say 10; 

# Print out 20 without a newline followed
put 20;

# Print out a newline
ln;


# loop — infinite loop, break exits after 5 iterations
my i = 0;
loop {
    i = i + 1;
    if i == 5 { break; }
}
assert 5 == say i;          # expected: 5

# loop with next — skips j==3, so sum = 1+2+4+5 = 12
my sum = 0;
my j = 0;
loop {
    j = j + 1;
    if j > 5 { break; }
    if j == 3 { next; }
    sum = sum + j;
}
assert 12 == say sum;        # expected: 12

# do...while — body runs once even though k >= 10 already
my k = 10;
do {
    k = k + 1;
} while k < 10;
assert 11 == say k;          # expected: 11

# do...until — stops when m reaches 5
my m = 0;
do {
    m = m + 1;
} until m == 5;
assert 5 == say m;          # expected: 5

#*
 * Examples of how to use procedures
 *#

proc foo {
	say 1 + a * 3 + b;
	my c = 6;
}

my a = 2, b = 4;

foo; # Run the procedure. Print out "11\n"
say c; # Print out "6\n";

proc bar {
	say "I am bar";

	undef baz;

	proc baz {
		say "I am baz";
	}
}

# Here bar would produce an error because the proc is not yet defined!
# bar; 

bar; # Here the procedure bar will define the procedure baz!
baz; # Now the procedure baz is defined!
bar; # Here the procedure bar will redefine baz again!

#*
 * Examples of how to use scopeing
 *#

my foo = 1;

{
	# Prints out 1
	assert 1 == (put defined foo);

	{
		my bar = 2;

		# Prints out 1
		assert 1 == (put defined bar);

		# Prints out all available symbols at
		# the current program position.
		scope;
	}

	# Prints out 0
	assert 0 == (put defined bar);

	my baz = 3;
}

# Prints out 0
assert 0 == (say defined bar);



# Test array index expressions and slice notation

my a = [10, 20, 30, 40, 50];

# Expression-based index
my i = 2;
assert 30 == say a[i];
assert 40 == say a[i + 1];

# Array element assignment
a[1] = 99;
assert 99 == say a[1];

# Basic slice (half-open range: end index is exclusive)
my sub = a[1:4];
assert 3 == say len sub;
assert 99 == say sub[0];
assert 30 == say sub[1];
assert 40 == say sub[2];

# Slice from start (low bound omitted)
my head = a[:2];
assert 2 == say len head;
assert 10 == say head[0];

# Slice to end (high bound omitted)
my tail = a[3:];
assert 2 == say len tail;
assert 40 == say tail[0];

# Full copy
my copy = a[:];
assert 5 == say len copy;

#*
 * Examples of how to use synonyms
 *#

# Create a variable foo, and bar is a synonym for foo
my foo = "foo";
my bar = \foo;

# Reset the value of foo
foo = "bar";

# The synonym variable should now also set to "bar"
assert "bar" == say bar;

# Create a new procedure baz
proc baz { 
	say "I am baz";
}

# Make a synonym baz, and undefine baz
my bay = \baz;

# Should be the num of syms for the same value
assert 2 == syms baz;
assert 2 == syms bay;
undef baz;
assert 1 == syms bay;

# bay still has a reference of the original procedure baz
bay; # this prints aut "I am baz" 

assert 0 == defined baz;
assert 1 == defined bay;

# This removes the procedure from memory
undef bay; 


#*
 * Examples how to convert types
 *#

assert 1 == say 1; # Integer output

assert 1 == say double 1; # Double output

assert 14 == say 1 + string 13; # Implicit type conversion to Integer

assert 2 == say integer 2.8; # Rounds down to the Integer 2

assert say integer double string put say neg 12; # Nonsense but working :)


#*
 * Fype uber-example: exercises every language feature.
 * Every assertion must pass for the script to exit cleanly.
 *#

# ─── 1. COMMENTS ─────────────────────────────────────────────────────────────

# Single-line comment — ignored completely.

#*
 * Block comment: also ignored.
 *#

# Inline block comment inside an expression:
my commentsok = 1 #* this is ignored *# + 1;
assert 2 == say commentsok;

# ─── 2. VARIABLES AND BASIC ARITHMETIC ───────────────────────────────────────

# Multiple declarations on one line; bay gets the default value 0
my x = 10, y = 3, bay;
assert 0  == say bay;
assert 13 == say x + y;
assert 7  == say x - y;
assert 30 == say x * y;
assert 3  == say x / y;     # integer division truncates toward zero
assert 10 == say 2 * (4 + 2) - 2;
assert 10 == say (8 / 2) + 2 * 3;

x = x + 1;
assert 11 == say x;

# ─── 3. NEGATION AND NOT ──────────────────────────────────────────────────────

assert 5        == say neg neg 5;
assert 0        == say neg neg 0;
assert (neg 1)  == (say neg not 0);  # not 0 => 1, neg 1 => -1

# ─── 4. INCREMENT / DECREMENT ────────────────────────────────────────────────

my counter = 5;
incr counter;
assert 6 == say counter;
decr counter;
decr counter;
assert 4 == say counter;

# ─── 5. TYPE CONVERSION ───────────────────────────────────────────────────────

assert 2 == say integer 2.8;       # truncates toward zero
assert 1 == say double 1;          # 1.0 compared as 1
assert 14 == say 1 + string 13;    # "13" coerced to integer 13
assert 5 == say "10 bla" / 2;      # leading digits extracted

# ─── 6. STRING ARITHMETIC ────────────────────────────────────────────────────

assert 46   == say "12" + "34";    # "12"->12 + "34"->34 = 46
assert 1231 == say "1234" - "3";   # 1234 - 3 = 1231
assert 5    == say "10 bla" / 2;

# ─── 7. COMPARISON OPERATORS ─────────────────────────────────────────────────

assert 1 == (put 5 > 3);   assert 0 == (say 5 > 5);
assert 1 == (put 5 >= 5);  assert 0 == (say 4 >= 5);
assert 1 == (put 3 < 5);   assert 0 == (say 5 < 5);
assert 1 == (put 3 <= 5);  assert 0 == (say 6 <= 5);
assert 1 == (put 5 == 5);  assert 0 == (say 4 == 5);
assert 1 == (put 5 != 4);  assert 0 == (say 5 != 5);

# ─── 8. BITWISE OPERATORS ────────────────────────────────────────────────────

assert 1 == say (5 and 3);    # 0b101 & 0b011 = 0b001 = 1
assert 7 == say (5 or 2);     # 0b101 | 0b010 = 0b111 = 7
assert 6 == say (5 xor 3);    # 0b101 ^ 0b011 = 0b110 = 6
assert 8 == say (2 :< 2);     # 2 << 2 = 8
assert 2 == say (8 :> 2);     # 8 >> 2 = 2
assert 0 == say (1 and 0);
assert 1 == say (0 or 1);
assert 0 == say (1 xor 1);

# ─── 9. CONDITIONALS ─────────────────────────────────────────────────────────

my flag = 0;
if 1 { flag = 1; }
assert 1 == say flag;

ifnot 0 { flag = 2; }
assert 2 == say flag;

if 0    { flag = 99; }   # must not execute
ifnot 1 { flag = 99; }   # must not execute
assert 2 == say flag;

# ─── 10. WHILE AND UNTIL ─────────────────────────────────────────────────────

my cnt = 0;
while cnt < 5 { cnt = cnt + 1; }
assert 5 == say cnt;

cnt = 0;
until cnt >= 4 { cnt = cnt + 1; }
assert 4 == say cnt;

# ─── 11. LOOP WITH BREAK AND NEXT ────────────────────────────────────────────

my n = 0;
loop {
    n = n + 1;
    if n == 7 { break; }
}
assert 7 == say n;

# Sum 1..10 skipping multiples of 3: 1+2+4+5+7+8+10 = 37
my total = 0, step = 0;
loop {
    step = step + 1;
    if step > 10            { break; }
    if step / 3 * 3 == step { next;  }  # divisible by 3
    total = total + step;
}
assert 37 == say total;

# ─── 12. WHILE WITH BREAK AND NEXT ───────────────────────────────────────────

# Sum 1..10 skipping 5, stopping after 8: 1+2+3+4 + 6+7+8 = 31
my wsum = 0, wi = 0;
while wi < 10 {
    wi = wi + 1;
    if wi == 5 { next; }
    if wi > 8  { break; }
    wsum = wsum + wi;
}
assert 31 == say wsum;

# ─── 13. DO-WHILE / DO-UNTIL ─────────────────────────────────────────────────

# Body runs once even though the condition is already false
my dw = 10;
do { dw = dw + 1; } while dw < 10;
assert 11 == say dw;

my du = 0;
do { du = du + 1; } until du == 5;
assert 5 == say du;

# ─── 14. PROCEDURES ──────────────────────────────────────────────────────────

# Procedures share the caller's scope; mutations are visible to the caller
my acc = 0;
proc bump { acc = acc + 10; }
bump;
bump;
assert 20 == say acc;

# Variables declared inside a procedure leak into the caller's scope
proc initcoords { my cx = 3; my cy = 7; }
initcoords;
assert 3 == say cx;
assert 7 == say cy;

# ─── 15. FUNCTIONS ───────────────────────────────────────────────────────────

# Zero-arg function with explicit return
fun answer() { ret 42; }
assert 42 == say answer();

# Single-arg
fun square(m) { ret m * m; }
assert 25 == say square(5);
assert 0  == say square(0);

# Two-arg
fun add(a, b) { ret a + b; }
assert 9 == say add(4, 5);

# Conditional return
fun absval(v) {
    if v < 0 { ret neg v; }
    ret v;
}
assert 7 == say absval(7);
assert 7 == say absval(neg 7);

# Iterative function with local variables and decr
fun factorial(num) {
    my result = 1;
    while num > 1 {
        result = result * num;
        decr num;
    }
    ret result;
}
assert 1   == say factorial(0);
assert 1   == say factorial(1);
assert 120 == say factorial(5);
assert 720 == say factorial(6);

# Iterative fibonacci using local variables
fun fib(num) {
    if num <= 1 { ret num; }
    my fa = 0, fb = 1, ftmp = 0, fi = 2;
    while fi <= num {
        ftmp = fa + fb;
        fa = fb;
        fb = ftmp;
        fi = fi + 1;
    }
    ret fb;
}
assert 0  == say fib(0);
assert 1  == say fib(1);
assert 1  == say fib(2);
assert 8  == say fib(6);
assert 55 == say fib(10);

# Old-style zero-arg function (no parentheses)
fun greet { say "hello from greet"; }
greet;

# Multiple return values both land on the caller's stack (printed here)
fun minmax(a, b) {
    if a < b { ret a, b; }
    ret b, a;
}
say minmax(3, 7);   # prints 3 then 7

# ─── 16. SCOPING ─────────────────────────────────────────────────────────────

my outer = 100;
{
    my inner = 200;
    outer = outer + inner;
    assert 1 == defined inner;
}
assert 300 == say outer;
assert 0   == defined inner;

# Variables defined in nested blocks vanish when the block closes
my depth = 0;
{
    depth = depth + 1;
    {
        depth = depth + 1;
        { depth = depth + 1; }
        assert 3 == say depth;
    }
}
assert 3 == say depth;

# ─── 17. SYNONYMS / ALIASES ──────────────────────────────────────────────────

my orig = 42;
my alias = \orig;
assert 42 == say alias;    # alias starts with orig's value

orig = 99;
assert 99 == say alias;    # alias reflects the change

assert 2 == syms orig;     # two symbols point to the same value
undef orig;
assert 1 == syms alias;
assert 0 == defined orig;
assert 1 == defined alias;
undef alias;

# Procedure synonym
proc grp { say "grp called"; }
my grp2 = \grp;
assert 2 == syms grp;
grp2;                      # still callable through the alias
undef grp;
grp2;                      # alias keeps it alive
assert 0 == defined grp;
undef grp2;

# ─── 18. DEFINED AND UNDEF ───────────────────────────────────────────────────

my tmpvar = 5;
assert 1 == defined tmpvar;
assert 0 == defined nosuchvar;
undef tmpvar;
assert 0 == defined tmpvar;

# ─── 19. ARRAYS — LITERALS, INDEXING, ASSIGNMENT ────────────────────────────

my nums = [10, 20, 30, 40, 50];
assert 5  == say len nums;
assert 10 == say nums[0];
assert 30 == say nums[2];
assert 50 == say nums[4];

# Expression-based index
my idx = 1;
assert 20 == say nums[idx];
assert 30 == say nums[idx + 1];

# Element assignment
nums[2] = 99;
assert 99 == say nums[2];

# ─── 20. ARRAY SLICES ────────────────────────────────────────────────────────

# nums is now [10, 20, 99, 40, 50]
my sl = nums[1:4];    # half-open: indices 1, 2, 3
assert 3  == say len sl;
assert 20 == say sl[0];
assert 99 == say sl[1];
assert 40 == say sl[2];

my head = nums[:2];   # first two elements
assert 2  == say len head;
assert 10 == say head[0];
assert 20 == say head[1];

my tail = nums[3:];   # from index 3 to end
assert 2  == say len tail;
assert 40 == say tail[0];
assert 50 == say tail[1];

my cpy = nums[:];     # full shallow copy
assert 5  == say len cpy;
assert 10 == say cpy[0];
assert 50 == say cpy[4];

say "All assertions passed.";

#*
 * Examples of how to define variables
 *#

# Defines the variables 
my foo = 1 + 1;
my bar = 4 - 1, baz = 100 + 1, bay;

# bay has been initialized with the default value of 0
say bay;

# Prints out "5\n"
assert 5 == (say foo + bar);

# Pritns out "51101\n"
assert 51 == (put baz - 50);
assert 101 == (say baz);

# Change the value of the variable to 99 and print it out
assert 99 == (baz = 99);
say baz;