语法文档

import fmt
 
fn main() {
	fmt.printf('hello world')
}

import fmt
 
var globalv = 1
 
type globalt = int
 
fn main() {
	var localv = 2
	type local t = int
	
	if true {
	}
 
	for true {
	}
}
 
if true { // x 不允许在全局作用域中声明 if 语句
 
}

var foo = 1 // v 声明变量 foo 并赋值，foo 类型自动推导为 int  
  
var foo = 1 // x 同一作用域下，不允许重复声明变量  
  
if (true) {  
    var foo = 2 // v 不同作用域下允许重复声明  
}

int foo = 1 // v  
float bar = 2.2 // v  
string car = 'hello world' // v 字符串使用单引号包裹  
  
foo = 2 // v 变量允许重新定值  
 
foo = 'hello world' // x foo 已经定义为 int 类型变量，不允许使用字符串赋值  
  
i8 f2 = 12 // v 字面量能够根据类型进行自动转换  
i16 f3 // x 变量声明必须赋值

string bar = '' // v 请使用这种方式声明一个空的字符串
 
[int] baz = [] // v 声明空 vec  
 
{float} s = {} // v 声明空 set
 
{string:float} m = {} // v 声明空 map
 
(int,bool,bool) t = (1, true, false) // v 定义 tuple， 使用方式 t[0], t[1], t[2]
 
var (t1, t2, t3) = (1, true, 'hello') // tuple 解构声明
 
var baz = [] // x, 无法推导 vec element 的类型
  
bar = null // x 不允许将 null 赋值给任何类型复合类型或者简单类型

// 方式 1
string? s = null
s = 'i am string'
 
// 方式 2
nullable<string> s2 = null 
s2 = 'hello world'

if condition {
    // 当 condition 为 true 时执行的代码
} else {
    // 当 condition 为 false 时执行的代码
}

int foo = 23
 
if foo > 100 {
    print('foo > 100')
    
} else if foo > 20 {
    print('foo > 20')
    
} else {
    print('else handle')
}

var sum = 0
for int i = 1; i <= 100; i += 1 {
    sum += i
}
println('1 +..+100 = ', sum)

var sum = 0
var i = 0
for i <= 100 {
    sum += i
    i += 1
}
println('1 +..+100 = ', sum)

var list = [1, 1, 2, 3, 5, 8, 13, 21]
for v in list {
    println(v)
}

var m = {1:10, 2:20, 3:30, 4:40}
for k in m {
    println(k)
}

for k, v in m {
    println(k, v)
}

// 这是一个单行注释
var str = `hello world` // 这也是一个单行注释

/*
这是一个多行注释
可以跨越多行
*/
var str = `hello world`

int i = 42.5 as int  // 浮点数转整数
[u8] bytes = "hello" as [u8]  // 字符串转字节数组
 
anyptr ptr = &i as anyptr  // rawptr<int> 转 anyptr

type my_int = int
type nullable<T> = T|null

fn string.find_char(u8 char, int after):int {
    int len = self.len()
    for int k = after; k < len; k += 1 {
        if self[k] == char {
            return k
        }
    }
    return -1
}

type square = struct {
    int length
    int width
}
 
fn square.area():int {
    return self.length * self.width
}

fn function_name(parameter_list):return_type {
    // 函数体
}

fn sum(int a, int b):int {
    return a + b
}

// 将匿名函数赋值给变量
var f = fn(int a, int b):int {
    return a + b
}
 
// 调用匿名函数
var result = f(1, 2)

fn sum(...[int] numbers):int {
    var result = 0
    for v in numbers {
        result += v
    }
    return result
}
 
// 调用
println(sum(1, 2, 3, 4, 5))

fn printf(string fmt, ...[any] args) {
    var str = sprintf(fmt, ...args)
    print(str)
}

fn divide(int a, int b):(int, int) {
    return (a / b, a % b) // 返回商和余数
}
 
// 使用 tuple 解构接收返回值
var (quotient, remainder) = divide(10, 3)

// 定义一个函数类型变量
fn(int,int):int calculator = fn(int a, int b):int {
     return a + b 
}
 
// 函数类型作为参数
fn apply(fn(int,int):int f, int x, int y):int {
    return f(x, y)
}

// 结构体声明
type person = struct {
    string name
    int age
    bool active
}
 
// 结构体初始化，此时 p 在栈上进行初始化
var p = person{
    name = "Alice",
    age = 25
}
 
