// if you set lang, all this file doc is at lang's format
//!lang=MarkDown(Default)/Org/Wiki/Html/Rst/AsciiDoc(Custom="executable path")
//!from="../README.MD"

//! #header
//! [link](www.google.com)

/// blablabla
imports and defs

int a = 10;
char* a = "a";
char[] a = @meta @raii{
    File* f = new File(a);
    @emit(StringLiteral(f.String()))
};

int main(){
    int res = 10;
    char* res = f(res);
    int res = g(res);
    return res;
}

@raii{

}

@expr if
@expr switch
@expr match
@expr {}
// no need return clause
void func() @expr {

}
// similar to rust semantic
char* read_10(char* path) @expr @raii {
    File f = new File{path:path};
    char* ch = new char[10];
    fgets(ch, 10, f);

    ch
    // f.close is called automatically
}

struct A{int a};

int main(){
    A a = {a:5};
    A{int b} = a;
    @assert(b == 5);
    &A{int b_ptr} = &a;
    @assert(b_ptr = &(a->a));
    *A{int b} = *a;
    @assert(b = 5);
}

void lots_of_exception() @throws(Exception1, Exception2) {
    try{
        for(;;){
            new char[114514];
            some_other_function();
            throw DUM;
        }
    }
    catch(OOM oom){
        abort();
    }
    catch(DUM dum){
        println(dum.stackTrace().String());
        continue;
    }
}

int main(){
    @expr @raii @checked_exception_cps({
        err1: int a = f()?;
        err2: int b = g(a)?;
        err3: int c = h(b)?;
        Ok(c)
    },(err1){
        Err("1")
    },(err2){
        Err("2")
    },(err3){
        Err("3")
    });
}

struct Parent{
    const char* name;
}
struct Child{
    inline Parent parent;
    // still aba-abaing
}
int main(){
    Child child = {name: "David"};
    child.name;
}

struct Parent{
    const char* name;
}
struct Child{
    inline Parent parent;
    // compiler error
    const char* name;
}

struct{int a; int b;|} s;
union{int a; double b;|} u;
tunion{int a; double b;|} tu;

// row poly generic is treat like template
void f(struct{int a;|}* s);

template
   
    
void f(T* s);

// dynamic dispatch
void f(struct{int a;|}^ s);

   

interface Name{
    void function_def(This *this,Ty,Ty);
}

// interface pointer/ value will be treat like template
void function(Name* name);

// equiv
template
   
    
void function(T* name);

// dynamic dispatch
void function(Name^ name);

   

int main(){
    int a = 1;
    a.@dyn_call(int add(int,int,int))(2,3);
}
// in some other module
int add23(int a, int b, int c){
    return a + b + c;
}

// expect to work
template
   
    
T add23(T t){
    try {
        t.@dyn_call(T add(T,T,T))(T{2},T{3});
    }catch(Err^ err){
        if (err.string() == "MethodMissing"){
            bool res = @register("some_module.o");
            if (res)
                continue;
            else
                throw Err::MethodNotFount{name: "add"};
        }
    }
}

   

// project Hello
// module Hello
void hello(){
    // ...
}

int main(){
    Ty ty = {};
    A a = {};
    B b = {};
    (&ty).acn(a);
    (&ty).acn(b);
}

Struct Mat4x4 {int[16] elem};
@operator Mat4x4 Mat4x4_OPADD_Mat4x4_Mat4x4 (Mat4x4 a, Mat4x4 b){
    Mat4x4 res = {};
    res[0] = a[0] + b[0];
    // ...
    return res;
}
int main(Env* env){
    Mat4x4 a = {elem: {
        1,1,1,1,
        1,1,1,1,
        1,1,1,1,
        1,1,1,1
    }};
    Mat4x4 b = {elem: {
        2,2,2,2,
        2,2,2,2,
        2,2,2,2,
        2,2,2,2
    }};
    Mat4x4 c = a + b;
}

@JSON
struct SomeJson {
    int id;
    string name;
}

@attribute_macro JSONObject* JSON(AST* ast){
    match (ast.type){
        case "struct":
            FunctionBuilder fb = {};
            fb.ret_type = "JSON*";
            fb.name = @format("{}_toJson",ast.type);
            fb.args = {Args{ty: ast.type, name: arg}};
            fb.body = @quote {
                @unquote {JSONObject object = new JSONObject{};}
                for (field* : ast.fields){
                    @unquote {
                        object.add(field.toJsonField());
                    }
                }
                @unquote {return object;}
            };
            @emit(fb)
        default:
            @compiler_error("not supported");
    }
}

int main(){
    SomeJson sj = {};
    sj.toJson();
}

@macro call_default(Type $1, Function $2){
    @emit {
            @quote {
                // default initializer
                $1.name _1 = {};
                @meta {
                    if ($2.arg_count == 1 && $2.arg_type[0] == $1){
                        @emit { $2(_1) }
                    } else {
                        @compiler_error(@format("{} is not supported",$2.name))
                    }
                }
        }
    }
}

int main(){
    // yes it allows
    int inc(int a){return ++a;};
    @call_default(int,inc);
}

import stdio;
const version = 5;
@meta println(@format("version: {}",version));
int[] arr = {
    @meta for(int i = 1; i <= version; ++i) {
        @emit_raw(i)
        @write(",")
    }
};

int main(Env* env){
    @meta println("hello from compile time");
    println("hello from runtime);
    for(int i:arr){
        println(@format("{}",i));
    }
}

> version: 5
> hello from compile time
> hello from runtime
> 1
> 2
> 3
> 4
> 5

template
   
    
void f(T t){}

@export_template(f
    
     ,f
     
      ,f
      
       )

      
     
    
   

@compile_time int fib(int a){
    if(a==0||a==1)
        return 1;
    else{
        return fib(a-1) + fib(a-2);
    }
}
int main(){
    // 1 1 2 3 5 8 13
    const int a = fib(4);
    // int a = 5;
    int b = fib(a);
    // int b = 8;
}

auto function_has_call_back(int a){
    return clos int (int b){
        return a + b;
    };
}

// auto will be replaced by `Closure
   
    `

   

int add(int a, int b){
    return a + b;
}

int add(int a, int b, int c){
    return a + b + c;
}

auto lam = void(){println("hello")};
// void _lam_{__LINE__}_{__FUNC__}

void func(){
    int a;
    auto clos = clos void(){
        a += 1;
    }
}

thread_local int a = 0;
int main(){
    auto lam = void(){for(;;){
        a += 1;
        println(@format("{}",a));
    }};
    auto _ = spawn(lam);
    lam();
}
/*
1
2
3
1
4
2
3
5
...
*/

@fromC("src/a.c") void function(){}

@coroutine void socket_listener(Socket *s) -> String{
    for(;;){
        auto res = await s.next();
        if(res != close){
            yield res.String()
        }else{
            return;
        }
    }
}

// a simple callback function
callback (tyy a) where{
    callback = void(int,int),
    tyy = int,
}
{
    //...
}