// Single declaration
def name(parameters) -> void;

// Multi-declaration
def name(int) -> bool,
    name(float) -> void,
    name(char*) -> int;   // Can prototype multiple functions at once, comma separated signatures.

def name (parameters) -> return_type
{
    return return_value;
};

def myAdd(int x, int y) -> int
{
    return x + y;
};

def myAdd(float x, float y) -> float
{
    return x + y;
};

#import <standard.fx>;

using standard::io::console;

def variadic(...) -> void
{
    print(...[0]); print();
    print(...[1]); print();
    print(...[2]); print();
    print(...[3]); print();
};



def main() -> int
{
    variadic(1,2,3,4);

    return 0;
};

1
2
3
4

def foo(int x) -> int
{
    return x / 2;
};

def bar () -> int
{
    return 0xFF;
};

int z = foo() <- bar(); // == // int z = foo(bar());

extern def foo() -> void;
extern def !!foo() -> void;  // !! tells the compiler do not mangle this function name

extern
{
    def foo() -> void;
    def bar() -> void;
    def !!zed() -> void;
};

extern
{
    // Memory allocation
    def !!
        malloc(size_t) -> void*,
        memcpy(void*, void*, size_t) -> void*,
        free(void*) -> void,
        calloc(size_t, size_t) -> void*,
        realloc(void*, size_t) -> void*,
        memcpy(void*, void*, size_t) -> void*,
        memmove(void*, void*, size_t) -> void*,
        memset(void*, int, size_t) -> void*,
        memcmp(void*, void*, size_t) -> int,
        abort() -> void,
        exit(int) -> void,
        atexit(void*) -> int;
};

def "??foo@"()->void;

#import "types.fx";

export
{
    def !!stub() -> void {};
};

#import <standard.fx>;  // <> means stdlib, "" means local to source file
#import "mylib.fx", "foobar.fx";  // Multi-line imports are processed from left to right in the order they appear.

int myVar = 10;

#import "somefile.fx";  // int myVar = 10;

def main() -> int
{
    if (myVar < 20)
    {
        // Do something ...
    };
    return 0;
};

#import <standard.fx">

#package super-types, flux-boost;  // these don't exist, yet..

#import <standard.fx>;

#ifdef __WINDOWS__
#def DEFAULT_CONFIG_FLAG 0x4000;
#else
#ifdef __LINUX__
#def DEFAULT_CONFIG_FLAG 0x8000;
#endif;
#endif;

#warn "This will show a warning message.";

#stop "This will hard-stop compilation.";

#dir "C:\\path\\to\\some\\lib";
// Adds a path to the preprocessor's search list

namespace myNamespace
{
    def myFoo() -> void; // Legal
};

namespace myNamespace
{
    def myBar() -> void;        // namespace myNamespace now has myFoo() and myBar()
};

namespace myNamespace
{
    namespace myNestedNamespace
    {
        def myFooBar() -> void;
    };
};

struct xyzStruct
{
    int x,y,z;
};

struct newStruct
{
    xyzStruct myStruct {x = 1, y = 1, z = 1};              // structs can contain structs
};

struct Header
{
    data{16} sig;
    data{32} filesize, reserved, dataoffset;
};

struct InfoHeader
{
    data{32} size, width, height;
    data{16} planes, bitsperpixel;
    data{32} compression, imagesize, xpixelsperm, ypixelsperm, colorsused, importantcolors;
};

struct ExtraData
{
    byte[64] author;
};

struct BMP : Header, InfoHeader
{
    // More bitmap fields
} : ExtraData;

struct Header
{
    data{16} sig;
    data{32} filesize;
};

byte[6] buf = [0x42, 0x4D, 0x00, 0x01, 0x02, 0x03];

Header h from buf;
// h.sig == 0x424D, h.filesize == 0x00010203
// `buf` is no longer usable after this point.

Header h from buf!;   // buf is still valid and usable after this line

// Recasting directly from a slice - no copy, h aliases buf[2:6]
Header h from buf[2:6];

__init()       -> this               Example: thisObj newObj();            // Constructor
__exit()       -> void               Example: newObj.__exit();             // Destructor
__expr()       -> any

#import <standard.fx>;

using standard::io::console;

object SomeOBJ
{
    int val;

    def __init(int x) -> this { return this; };

    def __exit() -> void {};

    def __expr() -> int { return this.val; };
};

def main() -> int
{
    SomeOBJ sobj = 5;

    println(sobj.val);   // Direct access

    println(sobj);  // Compiler detects object instance, emits print(sobj.__expr());

    println(sobj + sobj); // 10

    return 0;
};

#import <standard.fx>;

using standard::io::console;

object SomeOBJ
{
    int val;
    def __init(int x) -> this
    {
        this.val = x;
        return this;
    };

    def __exit() -> void { print("Cleaning up!"); };

    def __expr() -> int { return this.val; };
};

def main() -> int
{
    SomeOBJ sobj = 5;
    defer sobj.__exit();

    print(sobj);
    // deferred statements injected here
    return 0;
};

#import <standard.fx>;

using standard::io::console;

def main() -> int
{
    println("Hello!");
    defer
    {
        println("Test1!");
        println("Test2!");
    };
    return 0;
};

Hello!
Test2!
Test1!

#import <standard.fx>;

using standard::io::console;

object A
{
    int a1, a2, a3;
    def __init() -> this { return this; };
    def __expr() -> A*   { return this; };
    def __exit() -> void { (void)this;  };
};

object B
{
    int b1, b2, b3;
    def __init() -> this { return this; };
    def __expr() -> A*   { return this; };
    def __exit() -> void { (void)this;  };
};

object C : A, B
{
    int c1, c2, c3;
    def __init() -> this { return this; };
    def __expr() -> A*   { return this; };
    def __exit() -> void { (void)this;  };
};

object B
{
    int b1, b2, b3;
    def __init() -> this { return this; };
    def __expr() -> A*   { return this; };
    def __exit() -> void { (void)this;  };

    !+ def foo() -> void {};
};

object C : B
{
    +  def foo() -> void {}; // compiler will error, child must inherit foo from parent
}