//  使用 new 可以在堆上初始化， 并获取结构体指针
ptr<person> p2 = new person(name = "Bob", age = 30)
p2.name = "Tom"  // 自动解引用

type person_t = struct{
    string name = "unnamed"
    bool active = true
}
 
// 使用默认值初始化
var p = person_t{}  // p.name="unnamed", p.active=true

type rect = struct {
    int width
    int height
}
 
// 为 rect 类型添加扩展函数
fn rect.area():int {
    return self.width * self.height  // 使用 self 访问结构体字段
}
 
fn main() {
    var r = rect{width = 10, height = 5}
    println(r.area())  // 输出: 50
    
    ptr<rect> rp = new rect(width = 20, height = 10)
    println(rp.area()) // 输出: 200
}

// 嵌套结构体
type outer = struct {
    int x
    rect r = rect{}  // 嵌套结构体with默认初始化
}
 
// 结构体组合
type animal = struct {
    string name
}
 
type dog = struct {
    animal base    // 组合 animal 结构体
    string breed
}
 
 
type dog = struct {
    struct {
        string name
    } base // x 不要使用匿名结构体, 虽然能够声明也无法进行初始化赋值, 仅用于内存结构转换使用
    string breed
}

// 字符串声明 - 支持单引号、双引号或反引号
string s1 = 'hello world'
string s2 = "hello world"
string s3 = `hello world`
 
// 字符串拼接
string s4 = s1 + ' one piece'
 
// 字符串比较
bool b1 = 'hello' == 'hello'  // true
bool b2 = 'a' < 'b'          // true
 
// 获取字符串长度
int len = s1.len()
 
// 索引访问和修改
s1[0] = 72  // 将第一个字符修改为 'H'（ASCII 码 72）
 
// 字符串与字节数组转换
[u8] bytes = s1 as [u8]
string s5 = bytes as string
 
// 字符串遍历
for v in s1 {
    // v 的类型为 u8，表示 ASCII 码值
    println(v)
}

// 声明与初始化
[int] list = [1, 2, 3]        // 语法 1：使用 [T] 声明
vec<int> list2 = [1, 2, 3]    // 语法 2：使用 vec<T> 声明
var list3 = vec_new<int>(0, 10) // 创建空 vec, 其中第一个参数是初始化的默认类型
var list7 = vec_new<string>("hello", 10) // 初始化字符串数组，默认值是 string
var list5 = [0;10]  // 等同于 vec_new，并根据默认参数类型自动推导
var list6 = vec_cap<int>(10) // 指定 cap, len = 0
[int] list4 = [] // 自动推导空 vec 类型
 
// 基本操作
list[0] = 10                   // 修改元素
var first = list[0]           // 获取元素
list.push(4)                  // 添加元素
var len = list.len()          // 获取数组长度
var cap = list.cap()          // 获取数组容量
 
// 切片和合并
var slice = list.slice(1, 3)  // 获取下标 1 到 3(不含) 的切片
list = list.concat([4, 5, 6]) // 合并两个数组
list.append([4, 5, 6]) // 追加到 list 数组上
 
// 遍历
for v in list {
    println(v)
}

// 声明与初始化
var m3 = {'a': 1, 'b': 2}              // 类型推导
{string:int} m1 = {'a': 1, 'b': 2}     // 使用 {T:T} 声明
map<string,int> m2 = {'a': 1, 'b': 2}  // 使用 map<T,T> 声明
 
// 基本操作
m1['c'] = 3                    // 插入/更新元素
var v = m1['a']                // 获取元素值
m1.del('b')                    // 删除元素
var exists = m1.contains('a')  // 检查键是否存在
var size = m1.len()            // 获取元素数量
 
// 遍历
for k in m1 {                  // 仅遍历键
    println(k)
}
 
for k, v in m1 {              // 同时遍历键和值
    println(k, v)
}
 
// 空 map 声明 示例
{string:int} empty = {}
var empty = map_new<string,int>()

// 声明与初始化
{int} s1 = {-32, -64, 13}     // 使用 {T} 声明
set<int> s3 = {1, 2, 3}       // 使用 set<T> 声明
 
// 基本操作
s1.add(111)                   // 添加元素
s1.del(13)                    // 删除元素
var exists = s1.contains(13)  // 检查元素是否存在
 
var found = {1, 2, 3}.contains(2)  // 支持方法链式调用
 
// 遍历
for v in s1 {
    println(v)
}
 
