tu  [options] file.tu        
    build *.tu              编译成汇编后进行链接生成二进制可执行文件
    -s  *.tu|dir            编译为tulang代码为linux-amd64汇编文件
    -c  *.s |dir            编译汇编为elf&pecoff跨平台可重定向cpu指令集文件
    -o  *.o |dir            链接elf&pecofff可重定向文件生成最终执行程序
    -d                      开启trace日志打印编译详细过程
    -gcc                    支持通过gcc链接生成最终可执行程序
    -g                      编译tu文件时带上debug段信息,支持栈回溯
    -std                    编译runtime&std相关内置库代码

$ cd tu
$ sudo make install
$ make tests

use fmt
class Http {
    request
}
Http::closure(){
    return fn(){
        return ["arr1","arr2",3,4]
    }
}
fn factory(){
    a = ["1",2,"some string word"]     // array
    b = {1:2,"sdfds":3,"a":a}          // map
    return a,b
}
fn main(){
    a = "this is a string"             // string
    b,c = 1000,200.33                  // number
    fmt.println(a,b,c)

    a,b = factory()
    fmt.print(a[0],a[1],a[2])
    fmt.print(b["a"],b["sdfds"])

    obj = new Http()                    // object
    obj.request = {"method":"POST"}
    cfunc = obj.closure()               // member
    fmt.println(cfunc())
}

use fmt
use os
fn main(){
    map = { "1":'a' , "hello":"world" , 3:5.11 , "arr": [ 0,1,2,3,4] }
    for k,v : map {
        if k == "arr" {
            for v2 : v {}
        }
        fmt.println(k,v)
    }

    match map["hello"] {
        map    : os.die("not this one!")
        999    : os.die("not this one!")
        "hello" | "world": {
            fmt.println("got it",map["hello"])
        }
        _      : {
            os.die("not default")
        }
    }
}

use runtime
Null<i64> = 0
enum {
    Insert,
    Update
    Conflict,
}

mem Rbtree {
    RbtreeNode* root
    RbtreeNode* sentinel
    u64         insert
}
mem RbtreeNode {
    u64  key
    u8   color
    RbtreeNode* left
    RbtreeNode* right
    RbtreeNode* parent

    runtime.Value* k
    runtime.Value* v[Conflict]
}
Rbtree::find(hk<u64>){

    node<RbtreeNode>     = this.root
    sentinel<RbtreeNode> = this.sentinel

    while node != sentinel 
    {
        if  hk != node.key  {
            if  hk < node.key {
                node = node.left
            }else{
                node = node.right
            }
            continue
        }
    }
    return Null
}
fn main(){}

use fmt
use runtime
use os

mem ReadStream: async {
    i32 bytes
    i32 readn
    i32 fd
}
ReadStream::poll(){
    if this.readn != this.bytes {
	this.readn += 1
	return runtime.PollPending
    }	
    match this.fd {
	1 : return runtime.PollReady , "hello "
	2 : return runtime.PollReady , "world"
	_ : os.die("")
    }
}
async read(){
    fut<ReadStream> = new ReadStream  { fd: 1, bytes: 5 }
    buf += fut.await

    fut2<ReadStream> = new ReadStream { fd: 2, bytes: 5 }
    buf += fut2.await
    return buf
}

fn main(){
    body = runtime.block(read())
    fmt.println(body)
}