trait Drawable
{
    def draw() -> void;
};


// Implementation
Drawable object myObj
{
    // ... required methods ...

    def draw() -> void
    {
        // Implementation code, if the block is empty the compiler throws an error.
        return void;
    };

    // ... other methods ...
};

// OK -- query is listed in the B(A) block
b.some_func(a.query());

// Error -- secret is not listed
b.some_func(a.secret());

// Inside a B method body:
int val = a.result();   // OK -- result is listed in A -> B
int val = a.secret();   // Error -- secret is not listed

trait Queryable  { def query(byte* sql) -> byte*; };
trait Connectable { def connect() -> bool, disconnect() -> bool; };

interface Database(A: Connectable, B: Queryable)
{
    A : B
    {
        connect()    -> bool,
        disconnect() -> void
    };

    B(A)
    {
        query(byte* sql) -> byte*
    };

    A -> B
    {
        result() -> byte*
    };
};

object Client, Store;

object Store
{
    def __init() -> this { return this; };
    def __exit() -> void {};
    def __expr() -> int { return 0; };
    def query(byte* sql) -> byte* { return sql; };
    def disconnect() -> void {};

    def fetch(Client* c) -> byte*
    {
        // Allowed: result() is listed in A -> B
        byte* r = c.result();
        return r;
    };
} : Database(Client, this);

object Client
{
    def __init() -> this { return this; };
    def __exit() -> void {};
    def __expr() -> int { return 0; };
    def connect() -> bool { return true; };
    def disconnect() -> bool { return true; };
    def result() -> byte* { return "data\0"; };
} : Database(this, Store);

def main() -> int
{
    Client c();
    Store  s();

    // Allowed: query() is listed in B(A), result() is the A method being passed
    byte* out = s.query(c.result());

    // Allowed: connect() is listed in A : B
    c.connect();

    return 0;
};

struct myStruct
{
    int x, y;
};

object Obj2;

object Obj1
{

    Obj2 myObject();

    // ... required methods ...

    private : Obj2    // Obj2 is a friend class and can inherit Obj1's private members
    {
        // code
    };

    def foo() -> int
    {
        return this.myObject.myStruct.y;    // ERROR - Need to use a getter of Obj2
    };
};

object Obj2
{
    private
    {
        myStruct objStru;
    };

    // ... required methods ...

    def get_y() -> int
    {
        return this.myStruct.y;
    };
};

#import <standard.fx>;

using standard::io::console,
      standard::strings;

def main() -> int
{
    string h = "Hello";
    string w = "World!";
    print(f"{h} {w}");
    return 0;
};

#import <standard.fx>; // imports types.fx

using standard::io::console;

def bar() -> noopstr { return "World"; };    // We get the non-OOP string type from the types library

def main() -> int
{
    println(i"Hello {} {}" : {bar() + "!"; "test";});

    x = i"Bar {}":{bar()};     // "Bar World!"

    noopstr a = "Hello", b = "World!",
            c = f"{a} {b}";    // "Hello World!"

    println(c);

    return 0;
};

string a = "Test\0";
string* pa = @a;
*pa += "ing!\0";
print(a);
// Result: "Testing!"


// Pointers to variables:
int idata = 0;
int* p_idata = @idata;

*p_idata += 3;
print(idata);  // 3

// Function pointer declarations
def{}* p_add(int,int)->int = @add;
def{}* p_sub(int,int)->int = @sub;

// Must dereference to call
print(p_add(0,3)); // 3
print(p_sub(5,2)); // 3

// Pointers to objects, structs, arrays:
object    myObj {};                 // Definition
object* p_myObj = @myObj;           // Pointer

struct    myStruct {};              // Definition
struct* p_myStruct = @myStruct;     // Pointer

int*[] pi_array = @i_array;         // Array of pointer

const int*  px; // Pointer to const value

const* int* px; // Constant pointer to int pointer

def _exchange64(i64* ptr, i64 value, i64* out) -> void
{
    #ifdef __ARCH_X86_64__
    volatile asm
    {
        movq $0, %rsi
        movq $2, %rdi
        movq $1, %rax
        xchgq %rax, (%rsi)
        movq %rax, (%rdi)
    } : : "r"(ptr), "r"(value), "r"(out) : "rax", "rsi", "rdi", "memory";
    #endif;
    #ifdef __ARCH_ARM64__
    volatile asm
    {
    .retry_xchg64:
        ldaxr x0, [$0]
        stlxr w3, x1, [$0]
        cbnz  w3, .retry_xchg64
        str   x0, [$2]
    } : : "r"(ptr), "r"(value), "r"(out) : "x0", "w3", "memory";
    #endif;
};

if (condition1)
{
    doThis();
}
elif (condition2)      // You can also use `else if`
{
    doThat();
}
else if (condition 3)  // Equivalent to `elif`
{
    doAnythingElse();
}
else
{
    doThings();
};

int x = 0;
int y = x if (x > 5) else noinit;

#import <standard.fx>;

using standard::io::console;

def foo() -> int
{
    return 10;
};

def main() -> int
{
    int* px @= 5;

    print(foo()) if (px);

    return 0;
};

#import <standard.fx>;

using standard::io::console;

def foo() -> int
{
    print("Hello");
};
def bar() -> void
{
    print(" World!");
};

def main() -> int
{
    {
        foo(); bar();
    } if (true);

    return 0;
};

#import <standard.fx>;

using standard::io::console;

def main() -> int
{
    int x = 0;
    int y = 5;

    int z = x < y ? y : 0;

    if (z is 5)
    {
        print("Success!\0");
    };
    return 0;
};

#import <standard.fx>;

using standard::io::console;

def main() -> int
{
    int x = 10,
        y;

    x ?= 50;
    y ?= x;

    if (x == y) { print("Success!\n\0"); };

    return 0;
};

#import <standard.fx>;

def main() -> int
{
    int x = 0;
    int y = 5;

    int z = y ?? 0;

    if (z is 5)
    {
        print("Success!\0");
    };
    return 0;
};