// 空集合声明
{int} empty = {}              
var empty = set_new<int>()     

var tup = (1, 1.1, true) // v 声明并赋值，多个元素使用逗号分隔
 
var tup = (1) // x tuple 中至少需要包含两个元素
 
var foo = tup[0] // v 字面量 0 表示 tuple 中的第一个元素，以此类推
 
// x tuple 中的元素访问不允许出现表达式，只允许通过 int 字面量访问
var foo = tup[1 + 1]
 
tup[0] = 2 // v 修改 tuple 中的值

var list = [1, 2, 3]
 
// 1. 变量创建
 // v 值允许通过 var 进行自动类型推导来连续创建多个变量
var (foo, bar, car) = (1, 2, true)
 
 // x 禁止声明类型，只允许通过 var 自动类型推导
(custom_type, int, bool) (foo, bar, car) = (1, 2, true)
 
var (foo, (bar, car)) = (1, (2, true)) // v 嵌套形式的创建多个变量
var (list[0], list[1]) = (2, 4) // x 创建变量时，左侧不允许使用表达式
 
 
// 2. 变量赋值
(foo, bar) = (bar, foo) // v 修改变量 foo,bar 的值，可以进行快速变量值交换
(foo, (bar, car)) = (2, (4, false)) // v 嵌套形式修改变量的值操作
(foo, bar, car) = (2, (4, false)) // x 左值与右值的类型不匹配
 
 // v tuple 赋值操作中允许使用左值表达式 ident/ident[T]/ident.T 这样的表达式为左值表达式
(list[0], list[2]) = (1, 2)
(1 + 1, 2 + 2) = (1, 2) // x 1+1 属于右值表达式

[u8;3] array = [1, 2, 3] // 声明一个长度为 12，元素为 u8 类型的数组
array[0] = 12
array[1] = 24
var a = array[7]

type t1 = struct {
    [u8;12] array
}
 
var size = @sizeof(t1) // 12 * 1 = 12byte
 
type t2 = struct {
    [u8] list
}
 
var size = @sizeof(t2) // list is pointer size = 8byte

// x 错误使用方式, can't use throw stmt in a fn without an errable! declaration. example: fn rem(...):void!
fn rem(int dividend, int divisor):int {
	...
}
 
// v 正确使用方式, 函数必须声明包含 error, 使用 ! 表示函数函数可能抛出错误
fn rem(int dividend, int divisor):int! {
	if divisor == 0 {
		throw errorf('divisor cannot zero')
	}
	return dividend % divisor
}

// 存在 error(!)  声明的函数可以使用 catch 拦截， 其中 e  实现了 throwable 接口
//type throwable = interface{  
//    fn msg():string  
//}  
//type errort:throwable = struct{  
// ...
//}  
 
var result = rem(10, 0) catch e {
    println(e.msg())
    break 1 // break 可以为 result 赋默认值
}

try {
    var a = 1
    var b = a + 1
    rem(10, 0)
    var c = a + b
} catch e { // e 实现了 throwable
    println('catch err:', e.msg())
}

fn bar():void! {
    throw errorf('error in bar')
}
 
fn foo():void! {
    bar()
}
 
fn main():void! {
    foo()
}

coroutine 'main' uncaught error: 'error in bar' at nature-test/main.n:2:22
stack backtrace:
0:	main.bar
		at nature-test/main.n:2:22
1:	main.foo
		at nature-test/main.n:6:11
2:	main.main
		at nature-test/main.n:10:11

var list = [1, 2, 3]
var a = list[4] 

// panic 捕获方式与 error 相同
var a = list[4] catch e {
    println(e.msg())
}
 
// 使用 panic 函数可以手动抛出 panic
panic('failed')

// 使用 | 运算符声明联合类型
type nullable<T> = T|null  // 可空类型
type number = int|float    // 数值类型

int? foo = null        // 等同于 nullable<int> foo = null
string? bar = "hello"  // 等同于 nullable<string> bar = "hello"

int? foo = 42
int val = foo as int  // 将联合类型断言为具体类型

int? foo = 42
bool is_int = foo is int    // true
bool is_null = foo is null  // false
 
// 在条件语句中使用, 如果可以通过逻辑判断确定 foo 的具体类型
// foo 在 if body 中会自动进行断言 foo = foo as int
if foo is int {
    println("foo is an integer", foo)
}

int? foo = null
int result = match foo {
    is int -> foo        // auto: foo = foo as int
    is null -> -1        // auto: foo = foo as null
}

any foo = 1
int? bar = null
foo = bar // v
bar = foo // x bar 的范围小于 foo

type measurable = interface{  
    fn area():int  
    fn perimeter():int
}
 
// interface 支持泛型声明
type measurable<T> = interface{  
    fn area():T  
    fn perimeter():T  
}

type measurable<T> = interface{  
    fn perimeter():T  
    fn area():T  
}  
 
// type 实现 interface
type rectangle: measurable<i64> = struct{  
    i64 width  
    i64 height  
}  
 
fn rectangle.area():i64 {  
    return self.width * self.height  
}
 
fn rectangle.perimeter():i64 {  
    return 2 * (self.width + self.height)  
}

fn print_shape(measurable<i64> s) {  
    println(s.area(), s.perimeter())  
}
 
fn main() {
	// 值传递
	var r = rectangle{width=3, height=4}  
	print_shape(r)  
 
	// 指针引用传递
	var r1 = new rectangle(width=15, height=18)  
	print_shape(r1)
}

type measurable<T> = interface{  
    fn perimeter():T  
    fn area():T  
}  
  
type updatable = interface{  
    fn update(i64)  
}  
  
type rectangle: measurable<i64>,updatable = struct{  
    i64 width  
    i64 height  
}  
fn rectangle.area():i64 {  
    return self.width * self.height  
}  
fn rectangle.perimeter():i64 {  
    return 2 * (self.width + self.height)  
}  
fn rectangle.update(i64 i) {  
   self.width = i  
   self.height = i  
}

fn use_com(combination c):int {  
    if c is square {  
        // auto as: square c = c as square, c is interface  
        c.unique()  
        return 1  
    }  
    if c is ptr<square> {  
        // auto as: ptr<square> c = c as ptr<square>  
        c.unique()  
        return 2  
    }  
    return 0  
}
 
// 同样支持 match is
  
fn use_com(combination c):int {  
    return match c {  
        is square -> 10  
        is ptr<square> -> 20  
        _ -> 0  
    }  
}

fn use(testable? test) {  
    if (test is testable) { // test = test as testable  
        println('testable value is', test.nice())  
    } else {  
        println('test not testable')  
    }  
}

match subject {
    pattern1 -> expression1
    pattern2 -> expression2
    ...
    _ -> default_expression  // 默认分支
}

var a = 12
match a {
    1 -> println('one')
    12 -> println('twelve')  // 匹配成功
    20 -> println('twenty')
    _ -> println('other')
}

match 'hello world' {
    'hello' -> println('greeting')
    'hello world' -> println('full greeting')  // 匹配成功
    _ -> println('other')
}

match {
    12 > 0 && 0 > 0 -> println('case 1')
    (13|(1|2)) == 15 -> println('case 2')  // 匹配成功
    (1|2) > 3 -> println('case 3')
    _ -> println('default')
}

any value = 2.33
var result = match value {
    is int -> 0.0
    is float -> value  // value 自动断言为 float 类型: var value = value as float
    _ -> 0.0
}

string result = match {
    12 > 13 -> {
        var msg = 'case 1'
        break msg
    }
    12 > 11 -> {
        var msg = 'case 2'
        break msg  // 匹配成功，返回 'case 2'
    }
    _ -> 'default'
}

// 单个类型参数
type box<T> = struct {
    T value
}
 
// 多个类型参数
type pair<T, U> = struct {
    T first
    U second
}
 
type result<T> = T|error    // 泛型联合类型
 
type list<T> = [T]         // 泛型数组类型

type wrapper<T> = struct {
    box<T> inner    // 嵌套使用泛型类型
}
 
// 使用嵌套泛型
var w = wrapper<int>{
    inner = box<int>{value = 42}
}

// 泛型函数声明
fn sum<T>(T a, T b):T {
    return a + b
}
 
// 泛型函数调用
var result = sum<int>(1, 2)      // 显式指定类型
var result2 = sum(1.1, 2.2)      // 类型自动推导
 
 
//  类型参数定义扩展函数
type box<T> = struct {
    T value
}
 
fn box<T>.get():T {
    return self.value
}

// union 约束
type test_union = int|bool|float  
  
fn test<T:test_union>(T param) {  
    println(param)  
}
 
// union 简化写法
fn test<T:int|bool|float>(T param) {  
    println(param)  
}
 