(const) (signed | unsigned) data {bit-width:alignment} (as) your_new_type

//    Example of a non-OOP string:

      unsigned data {8}[] as noopstr;    // Unsigned byte array, default alignment

signed data{32} as i32;
unsigned data{32} as u32;

i32 a = -10;
u32 b = 20;

// Mixed arithmetic (result type determined by widest type)
i32 result1 = a + (i32)b;    // -10 + 20 = 10 (signed)
u32 result2 = (u32)a + b;    // 4294967286 + 20 (unsigned, wraps)

// Comparison with mixed signs
if (a < (i32)b)  // true: -10 < 20
{
    print("Signed comparison\0");
};

if ((u32)a < b)  // false: 4294967286 > 20
{
    print("Unsigned comparison\0");
};

data{16::0} as le16;  // Little-endian 16-bit
data{16}    as be16;  // Big-endian default 16-bit

def swap_endian_16(be value) -> data{16}
{
    data{16::0} v2 = value; // Explicit byte swap on assignment
    return v2;
};

// Network byte order (big-endian) to host (little-endian)
def network_to_host(be16 net_value) -> le16
{
    le16 x = net_value;     // Explicit byte swap on assignment
    return x;
};

// Reading from network buffer
data{8::0}[4] buf = [0x12, 0x34, 0x56, 0x78];
be16[2] net = buf; // autopack and convert endianness

float x = 3.14;                  // 01000000010010001111010111000010b   binary representation of 3.14
i32 y = (i32)x;                  // 01000000010010001111010111000010b   but now treated as an integer  1078523330 == 0x4048F5C2

def example() -> void {
    int stackVar = 42; // Stack allocated

    (void)stackVar;    // What happens here?
}

  le32 netValue = ...;
  uint plain = uint(netValue);   // same bits, but now untagged as native/no endianness

#import <standard.fx>;

using standard::io::console;

def main() -> int
{
    double d = 3.1415925658;

    int i = int(d);

    print(i);

    return 0;
};

data{8:8:0}* as lestr;
signed data{13:16} as strange;

sizeof(lestr);    // 8
alignof(lestr);   // 8
typeof(lestr);    // unsigned data{8:8}*
endianof(lestr);  // 1

sizeof(strange);   // 13
alignof(strange);  // 16
typeof(strange);   // signed data{13:16}
endianof(strange); // 1

if (x == void) {...code...};    // If it's nothing, do something
void x;
if (x == !void) {...code...};   // If it's not nothing, do something

int[][][] z = [
                [
                  [ 1,  2,  3], [ 4,  5,  6], [ 7,  8,  9]
                ],
                [
                  [10, 11, 12], [13, 14, 15], [16, 17, 18]
                ],
                [
                  [19, 20, 21], [22, 23, 24], [25, 26, 27]
                ]
              ];

// Python-style comprehension
int[10] squares = [x ^ 2 for (int x in 1..10)];

// With condition
int[20] evens = [x for (int x in 1..20) if (x % 2 == 0)];

// With type conversion
float[sizeof(int_array)] floats = [(float)x for (int x in int_array)];

// C++-style comprehension
int[10] squares = [x ^ 2 for (int x = 1; x <= 10; x++)];

// With condition
int[20] events = [x for (int x= 1; x <= 20; x++) if (x % 2 == 0)];

#import <standard.fx>;

using standard::collections; // For the dynamic array 'Array'

Array[] myArr = [x.name for (Array x in oldArr) if (x.name.len() > 5)];

u64 packed = (u64)[0x12u, 0x34u, 0x56u, 0x78u, 0x9Au, 0xBCu, 0xDEu, 0xF0u];
// packed == 0x123456789ABCDEF0 - element 0 is the highest byte.

byte[8] bytes = (byte[8])packed;
// bytes == [0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0]

for (x in y)                     // Array iteration
{
    // ... code ...
};

for (int c = 0; c < 10; c++)     // init ; cond ; expr
{
    // ... code ...
};

do
{
    // some code;
};

do
{
    y[i--] = void;     // Nulled out of array
}
while (x in y & i > 0);

while (condition)
{
    // ... code ...
};

while (true)
{
    // ...
};
// or
while (1)
{
    // ...
};

int x = 5;
int[5] arr = [1, 2, 3, 4, 5];

if (x in arr) { ... };          // true: 5 is an element of arr
bool found = 3 in arr;

byte* greeting = "Hello, World!";
if ('W' in greeting) { ... };          // true
if ("World" in greeting) { ... };      // true - substring search

int[6] nums = [1, 2, 3, 4, 5, 6];
int[2] pair = [3, 4];
if (pair in nums) { ... };             // true - contiguous sub-sequence

#import <standard.fx>;

using standard::io::console;

def foo() -> void
{
    singinit int x;
    x += 1;
    print(x); print();
};

def call(int y) -> void
{
    if (y == 0) { return; };
    foo();
    call(--y);
};

def main() -> int
{
    call(10);
    return 0;
};

def rsub(int x, int y) -> int
{
    switch (x == 0 | y == 0)
    {
    };

    rsub(--x,--y);
};

#import <standard.fx>;

using standard::io::console;

noopstr m1 = "[recurse \0",
        m2 = "]\0";

def recurse1(int x) <~ int
{
    singinit int y;
    print(m1); print(y); println(m2);
    return ++y;
};


def recurse2() <~ void
{
    singinit int z;
    print(m1); print(++z); println(m2);
};


def main() -> int
{
    recurse2(); // Step into tail function
    return 0;
};

def recurse2() <~ void
{
    if (!entered_flag) {entered_flag = true;};
    singinit int z;
    print(m1); print(++z); println(m2);
    if (z >= 10) { escape main(); }; // or any other function
};

unsigned data{8}[] as string;  // Basic string implementation with no functionality (non-OOP string)

object ERR
{
    string e;

    def __init(string e) -> this
    {
        this.e = e;
        return this;
    };

    def __expr() -> string
    {
        return this.e;
    };
};

def myErr(int e) -> void
{
    switch (e)
    {
        case (0)
        {
            ERR myErrObj("Custom error from object myE\0");
            throw(myErrObj);
        }
        default
        {
            throw("Default error from function myErr()\0");
        };                                                  // Semicolons only follow the default case.
    };
};

def thisFails() -> bool
{
    return true;
};

def main() -> int
{
    string error = "\0";
    try
    {
        try
        {
            if(thisFails())
            {
                myErr(0);
            };
        }
        catch (ERR e)                                     // Specifically catch our ERR object
        {
            string err = e.e;
        }                                                 // No semicolon here because this is not the last catch in the try statement
        catch (string x)                                  // Only catch a primitive string (unsigned data{8}[]) thrown
        {
        }                                                 // No semicolon here because this is not the last catch in the try statement
        catch (auto x)
        {
        };                                                // Semicolon follows because it's the last catch in the try/catch sequence.
    }
    catch (string x)
    {
        error = x;  // "Thrown from nested try-catch block."
    };

    return 0;
};

union myUnion
{
    int iVal;
    float fVal;
};

myUnion u {iVal = 10};

def main() -> int
{
    u.iVal = 10;   // iVal is the active member
    u.fVal = 3.14; // iVal overwritten by fVal in memory
};

#import <standard.fx>;

using standard::io::console;

enum ErrorUnionEnum
{
    INACTIVE,
    INT_ACTIVE,
    LONG_ACTIVE,
    BOOL_ACTIVE,
    CHAR_ACTIVE,
    FLOAT_ACTIVE,
    DOUBLE_ACTIVE   
};

union ErrorUnion
{
    int  iRval;
    long lRval;
    bool bRval;
    char cRval;
    float fRval;
    double dRval;
} ErrorUnionEnum;


def foo() -> ErrorUnion
{
    ErrorUnion err;

    err.bRval = false; // Set bool to active element
    err._ = ErrorUnionEnum.BOOL_ACTIVE;

    return err;
};


def main() -> int
{
    ErrorUnion e = foo();

    switch (e._)
    {
        case (ErrorUnionEnum.INT_ACTIVE)
        {
            print("Integer active in error union!\n\0");
        }
        case (ErrorUnionEnum.LONG_ACTIVE)
        {
            print("Long active in error union!\n\0");
        }
        case (ErrorUnionEnum.BOOL_ACTIVE)
        {
            print("Bool active in error union!\n\0");
        }
        case (ErrorUnionEnum.CHAR_ACTIVE)
        {
            print("Char active in error union!\n\0");
        }
        case (ErrorUnionEnum.FLOAT_ACTIVE)
        {
            print("Float active in error union!\n\0");
        }
        case (ErrorUnionEnum.DOUBLE_ACTIVE)
        {
            print("Double active in error union!\n\0");
        }

        default { print("No active tag set!\n\0"); };
    };

    return 0;
};

switch (e)
{
    case (0)
    {
        // Do something
    }
    case (1)
    {
        // Another thing
    }
    default
    {
        // Something else
    };
};

!using standard::io::file;
not using some::specific::namespace;

#import <standard.fx>;

namespace test1
{
    namespace test2
    {
        def foo() -> void {};
    };
};

deprecate test1::test2;

def main() -> int
{
    test1::test2::foo();

    return 0;
};

✗ Compilation failed: Deprecated namespace 'test1::test2' is still referenced:
Function call test1__test2__foo()

def main() -> int
{
    int x;
    try
    {
        assert(x == 0, "Something is fatally wrong with your computer.");
    }
    catch (string e)
    {
        print(e);
        return -1;
    };
    return x;
};

heap int x = 5;      // Allocate
(void)x;             // Deallocate

operator (int L, int R) [+++] -> int
{
    return ++L + ++R;
};

operator (int L, int R) [NOPOR] -> bool
{
    return !L | !R;
};

operator (int L, BigInt R) [+] -> bool
{
    // Implementation for adding an int and a BigInt
};

operator<T> (T L, T R) [+] -> T
{
    // ...
};

#import <standard.fx>;

using standard::io::console;

contract NonZero
{
    assert(x > 0, "x must be positive");
};

contract rValGT10
{
    assert(x > 10, "r must be greater than 10");
};

def foo(int x) -> int : NonZero
{
    x = x / 2;
    return x;
} : rValGT5;

def main() -> int
{
    int y = foo(18);

    return 0;
};

def foo(int x) -> int : NonZero
{
    assert(x > 0, "x must be positive");
    x = x / 2;
    assert(x > 10, "x must be greater than 10");
    return x;
};

#import <standard.fx>;

using standard::io::console;

contract NonZero(a,b)
{
    assert(a != 0, "a must be nonzero");
    assert(b != 0, "b must be nonzero");
};

operator(int x, i32 y)[+] -> int : NonZero(x,y)
{
    return x+y;
};


def main() -> int
{
    0 + 4;

    return 0;
};

#import <standard.fx>;

using standard::io::console;

macro xyz(a,b,c)
{
    (a + b) ^ c
};

def main() -> int
{
    int x, y, z = 1, 2, 3;

    println(f"xyz(abc) = {xyz(x,y,z)}");

    return 0;
};

println(f"xyz(abc) = {(1 + 2) ^ 3}");

// noopstr is alias for byte*
noopstr.add_world() -> noopstr
{
    return _ + ", World!";  //  "Hello".add_world() == return "Hello" + ", World!"
};

/// Alternatively, you may use "" - Note this is special for type functions ///
"".add_world() -> ""
{
    return _ + ", World!";
};

struct MyStru
{
    // .. members ..
};

MyStru.mystru_func1() -> MyStru
{
    // impl
};

~byte*.sub11() -> ~byte*
{
    return _[0] - 11; // set first char - 11, _ is tied type, no need for explicit move
};

0.my_int_func() -> int   // 55.my_int_func()
{
    return _;
};

0l.my_long_func() -> long
{
    return _;
};

0d.my_double_func() -> double
{
    return _;
};

struct.my_struct_func() -> struct
{
    // impl for your arbitrary struct func
};

#import <standard.fx>;

using standard::io::console;

data!{32} as u32i;