// interface 约束
type test_interface = interface{}  
type test_interface2 = interface{}  
  
fn test<T:test_interface&test_interface2>(T param) {  
    println(param)  
}

// 定义泛型结构体
type pair<T, U> = struct {
    T first
    U second
}
 
// 定义泛型方法
fn pair<T, U>.swap():(U, T) {
    return (self.second, self.first)
}
 
fn main() {
    // 创建泛型实例
    var p = pair<int, string>{
        first = 42,
        second = "hello"
    }
    
    // 调用泛型方法
    var (s, i) = p.swap()
}

var fut = go sum(1, 2)  // 创建一个共享协程

var fut = @async(sum(1, 2), co.SAME)  // SAME 表示新的协程和当前协程共用 processor

fn sum(int a, int b):int {
    co.sleep(1000)  // 模拟耗时操作, sleep 单位 ms
    return a + b
}
 
fn main() {
    var fut = go sum(1, 2)
    var result = fut.await()  // 等待协程执行完成并获取结果
    println(result)  // 输出: 3
}

import co.mutex as m
 
// 创建互斥锁
var mu = m.mutex_t{}
 
// 加锁
mu.lock()
 
// 临界区代码
// ...
 
// 解锁
mu.unlock()

fn div(int a, int b):int! {
    if b == 0 {
        throw errorf("division by zero")
    }
    return a / b
}
 
fn main() {
    var fut = go div(10, 0)
    var result = fut.await() catch e {
        println("error:", e.msg())
        break 0  // 提供默认值
    }
}

// 创建无缓冲 channel
var ch = chan_new<int>()      // 创建传递 int 类型数据的 channel
var ch_str = chan_new<string>() // 创建传递 string 类型数据的 channel
 
// 创建带缓冲的 channel
var ch_buf = chan_new<int>(5)  // 创建缓冲大小为 5 的 channel
 
// 发送数据
ch.send(42)        // 发送数据到 channel
ch_str.send("hello") 
 
// 接收数据
var value = ch.recv()     // 从 channel 接收数据
var msg = ch_str.recv()
 

ch.close()                    // 关闭 channel
bool closed = ch.is_closed()  // 判断协程 是否关闭
var ok = ch.is_successful()   //  在协程关闭状态下可以检查最近的读取或者写入操作是否成功

select {
    ch1.on_recv() -> msg {
        // 处理从 ch1 接收到的数据
    }
    ch2.on_send(value) -> {
        // ch2 发送成功后的处理
    }
    _ -> {
        // 默认分支，当所有 channel 都不可操作时执行
    }
}

// 生产者
go (fn(chan<int> ch):void! {
    ch.send(42)
})(ch)
 
// 消费者
var value = ch.recv()

var limiter = chan_new<u8>(10)  // 最多允许 10 个并发任务
for u8 i = 0; i < 100; i+=1 {
    limiter.send(i)             // 获取令牌
    go (fn():void! {
        // 处理任务
        limiter.recv()          // 释放令牌
    })()
}

var ch = chan_new<string>()
var timeout = chan_new<bool>()
 
select {
    ch.on_recv() -> msg {
        println("received:", msg)
    }
    timeout.on_recv() -> {
        println("operation timeout")
    }
}

var size = @sizeof(i8) // sizeof 读取类型占用栈内存
 
type double = f64
var hash = @reflect_hash(double) // 读取类型反射唯一标识
 
@async(delay_sum(1, 2), 0) //  创建协程
 
// 使用 unsafe_load 避免对 package struct 进行堆分配  
@unsafe_load(package).set_age(25) 
 
var a = @default // 堆变量赋初始化默认值，通常用于泛型中的默认值赋值

#linkid print_message
fn log(string message):void {
    // 函数实现
}

#local
fn internal_helper():void {
    // 函数实现
}

nullable<int> foo = null
foo = 42  // 可以赋值为 int 类型
 
// 简写语法
int? bar = null
bar = 42

  
type throwable = interface{  
    fn msg():string  
}  
  
type errort:throwable = struct{  
    string message  
    bool is_panic  
}  
  
fn errort.msg():string {  
    return self.message  
}  
  
fn errorf(string format, ...[any] args):ptr<errort> {  
    var msg = fmt.sprintf(format, ...args)  
    return new errort(message = msg)  
}

print("Hello", 42, true)  // 输出: Hello42true

println("Hello", 42)  // 输出: Hello 42\n

panic("something went wrong")  // 程序终止并输出错误信息