u32i.foo() -> u32i { return 0u; };

def main() -> int
{
    return 0;
};

#import <standard.fx>;


def foo<T>(T x) -> T
{
    return x;
};


def main() -> int
{
    float y = foo<float>(5.5f);
    int z = foo<int>(3);

    println(y);
    println(z);

    system("pause\0");
    return 0;
};

#import <standard.fx>;

using standard::io::console;

struct myStru<T>
{
    T a, b;
};

def foo<T, U>(T a, U b) -> U
{
    return a.a * b;
};

def bar(myStru<int> a, int b) -> int
{
    return foo(a, 3); // inferred from signature via 'a'
};

def main() -> int
{
    myStru<int> ms = {10,20};

    //int w = foo<myStru<int>, int>(ms, 3); // <brackets> at call site

    int x = foo(ms, 3); // inferred locally

    int y = bar(ms, 3);

    println(x == y);
    return 0;
};

<T: int | i32, U: long | i64>

#import <standard.fx>;
 
using standard::io::console;

"".fx<T: "", U: "">(T x, U y) -> ""
{
    return _ + f"{x} {y}";
};

def main() -> int
{
    byte* new = "Hello".fx(",", "World!");
    println(new);
    return 0;
};

<T: +float | int>

<!+T: float | int>

#import <standard.fx>;
 
using standard::io::console;

"".fx<T: "", U: "", :{T ~= U}>(T x, U y) -> ""
{
    return _ + f"{x} {y}";
};

def main() -> int
{
    byte* new = "Hello".fx(",", "World!");
    println(new);
    return 0;
};

#import <standard.fx>;
 
using standard::io::console;

"".fx<T: "", U: "", :{T ~= U, T !`< U}>(T x, U y) -> ""
{
    return _ + f"{x} {y}";
};

def main() -> int
{
    byte* new = "Hello".fx(",", "World!");
    println(new);
    return 0;
};

D !~= B & [A !@ A] !~= C !`< D !-= A

C !~= D !~= B & [A !@ A] !~= C !`< D !-= A

#import <standard.fx>;
 
using standard::io::console;

constraint MyCS(A)
{
    A !`< A    // This is a unary expression, read as the relation !`< "between A types"
};

def foo<T: int, :{MyCS}>(T x) -> byte
{
    return 5 + x; // lowering would occur here, violating MyCS
};

def main() -> int
{
    foo(10);
    return 0;
};

✗ Compilation failed: Type relation T !`< T violated: illegal truncation on int at 12:5
    return 5 + x;
----^ // 5 + x will lower to byte

constraint MyCS3 = MyCS1 + MyCS2;

constraint MyCS3(M, N) = MyCS1 + MyCS2;

struct myStru<A,B>
{
    A ax, ay, az;
    B bx, by, bz;
};

struct myStru1<A,B>
{
    A a1x, a1y;
    B b1x, b1y;
};

struct myStru2<A,B,C> : myStru1
{
    A a2x, a2y, a2z;
    B b2x, b2y, b2z;
};

// Becomes,

struct myStru2<A,B,C>
{
    A a1x, a1y;
    B b1x, b1y;
    A a2x, a2y, a2z;
    B b2x, b2y, b2z;
};

operator<T, K>(T t, K k)[+] -> int
{
    return t + k;
};

#import <standard.fx>;

using standard::io::console;

struct myStru<T>
{
    T a, b;
};

def foo<T, U>(T a, U b) -> U
{
    return a.a * b;
};

def bar(myStru<int> a, int b) -> int
{
    return foo(a, 3); // Template inferred from parameter
};

macro macNZ(x)
{
    x != 0
};

contract ctNonZero(a,b)
{
    assert(macNZ(a), "a must be nonzero");
    assert(macNZ(b), "b must be nonzero");
};

contract ctGreaterThanZero
{
    assert(x > 0, "a must be greater than zero");
    assert(y > 0, "b must be greater than zero");
};

operator<T, K>(T t, K k)[+] -> int : ctNonZero(a,b)
{
    return t + k;
} : ctGreaterThanZero;

def main() -> int
{
    myStru<int> ms = {10,20};

    int x = foo(ms, 3); // Template inferred from myStru<int> above

    i32 y = bar(ms, 3);

    println(x + y);

    return 0;
};

// You can take the address of a literal value
int* p = @42;
print(*p);  // 42

// The address can be manipulated as an integer
unsigned data{64}* as u64ptr;
u64ptr addr = (u64ptr)p;
addr += 8;  // Move 8 bytes forward in memory
int* p2 = (int*)addr;

// Pointer arithmetic on literal addresses
int* base = @100;
int* offset = base + 5;
*offset = 200;  // Writing to calculated memory location

#import <standard.fx>;

using standard::io::console;

def main() -> int
{
    uint x, y = 10, 0;

    uint* px, py = @x, @y;

    // A pointer is simply a variable and its value is an address
    // An address is a number.
    // Therefore, we can store that address
    //
    u64 kx = px;

    // (@) is address-cast. It reinterprets the number as an address
    // When we treat a number as an address, we call that a pointer.
    // Therefore, we can assign this to another pointer.
    //
    py = (@)kx;

    // py now points to x

    // Dereference py to get the value at the address
    // Cast to make sure it's the proper type to print

    if (x == 10 & y == 0 & *py == x & px == py & px == (@)kx)
    {
        print("Success, y unchanged, py points to x.\n\0");
        print((uint)*py);
        return 0;
    };

        return 0;
};

// 13-bit signed value, 16-bit aligned
signed data{13:16} as strange13;

strange13 value = 0x1FFF;  // Max positive value for 13 bits
print(value);              // 8191

value = 0x1000;            // Sign bit set (bit 12)
print(value);              // -4096 (two's complement)

// Extract specific bit ranges
u32 packed = 0x12345678;

def extract_bits(uint32 value, int start, int length) -> uint32
{
    uint32 mask = ((1 << length) - 1) << start;
    return (value & mask) >> start;
};

uint32 nibble0 = extract_bits(packed, 0, 4);   // 0x80
uint32 nibble3 = extract_bits(packed, 12, 4);  // 0x50
uint32 byte1 = extract_bits(packed, 8, 8);     // 0x56

len_block[0]  = (byte)((aad_bits    >> 56) & 0xFF);
len_block[1]  = (byte)((aad_bits    >> 48) & 0xFF);
len_block[2]  = (byte)((aad_bits    >> 40) & 0xFF);
len_block[3]  = (byte)((aad_bits    >> 32) & 0xFF);
len_block[4]  = (byte)((aad_bits    >> 24) & 0xFF);
len_block[5]  = (byte)((aad_bits    >> 16) & 0xFF);
len_block[6]  = (byte)((aad_bits    >>  8) & 0xFF);
len_block[7]  = (byte)( aad_bits           & 0xFF);
len_block[8]  = (byte)((cipher_bits >> 56) & 0xFF);
len_block[9]  = (byte)((cipher_bits >> 48) & 0xFF);
len_block[10] = (byte)((cipher_bits >> 40) & 0xFF);
len_block[11] = (byte)((cipher_bits >> 32) & 0xFF);
len_block[12] = (byte)((cipher_bits >> 24) & 0xFF);
len_block[13] = (byte)((cipher_bits >> 16) & 0xFF);
len_block[14] = (byte)((cipher_bits >>  8) & 0xFF);
len_block[15] = (byte)( cipher_bits        & 0xFF);

len_block[0..7]  = (byte[8])(u64)aad_bits;
len_block[8..15] = (byte[8])(u64)cipher_bits;

uint* pd = @p.digits[0];

// Proper Flux
pd = [0xFFFFFFEDu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu,
      0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFu];

/// C-like
pd[0] = 0xFFFFFFED;
pd[1] = 0xFFFFFFFF;
pd[2] = 0xFFFFFFFF;
pd[3] = 0xFFFFFFFF;
pd[4] = 0xFFFFFFFF;
pd[5] = 0xFFFFFFFF;
pd[6] = 0xFFFFFFFF;
pd[7] = 0x7FFFFFFF;
///

for (i = 0; i < 4; i++)
{
    hash[i] = (byte)((ctx.state[0] >> (24 - i * 8)) & 0xFF);
    hash[i + 4] = (byte)((ctx.state[1] >> (24 - i * 8)) & 0xFF);
    hash[i + 8] = (byte)((ctx.state[2] >> (24 - i * 8)) & 0xFF);
    hash[i + 12] = (byte)((ctx.state[3] >> (24 - i * 8)) & 0xFF);
    hash[i + 16] = (byte)((ctx.state[4] >> (24 - i * 8)) & 0xFF);
    hash[i + 20] = (byte)((ctx.state[5] >> (24 - i * 8)) & 0xFF);
    hash[i + 24] = (byte)((ctx.state[6] >> (24 - i * 8)) & 0xFF);
    hash[i + 28] = (byte)((ctx.state[7] >> (24 - i * 8)) & 0xFF);
};

hash[0..3]   = (byte[4])(be32)ctx.state[0];
hash[4..7]   = (byte[4])(be32)ctx.state[1];
hash[8..11]  = (byte[4])(be32)ctx.state[2];
hash[12..15] = (byte[4])(be32)ctx.state[3];
hash[16..19] = (byte[4])(be32)ctx.state[4];
hash[20..23] = (byte[4])(be32)ctx.state[5];
hash[24..27] = (byte[4])(be32)ctx.state[6];
hash[28..31] = (byte[4])(be32)ctx.state[7];

#import <standard.fx>;

using standard::io::console;

def main() -> int
{
    byte x = 55;

    x[0``7] = x[7``0]; // Reverse the bits

    println(int(x)); // 236

    return 0;
};

#import <standard.fx>;

using standard::io::console;

struct xx { int a, b; };

def main() -> int
{
    data{4} as u4;
    xx yy = {5,10};
    u4 a = yy[60``63]; // 10 because 0b1010

    print((int)a);

    return 0;
};

#import <standard.fx>;

using standard::io::console;

struct xx { int a, b; };

def main() -> int
{
    data{4} as u4;
    data{2} as u2;
    xx yy = {5,10};
    u4 a = yy[60``63]; // 10 because 0b1010
    u2 b = a[0``1];

    print(int(b)); // 2, because 0b10

    return 0;
};

u32 packed = 0x12345678;
packed[24``31] = 0xFF;   // replace just the lowest byte
// packed == 0x123456FF

// 3-bit unsigned value (0-7)
unsigned data{3} as tiny = 5;

// 17-bit signed value
signed data{17} as weird17 = -1000;

// 7-bit with 8-bit alignment (1 bit padding)
unsigned data{7:8} as aligned7 = 127;

// Array of 5-bit values
unsigned data{5}[10] as 5b_array arr;
arr[0] = 0x1F;  // Max value for 5 bits

// Casting between weird widths
unsigned data{13} as u13 a = 8191;
unsigned data{17} as u17 b = (u17)a;  // Zero-extend
signed data{13} as s13 c = (s13)a;    // Truncate LTR, losing most significant bits

#import <standard.fx>;

using standard::io::console;

def foo(int x) -> int
{
    print("Inside foo!\n\0");
    return 0;   
};


def main() -> int
{
    def{}* pfoo(int)->int = @foo;
    print("Function pointer created.\n\0");
    print();

    pfoo(0); // Compiler auto dereferences

    return 0;
};

#import <standard.fx>;

using standard::io::console;

def foo() -> void
{
    println("In foo()!");
};

def callback(long x) -> int
{
    def{}* cb()->void = x;
    cb();
    return 0;
};

def main() -> int
{
    callback(long(@foo));
    return 0;
};

#import <standard.fx>;

using standard::io::console;

def main() -> int
{
    byte[] some_bytecode = [0x48, 0x31, 0xC0, 0xC3];  // xor rax,rax ; ret
    def{}* fp()->void = @some_bytecode;
    fp();
    
    return 0;
};

#import <standard.fx>;

def foo(~int z) -> void  // accepts a tied parameter
{
    return;
};

def main() -> int
{
    ~int x;
    int  y;  // Non-tied var

    foo(~x); // Untie from main, tie to foo()

    foo(~x); // Compile error, use after untie

    foo(y);  // Compile error, foo expects tied param

    return 0;
};

def classify_value(int x, int y) -> void
{
    switch (x)
    {
        case (0)
        {
            switch (y)
            {
                case (0)
                {
                    print("Both zero\0");
                }
                case (1)
                {
                    print("X zero, Y one\0");
                }
                default
                {
                    print("X zero, Y other\0");
                };
            };
        }
        case (1)
        {
            print("X is one\0");
        }
        default
        {
            print("X is other\0");
        };
    };
};

object ErrorA
{
    int code;
    def __init(int c) -> this { this.code = c; return this; };
    def __exit() -> void {return;};
};

object ErrorB
{
    string message;
    def __init(string m) -> this { this.message = m; return this; };
    def __exit() -> void {return;};
};

def risky_operation(int mode) -> void
{
    if (mode == 1)
    {
        throw(ErrorA(100));
    }
    elif (mode == 2)
    {
        throw(ErrorB("Something failed\0"));
    }
    else
    {
        throw("Generic error\0");
    };
};

def main() -> int
{
    try
    {
        risky_operation(1);
    }
    catch (ErrorA e)
    {
        print(f"ErrorA caught: code {e.code}\0");
    }
    catch (ErrorB e)
    {
        print(f"ErrorB caught: {e.message}\0");
    }
    catch (string s)
    {
        print(f"String error: {s}\0");
    }
    catch (auto x)
    {
        print("Unknown error type\0");
    };
    
    return 0;
};

def find_in_matrix(int[][] matrix, int target) -> bool
{
    for (int i = 0; i < 10; i++)
    {
        for (int j = 0; j < 10; j++)
        {
            if (matrix[i][j] == target)
            {
                print(f"Found at [{i}][{j}]\0");
                return true;  // Break out of both loops
            };
            
            if (matrix[i][j] < 0)
            {
                continue;  // Skip negative values
            };
        };
    };
    
    return false;
};

// Do-while with complex condition
def wait_for_ready(int* status_reg) -> void
{
    int timeout = 1000;
    do
    {
        if (*status_reg & 0x01)  // Ready bit
        {
            break;
        };
        timeout--;
    }
    while (timeout > 0 & !(*status_reg & 0x80));  // Not error bit
};

struct IPHeader
{
    nybble version, ihl;
    byte tos;
    be16 total_length, identification, flags_offset;
    byte ttl, protocol;
    be16 checksum;
    be32 src_addr, dst_addr;
};

def parse_ip_header(bytes* packet) -> IPHeader
{
    IPHeader* header = (IPHeader*)packet;
    return *header;
};

def format_ip(be32 addr) -> string
{
    bytes* bp = (bytes*)@addr;
    return f"{bp[0]}.{bp[1]}.{bp[2]}.{bp[3]}\0";
};

// Usage
bytes packet_data = [
    0x45, 0x00, 0x00, 0x3c,  // Version=4, IHL=5, ToS=0, Length=60
    0x1c, 0x46, 0x40, 0x00,  // ID, Flags
    0x40, 0x06, 0xb1, 0xe6,  // TTL=64, Protocol=TCP, Checksum
    0xc0, 0xa8, 0x01, 0x01,  // Source: 192.168.1.1
    0xc0, 0xa8, 0x01, 0x02   // Dest: 192.168.1.2
];

IPHeader hdr = parse_ip_header(@packet_data[0]);
print(f"Source: {format_ip(hdr.src_addr)}\0");
print(f"Dest: {format_ip(hdr.dst_addr)}\0");

// 16.16 fixed-point format
signed data{32} as fixed16_16;

def to_fixed(float value) -> fixed16_16
{
    return (fixed16_16)(value * 65536.0);
};

def from_fixed(fixed16_16 value) -> float
{
    return (float)value / 65536.0;
};

def fixed_mul(fixed16_16 a, fixed16_16 b) -> fixed16_16
{
    i64 temp = ((i64)a * (i64)b) >> 16;
    return (fixed16_16)temp;
};

def fixed_div(fixed16_16 a, fixed16_16 b) -> fixed16_16
{
    i64 temp = ((i64)a << 16) / (i64)b;
    return (fixed16_16)temp;
};

// Usage
fixed16_16 a = to_fixed(3.14159),
           b = to_fixed(2.0);
fixed16_16 result = fixed_mul(a, b);
print(from_fixed(result));  // approx 6.28318

// Void as a value
void x = void;      // Cannot have void type, only void pointer
void* px = @0;      // Null void pointer. Allocates a 0 and takes its address
                    // Based on default pointer width (64)

if (px is void)
{
    print("px is null\0");
};

// Conditional void assignment
void y = condition ? void : some_value;

// Void in arrays (creates holes)
int[] sparse = [1, 2, void, 4, void, 6];
if (sparse[2] == void)
{
    sparse[2] = 3;  // Fill the hole
};

// Function returning void pointer
def get_nullable() -> int*
{
    if (error_condition)
    {
        return (int*)void;  // Return null
    };
    return @some_value;
};

stdcall foobar() -> void;

vectorcall{}* someSIMDfunc() -> u64*;

#import <standard.fx>;

using standard::io::console;

def main() -> int
{
    int Hello = 5;

    println($Hello);
    return 0;
};

#import <standard.fx>;

using standard::io::console;

def main() -> int
{
    byte* test = "int x = 5;";

    ~$test;

    println(x);
    
    return 0;
};

#import <standard.fx>;

comptime
{
    def foo() -> void
    {
        compiler.io.console.print("Hello from compile time!\n");
    };
};

def main() -> int
{
    return 0;
};

#import <standard.fx>;

comptime
{
    def foo() -> void
    {
        compiler.io.console.print("Hello from compile time!\n");
    };

    foo();
};

def main() -> int
{
    return 0;
};

[INFO] [lexer] ► Lexical analysis
[INFO] [parser] ► Parsing
[INFO] [parser] ► AST generated.
[INFO] [codegen] ► LLVM IR code generation
[AST] Begining codegen for Flux program ...
[AST] Total statements in AST: 45
[AST] Namespace definitions: 10
[AST] Pass 1: Processing using statements...
[AST] Pass 2: Processing not using statements...
[AST] Pre-pass: Registering all object types and extern blocks...
[AST] Pass 3: Processing all other statements...
Hello from compile time!
[AST] Pass 4: Re-emitting pending bodies...
[INFO] [compiler] ► Compiling to object file (Windows)
[INFO] [llc] opt IR optimization pass complete
[INFO] [linker] ► Linking executable: ./test.exe
✓ Compilation completed: ./test.exe

#import <standard.fx>;
 
using standard::io::console;

comptime
{
    def foo() -> void
    {
        compiler.io.console.print("comptime foo!!!\n");
    };
};

comptime
{
    foo();

    int x;
    int* px = @x;

    compiler.io.console.print(f"Hello from comptime! {ulong(px)}\n");
};

def main() -> int
{
    return 0;
};

[INFO] [lexer] ► Lexical analysis
[INFO] [parser] ► Parsing
[INFO] [parser] ► AST generated.
[INFO] [codegen] ► LLVM IR code generation
[AST] Begining codegen for Flux program ...
[AST] Total statements in AST: 47
[AST] Namespace definitions: 10
[AST] Pass 1: Processing using statements...
[AST] Pass 2: Processing not using statements...
[AST] Pre-pass: Registering all object types and extern blocks...
[AST] Pass 3: Processing all other statements...
comptime foo!!!
Hello from comptime! 17
[AST] Pass 4: Re-emitting pending bodies...

comptime
{
    int x = 42;

    emitflux
    {
        def get_x() -> int { return ~$f"{x}"; };
    };
};

// get_x() is now available at runtime
def main() -> int
{
    return get_x();   // returns 42
};

#def NUM_OPS 4;

comptime
{
    byte*[NUM_OPS] op_names = ["add", "sub", "mul", "div"];

    // Step 1: open the function and switch, then exit emitflux with }#;
    emitflux
    {
        def dispatch(int id, int a, int b) -> int
        {
            switch (id)
            {
    }#;

    // Step 2: comptime loop emits one case per op
    int i = 0;
    while (i < NUM_OPS)
    {
        byte* nm = op_names[i];
        int   iv = i;

        emitflux
        {
                case (~$i"{}":{iv;}) { return ~$i"op_{}":{nm;} (a, b); }
        };

        i++;
    };

    // Step 3: close switch and function using #}; to avoid ending emitflux
    emitflux
    {
                default { return -1; };
           #};   // closes switch body
       #};       // closes function body
    };
};

and, as, asm, assert, auto, bool, break, byte, case, catch,
cdecl, char, comptime, const, constraint, continue, contract, data, def, default, defer,
deprecate, do, double, elif, else, emitflux, enum, escape, export, extern,
false, fastcall, float, for, from, global, goto, has, heap, if, in, inline, int, interface, is,  
jump, label, local, long, macro, namespace, noinit, noreturn, not, object,
operator, or, private, public, register, return, signed, singinit,
stack, stdcall, struct, switch, this, thiscall, throw, trait, true,
try, uint, ulong, union, unsigned, using, vectorcall, void,
volatile, while, xor

ADD = "+"
SUB = "-"
INCREMENT = "++"
DECREMENT = "--"
MUL = "*"
DIV = "/"
MOD = "%"
NOT = "!"
POWER = "^"
# Logical
AND = "&"
OR = "|"
NAND = "!&"
NOR = "!|"
XOR = "^^"
# Comparison
EQUAL = "=="
NOT_EQUAL = "!="
LESS_THAN = "<"
LESS_EQUAL = "<="
GREATER_THAN = ">"
GREATER_EQUAL = ">="
# Assignment
ASSIGN = "="
PLUS_ASSIGN = "+="
MINUS_ASSIGN = "-="
MULTIPLY_ASSIGN = "*="
DIVIDE_ASSIGN = "/="
MODULO_ASSIGN = "%="
POWER_ASSIGN = "^="
# Bitwise operators
# Logical
BITNOT = "`!"
BITAND = "`&"
BITOR = "`|"
BITNAND = "`!&"
BITNOR = "`!|"
BITXOR = "`^^"
BITXNOT = "`^^!"
BITXNAND = "`^^!&"
BITXNOR = "`^^!|"
# Assignment
AND_ASSIGN = "&="
OR_ASSIGN = "|="
XOR_ASSIGN = "^^="
BITAND_ASSIGN = "`&="
BITOR_ASSIGN = "`|="
BITNAND_ASSIGN = "`!&="
BITNOR_ASSIGN = "`!|="
BITXOR_ASSIGN = "`^^="
BITXNOT_ASSIGN = "`^^!="
BITXNAND_ASSIGN = "`^^!&="
BITXNOR_ASSIGN = "`^^!|="

# Ternary operators / Null-oriented operators
TERN_ASSIGN = "?="  // Assign if LHS is null
NOT_NULL = "!?"     // unary boolean postfix operator, primary use for pointers `if (px!?) {...};`
NULL_COALESCE = "??"

# Shift
BITSHIFT_LEFT = "<<"
BITSHIFT_RIGHT = ">>"
BITSHIFT_LEFT_ASSIGN = "<<="
BITSHIFT_RIGHT_ASSIGN = ">>="

BITSLICE = "``"

ADDRESS_OF = "@"
ADDRESS_ASSIGN = "@="
ADDRESS_CAST = "(@)"
RANGE = ".."
SCOPE = "::"
QUESTION = "?"
COLON = ":"
TIE = "~"
STRINGIFY = "$"
RETURN_ARROW = "->"
CHAIN_ARROW = "<-"
RECURSE_ARROW = "<~"      // def foo() <~ void;  // Emits musttail, 0 stack growth
NO_MANGLE = "!!"          // prevent the compiler from mangling the function name
FUNCTION_POINTER = "{}*"