assert(1 + 1 == 2)  // 正常执行
assert(1 > 2)       // 触发 panic

// main.n
import fmt
 
fn main() {
    fmt.printf("Hello, World!")
}

// user.n
type user = struct {
    int id
    string username
}
 
int total_users = 0
 
fn create_user(string name):user {
    total_users += 1
    return user{
        id = total_users,
        username = name
    }
}

// 基本导入
import "user.n"
 
// 使用别名
import "user.n" as u
 
fn main() {
    var new_user = user.create_user("alice")
    // 或者使用别名
    var another = u.create_user("bob")
}

# 基础信息
name = "myproject"        # 项目名称
version = "1.0.0"        # 版本号
authors = ["Alice <a@example.com>"]
description = "项目描述"
license = "MIT"
type = "bin"             # bin 或 lib
entry = "main"           # 库的入口文件（type = "lib" 时使用）
 
# 依赖包，可以通过 git 或者本地路径指定
[dependencies]
rand = { type = "git", version = "v1.0.1", url = "jihulab.com/nature-lang/rand" }
local_pkg = { type = "local", version = "v1.0.0", path = "./local" }

$HOME/.nature/package
├── caches
└── sources
    ├── jihulab.com.nature-lang.os@v1.0.1
    │   ├── main.n
    │   └── package.toml
    └── local@v1.0.0
        ├── main.linux_amd64.n
        ├── main.linux.n
        ├── main.n
        └── package.toml
 

import rand                    // 导入包的主模块（等同于 import rand.main）
import rand.utils.seed         // 导入特定模块
import rand.utils.seed as seed // 使用别名

[dependencies]
rand_v1 = { type = "git", version = "v1.0", url = "jihulab.com/nature-lang/rand" }
rand_v2 = { type = "git", version = "v2.0", url = "jihulab.com/nature-lang/rand" }

import rand_v1
import rand_v2

[links]
libz = { 
    linux_amd64 = 'libs/libz_linux_amd64.a',
    darwin_amd64 = 'libs/libz_darwin_amd64.a',
    linux_arm64 = 'libs/libz_linux_arm64.a', 
    darwin_arm64 = 'libs/libz_darwin_arm64.a'
}

#linkid gzopen
fn gzopen(anyptr fname, anyptr mode):anyptr
 
#linkid sleep
fn sleep(int second)

// zlib.n
#linkid gzopen
fn gzopen(anyptr fname, anyptr mode):anyptr
 
// main.n
import zlib
 
fn main() {
    var output = "output.gz"
    // 使用 string.ref 函数可以获取 c 语言字符串，包含 '\0'
    var gzfile = zlib.gzopen(output.ref(), "wb".ref())
    if gzfile == null {
        throw errof("failed to open gzip file")
    }
    // ... 使用 gzfile
}

// 获取变量地址
var str = "hello"
anyptr ptr = str.ref()  // 获取字符串地址
 
// 获取 rawptr 类型
rawptr<tm_t> time_ptr = &time_info  // 获取结构体地址
 
// 获取 anyptr 类型
anyptr c_ptr = time_info as anyptr // 任何 nature 类型都可以转换为 anyptr 类型

type tm_t = struct {
    i32 tm_sec
    i32 tm_min
    i32 tm_hour
    i32 tm_mday
    i32 tm_mon
    i32 tm_year
    i32 tm_wday
    i32 tm_yday
    i32 tm_isdst
    i64 tm_gmtoff
    anyptr tm_zone
}

// ...
#linkid localtime
fn localtime(rawptr<i64> timestamp):rawptr<tm_t>
 
#linkid strlen
fn strlen(anyptr str):uint
 
#linkid fork
fn fork():int
 
// ...

var bar = '' // stmt 结尾不需要携带 ; 
 
if true {
    var foo = 1 // 使用 4 个空格进行缩进
}
 
call_test(
    1,
    2, // 多行参数, 需要在最后一行添加 ,
)
 
var v = [
    1,
    2,
    3, // 同上
]
 
var m = {
    "a": 1,
    "b": 2, // 同上
}
 
var s = person_t{ // 结构体 alias ident 和 { 之间不需要空格
    name: "john",
    age: 18, // 同上
}
 
// 1. 函数定义 '{' 和函数声明需要在同一行
// 2. 返回参数和 ')' 之间需要空格
// 3. 每个参数之间需要空格
fn test(int arg1, int arg2):int {
 
}