Syntax Document

import fmt // import module declaration, fmt module is a standard library string formatting module
 
fn main() { // fn is used for function declaration, main function serves as the program entry point
	fmt.printf('hello %s', 'world') // call printf function in fmt module for formatted output
}

import fmt
 
var global_v = 1
 
const PI = 3.14
 
type global_t = int
 
fn main() {
	var localv = 2
	type local_t = int
	
	if true {
	}
 
	for true {
	}
}
 
if true { // x not allowed to declare if statement in global scope
}

var foo = 1 // v declare variable foo and assign value, foo type is automatically inferred as int  
  
var foo = 1 // x duplicate variable declaration not allowed in the same scope  
  
if (true) {  
    var foo = 2 // v duplicate declaration allowed in different scopes  
}

int foo = 1 // v
u8 foo2 = 1 // v literal automatic type inference
 
float bar = 2.2 // v  
 
string car = 'hello world' // v strings use single quotes  
string car2 = "hello world" // v double quotes supported
string car3 = `hello
world` // v backticks supported
  
foo = 2 // v variables allow reassignment  
 
foo = 'hello world' // x foo is already defined as int type, cannot assign string  
  
i8 f2 = 12 // v literals can automatically convert according to type  
i16 f3 // x variable declaration must include assignment

string bar = '' // v use this method to declare an empty string
 
[int] baz = [] // v declare empty vec
var baz2 = vec_new<string>('default value', 10) // method 2
 
{float} s = {} // v declare empty set
var s = set_new<float>() // v method 2
 
{string:float} m = {} // v declare empty map
var m = map_new<string,float>() // v method 2
 
(int,bool,bool) t = (1, true, false) // v define tuple, use as t[0], t[1], t[2]
 
var (t1, t2, t3) = (1, true, 'hello') // tuple destructuring declaration
 
var sum = fn(int a, int b):int { // closure declaration
	return a + b
}
 
 
var baz = [] // x, cannot infer vec element type
 
bar = null // x cannot assign null to any compound type or simple type

// method 1 nullable
string? s = null
s = 'i am string'
 
// method 2
nullable<string> s2 = null 
s2 = 'hello world'
 
// method 3 union
type union_test = int|float|null
union_test u = null
 
// method 3 any
any s3 = null // any is a special union type that includes all types by default

const PI = 3.14 // v float type, constant definition cannot declare type, compiler will automatically infer
const STR = 'hello world' // v string type
const INDEX = 1 // v int type
const B = true // v bool type
 
const STR2 = STR + 'byebye' // v constant folding calculation
const AREA = PI * 2 * 2 // v calculation example, supports common operators
 
const RESULT = test() // x constant definition only supports literal integer/float/string/bool types

if condition {
    // code executed when condition is true
} else {
    // code executed when condition is false
}

int foo = 23
 
if foo > 100 {
    print('foo > 100')
} else if foo > 20 {
    print('foo > 20')  // matches
} 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)
}

// example: var ch = chan_new<int>()
// yield until ch.recv() receives message to wake up current coroutine
for v in ch {
    println('recv v ->', v)  
}

fn function_name(parameter_list):return_type {
    // function body
}

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

fn main() {
	int c = 3
	
	var f = fn(int a, int b):int {
	    return a + b + c
	}
	
	var result = f(1, 2) // call anonymous function
}

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)
}
 
// Use tuple destructuring to receive return values
var (quotient, remainder) = divide(10, 3)

type calc_fn = fn(int,int):int  // declare fn type
  
fn apply(calc_fn f, int x, int y):int {  
    return f(x, y)  
}  
  
fn main() {  
    var result = apply(fn(int a, int b):int {  
        return a + b  
    }, 3, 4)  
  
    println(result)  
}

fn print() { // v
}
 
fn print():void { // v
 
}

// This is return type postfix
func sum(a int, b int) (c int) {  
    c = a + b  
    return c  
}
 
// This is return type prefix
fn sum(int a, int b):(int c) {
	c = a + b
	return c
}

// This is a single line comment
var str = `hello world` // This is also a single line comment

/*
This is a multi-line comment
can span multiple lines
*/
var str = `hello world`

type my_int = int
 
type person_t = struct{
	int age
	float height
}
 
type node_t = struct{
	int id
	[node_t] children // v use dynamic array or pointer nested reference type
	rawptr<node_t> next // v reference through raw pointer
	ptr<node_t>? next // v pointer+nullable reference
	node_t next // x circular reference
	[node_t;2] foo // x circular reference
	node2_t bar // x circular reference
}
 
type nullable<T> = T|null // custom union type + type parameter generics
 
type throwable = interface{} // interface definition, detailed introduction later

int i = 42.5 as int  // float to integer
 
[u8] bytes = "hello" as [u8]  // string to vec
 
string str = bytes as string // vec<u8> to string
 
anyptr ptr = &i as anyptr  // rawptr<int> to anyptr
 
type myint = int
myint foo = 12
 
int bar = foo as int // myint -> int
int baz = bar as myint // int -> myint

f32 a = 1.1 // automatic inference conversion
f64 b = 2.2 // automatic inference conversion
any c = 1.1 // cannot infer, defaults to float type
 
i8 d = 1
i16 e = 1
i32 f = 1
any g = 1 // cannot infer, defaults to int type

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 {
	// Use self for data reference in type extension
    return self.length * self.width
}
 
type box<T> = struct{
	T length
	T width
}
 
// Generic parameters need to be consistent with type declaration
fn box<T>.area():T{
	return self.length * self.width
}

// For string this is simple, string is stored in the heap, so it can be called directly
var str = 'hello world'
var c = str.find_char()
 
// But for scalar types and structs, you need to use the new keyword to allocate data in the heap, like
var s = new square(length=5, width=10) // s type is ptr<square>
var a = s.area() // self is ptr<square>

var s = square{}
 
// If method won't be referenced across threads, maybe we can cheat the compiler with an unsafe pointer via as conversion
(&s as anyptr as ptr<square>).area()
 
// We can also use the built-in macro @ula(unsafe load addr), which does the above type conversion
@ula(s).area()
 
// If we want memory safety while not calling new keyword for heap allocation?
// We can also use @sla(safe load addr) macro, which triggers simple escape analysis and allocates s in the heap by default.
@sla(s).area() 

var s = square{}
 
s.area() // v eq @sla(s).area()

// Struct declaration
type person_t = struct {
    string name
    int age
    bool active
}
 
// Struct initialization, struct is initialized on stack by default.
var p = person_t{
    name = 'Alice',
    age = 25
}
 
//  Using new can initialize on heap and get struct pointer
ptr<person> p2 = new person(name = 'Bob', age = 30)
p2.name = 'Tom'  // automatic dereference

type sub_t = struct{
	var name = 'alice' // supports automatic type inference when default value exists
}
 
type person_t = struct{
    string name = 'unnamed'
    bool active = true
 
    sub_t sub1         // Note! no default value here
    var sub2 = sub_t{} // includes default value
}
 
// Initialize with default values
// p.name is 'unnamed', p.active is true, 
// p.sub1.name is '', p.sub2.name is 'alice'
var p = person_t{}

type outer = struct {
    int x
    rect r = rect{} 
}
 
type animal = struct {
    string name
}
 
type dog = struct {
    animal base
    string breed
}
 
 
type dog = struct {
    struct {
        string name
    } base // x don't use anonymous struct, although it can be declared it cannot be initialized, only used for memory structure conversion
    string breed
}

string s1 = 'hello world' // use single quotes to declare strings in non-special cases
string s2 = "hello world"
string s3 = `hello 
world`
 
// use + sign for string concatenation
var s4 = s1 + ' one piece'
 
// string comparison
bool b1 = 'hello' == 'hello'  // true
bool b2 = 'a' < 'b'          // true
 
// get string length
int len = s1.len()
 
// access and modify through index
s1[0] = 72  // modify first character to 'H' (ASCII code 72)
 
// string and byte array conversion
[u8] bytes = s1 as [u8]
string s5 = bytes as string
 
// string traversal, traverse by char
for v in s1 {
    // v type is u8, represents ASCII code value
    println(v)
}

// method 1 through constant definition
const A = 97
const B = 99
 
u8 c = A
 
// method 2 through array reference
u8 c2 = '@'[0]

import strings
 
fn main() {
	var s = 'hello world world'  
	var index = s.find('wo')
	
	var list = s.split(' ')
	
	var list2 = ['nice', 'to', 'meet', 'you']  
	var s2 = strings.join(list2, '-')
	
	var b = s.starts_with('hello')
	
	// more methods can refer to standard library documentation
}

// Declaration and initialization
[int] list = [1, 2, 3]        // Syntax 1: recommended using [T] declaration
vec<int> list2 = [1, 2, 3]    // Syntax 2: using vec<T> declaration
 
 // Create empty vec, first parameter is initialization default type
var list3 = vec_new<int>(0, 10)
 
// Initialize string array, default value is string
var list7 = vec_new<string>("hello", 10) 
 
// Similar to vec_new, automatically infer based on default parameter type
var list5 = [0;10]
 
// Initialize with specified cap, len = 0
var list6 = vec_cap<int>(10)
 
// Automatically infer empty vec type
[int] list4 = []
 
list[0] = 10                  // modify element
var first = list[0]           // get element
list.push(4)                  // add element
var len = list.len()          // get vec length
var cap = list.cap()          // get vec capacity
 
// Slicing and merging
var slice0 = list[1..3] // get slice from index 1 to 3(exclusive)
var slice2 = list[..3] // get slice from 0 to 3(exclusive)
var slice3 = list[1..] // get slice from 1 to len(exclusive)
 
// Merge two vecs into a new vec
var new_list = list.concat([4, 5, 6]) 
 
 // Append to list
list.append([4, 5, 6])
 
 
// Traversal
for value in list {
}
 
for index,value in list {
}

// Declaration and initialization
var m3 = {'a': 1, 'b': 2}              // type inference
{string:int} m1 = {'a': 1, 'b': 2}     // using {T:T} declaration
map<string,int> m2 = {'a': 1, 'b': 2}  // using map<T,T> declaration
{string:int} empty = {}                // empty map declaration method 1
var empty = map_new<string,int>()      // empty map declaration method 2
 
// Insert/update element
m1['c'] = 3                   
 
// Get element value, if element doesn't exist will produce panic error, need to catch panic via catch
var v = m1['a']                
var v2 = m1['a'] catch e {
	// handle notfound
}
 
m1.del('b')                    // delete element
 
var exists = m1.contains('a')  // check if key exists
var size = m1.len()            // get element count
 
// Traversal
for k in m1 {                  // traverse keys only
    println(k)
}
 
for k, v in m1 {              // traverse both keys and values
    println(k, v)
}

// Declaration and initialization
{int} s1 = {-32, -64, 13}     // using {T} declaration
set<int> s3 = {1, 2, 3}       // using set<T> declaration
 
// Empty set declaration
{int} empty = {}              
var empty = set_new<int>()     
 
// Basic operations
s1.add(111)                   // add element
s1.del(13)                    // delete element
var exists = s1.contains(13)  // check if element exists
 
var found = {1, 2, 3}.contains(2)  // supports method chaining
 
// Traversal
for v in s1 {
    println(v)
}

var tup = (1, 1.1, true) // v declare and assign, multiple elements separated by comma
 
var tup = (1) // x tuple must contain at least two elements, otherwise cannot distinguish between expression and tup
 
var foo = tup[0] // v index 0 represents the first element in tuple, and so on
 
// x element access in tuple does not allow expressions, only int literals are allowed
var foo = tup[1 + 1]
 
tup[0] = 2 // v modify value in tuple

 
// v values can be used with var for automatic type inference to continuously create multiple variables
var (foo, bar, car) = (1, 2, true)
 
// x prohibit type declaration, only allow automatic type inference through var
(custom_type, int, bool) (foo, bar, car) = (1, 2, true)
 
// v nested form of creating multiple variables
var (foo, (bar, car)) = (1, (2, true)) 
 
// x when creating variables, left side does not allow expressions
var list = [1, 2, 3]
var (list[0], list[1]) = (2, 4)
 
// v modify variable foo,bar values, can perform quick variable value swapping
(foo, bar) = (bar, foo)
 
// v nested form of modifying variable values
(foo, (bar, car)) = (2, (4, false)) 
 
// x left value and right value type mismatch
(foo, bar, car) = (2, (4, false)) 
 
 // v tuple assignment operation allows left value expressions like ident/ident[T]/ident.T
(list[0], list[2]) = (1, 2)
 
// x 1+1 belongs to right value expression
(1 + 1, 2 + 2) = (1, 2)

[u8;3] array = [1, 2, 3] // declare an array with length 3, element type 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) // vec is pointer size = 8byte

// x wrong usage, can't use throw stmt in a fn without an errable! declaration. example: fn rem(...):void!
fn rem(int dividend, int divisor):int {
	throw errorf('....')
}
 
// v correct usage, function must declare containing errable(!), use `!` symbol to indicate function may throw error
fn rem(int dividend, int divisor):int! {
	if divisor == 0 {
		throw errorf('divisor cannot zero')
	}
	return dividend % divisor
}

var result = rem(10, 0) catch e { // e implements throwable interface, can call related methods
    println(e.msg())
    1 // last expression in catch body has value passing effect, can assign 1 to result
}

try {
    var a = 1
    var b = a + 1
    rem(10, 0)
    var c = a + b
} catch e { // e implements throwable interface, can call related methods
    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

 
// int! is equivalent to Result<int,err> in rust
// int? is equivalent to Option<int> in rust
fn rem(int dividend, int divisor):int! {
	if divisor == 0 {
		// equivalent to return Err('xxx')
		throw errorf('divisor cannot zero')
	}
	
	// equivalent to return Ok(xxx)
	return dividend % divisor
}
 
fn main() {
	// equivalent to int result = rem(10, 0)?
	int result = rem(10, 0)
	
	/**
	equivalent to
	let result = match rem(10, 0) {
		Err(e) => {
			debug('has err', e)
			0
		}
		Ok(r) => r
	}
	*/
	int result = rem(10, 0) catch e {
		println('has err', e.msg())
		0
	}
}

import fmt
 
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)  
}

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

// panic catching method is same as error
var a = list[4] catch e {
    println(e.msg())
}
 
// use built-in panic function to manually throw panic
panic('failed')

// use | operator to declare union of multiple types
type nullable<T> = T|null  // nullable type
type number = int|float    // numeric type

int? foo = null        // equivalent to nullable<int> foo = null
string? bar = "hello"  // equivalent to nullable<string> bar = "hello"

int? foo = 42
int val = foo as int  // assert union type to specific type

int? foo = 42
bool is_int = foo is int    // true
bool is_null = foo is null  // false
 
// when using type checking in conditional statements, if foo's specific type can be inferred through logical reasoning, automatic type assertion will be triggered at compile time
 
if foo is int {
	// auto as: foo = foo as int
    println("foo is an integer", foo + 1)
}
 
// x cannot perform automatic type inference
if !(foo is null) {  
	var bar = foo + 1 // binary type inconsistency, left is 'union', right is 'i64'
}

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's range is smaller than foo
 
type nullable2 = int|bool|null|string  
nullable2 bar2 = bar // v, nullable2 contains larger type range

type measurable = interface{  
    fn area():int  
    fn perimeter():int
}
 
// generic parameter declaration
type measurable<T> = interface{  
    fn area():T  
    fn perimeter():T  
}

type measurable<T> = interface{  
    fn perimeter():T  
    fn area():T  
}  
 
// type implements 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() {
	// value passing
	var r = rectangle{width=3, height=4}  
	print_shape(r)  
 
	// pointer reference passing
	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  
}
 
// also supports 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')  
    }  
}

type measurable<T> = interface{  
    fn perimeter():T  
    fn area():T  
}  
  
type updatable = interface{  
    fn update(i64)  
    fn area():i64  
}  
  
type combination: measurable<i64>,updatable = interface{  
    fn to_str():string  
}
 
// square needs to implement to_str + area + update + perimeter methods.
type square:combination = i64

type measurable<T> = interface{  
    fn perimeter():T  
    fn area():T  
}  
type combination: measurable<i64> = interface{  
    fn to_str():string  
}  
  
type square:combination = i64  
  
fn square.area():i64 {  
    i64 length = *self as i64  
    return length * length  
}  
fn square.perimeter():i64 {  
    return (*self * 4) as i64  
}  
fn square.to_str():string {  
    return 'hello world'  
}
 
fn use_mea(measurable<i64> m):int {
    return m.perimeter()  
}  
  
fn main():void! {  
    var sp = new square(8)  
    println(use_mea(sp))  
}

match subject {
    pattern1 -> expression1
    pattern2 -> expression2
    ...
    _ -> default_expression  // default branch
}

var a = 12
match a {
    1 -> println('one')
    12 -> println('twelve')  // matches successfully
    20 -> println('twenty')
    _ -> println('other')
}

match 'hello world' {
    'hello' -> println('greeting')
    'hello world' -> println('full greeting')  // matches successfully
    _ -> println('other')
}

match {
    12 > 0 && 0 > 0 -> println('case 1')
    (13|(1|2)) == 15 -> println('case 2')  // matches successfully
    (1|2) > 3 -> println('case 3')
    _ -> println('default')
}

any value = 2.33
var result = match value {
    is int -> 0.0
    is float -> value  // auto as: var value = value as float
    _ -> 0.0
}

fn main() {  
    string result = match {  
        (12 > 13) -> {  
            var msg = 'case 1'  
            msg  
        }  
        (12 > 11) -> {  
            var msg = 'case 2'  
            msg  // matches successfully, return value msg will be assigned to result 
        }  
        _ -> 'default'  
    }  
    println(result)  
}

// single type parameter
type box<T> = struct {
    T value
}
 
// multiple type parameters
type pair<T, U> = struct {
    T first
    U second
}
 
type result<T> = T|error    // generic union type
 
type list<T> = [T]         // generic array type

type wrapper<T> = struct {
    box<T> inner    // nested use of generic type
}
 
// using nested generics
var w = wrapper<int>{
    inner = box<int>{value = 42}
}

// generic function declaration
fn sum<T>(T a, T b):T {
    return a + b
}
 
// generic function call
var result = sum<int>(1, 2)      // explicitly specify type
var result2 = sum(1.1, 2.2)      // automatic type inference
 
 
//  type parameter definition method
type box<T> = struct {
    T value
}
 
fn box<T>.get():T {
    return self.value
}
 
// type parameter method and fn generic conflict, cannot be used simultaneously
 
fn box<T>.get<U>():U { // x method does not support generic parameters temporarily
}

// union constraint
type test_union = int|bool|float  
  
fn test<T:test_union>(T param) {  
    println(param)  
}
 
// union constraint can be abbreviated
fn test<T:int|bool|float>(T param) {  
    println(param)  
}
 
// interface constraint
type test_interface = interface{
	fn bar()
}  
type test_interface2 = interface{
	fn bar()
}  
  
// parameter needs to implement methods contained in interface.
fn test<T:test_interface&test_interface2>(T param) {  
    println(param)  
}

// define generic struct
type pair<T, U> = struct {
    T first
    U second
}
 
// define generic method
fn pair<T, U>.swap():(U, T) {
    return (self.second, self.first)
}
 
fn main() {
    // create generic instance
    var p = pair<int, string>{
        first = 42,
        second = "hello"
    }
    
    // call generic method
    var (s, i) = p.swap()
}

var fut = go sum(1, 2)  // create a shared coroutine

var fut = @async(sum(1, 2), co.SAME)  // SAME means new coroutine shares processor with current coroutine

import co // standard library co package contains some common coroutine functions
 
fn sum(int a, int b):int {
    co.sleep(1000)  // simulate time-consuming operation, sleep unit is ms
    return a + b
}
 
fn main() {
    var fut = go sum(1, 2)
    var result = fut.await()  // wait for coroutine execution completion and get result
    println(result)  // output: 3
}

import co.mutex as m
 
// create mutex
var mu = m.mutex_t{}
 
// lock
mu.lock()
 
// critical section code
// ...
 
// unlock
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())
        0  // return default value
    }
}

// create unbuffered channel
var ch = chan_new<int>()      // create channel for passing int type data
var ch_str = chan_new<string>() // create channel for passing string type data
 
// create buffered channel
var ch_buf = chan_new<int>(5)  // create channel with buffer size 5
 
// send data
ch.send(42)        // send data to channel
ch_str.send('hello') 
 
// receive data
var value = ch.recv()     // receive data from channel
var msg = ch_str.recv()

ch.close()                    // close channel
bool closed = ch.is_closed()  // check if coroutine is closed
var ok = ch.is_successful()   //  in closed state can check if recent read or write operation was successful

fn handle(chan<int> ch) {  
    for v in ch { // compiler automatically calls recv and yield until data is received
        println('recv v ->', v)  
    }  
}

select {
    ch1.on_recv() -> msg {
        // handle data received from ch1
    }
    ch2.on_send(value) -> {
        // handle after ch2 send success
    }
    _ -> {
        // default branch, executed when all channels are not operable
    }
}

// producer
go (fn(chan<int> ch):void! {
    ch.send(42)
})(ch)
 
// consumer
var value = ch.recv()

var limiter = chan_new<u8>(10)  // allow maximum 10 concurrent tasks
for u8 i = 0; i < 100; i+=1 {
    limiter.send(i)             // acquire token
    go (fn():void! {
        // process task
        limiter.recv()          // release token
    })()
}

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 reads type stack memory usage
 
type double = f64
var hash = @reflect_hash(double) // read type hash value.
 
@async(delay_sum(1, 2), 0) //  create coroutine
 
// use ula to avoid heap allocation for package struct  
@ula(package).set_age(25) 
 
var a = @default(T) // initialize default value, can be used for default value assignment in generics

#linkid print_message
fn log(string message):void {
    // function implementation
}

#linkid sleep  
fn sleep(int second)

#local
fn internal_helper():void {
    // function implementation
}

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

// basic import, by default takes user as module ident
import "user.n"
 
// custom module keyword
import "user.n" as u
 
// import standard library
import fmt
 
fn main() {
    var new_user = user.create_user("alice")
    
    var another = u.create_user("bob")
    
    fmt.printf('name is %s', another.name)
}

# basic information
name = "myproject"        # project name
version = "1.0.0"        # version number
authors = ["Alice <a@example.com>"]
description = "project description"
license = "MIT"
type = "bin"             # bin or lib
entry = "main"           # library entry file (used when type = "lib")
 
# dependency packages, can be specified via git or local path
[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 package main module (equivalent to import rand.main)
import rand.utils.seed         // import specified module, i.e., rand/utils/seed.n file
import rand.utils.seed as s    // custom module name

[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

nature build --ld '/usr/bin/ld' --ldflags '-nostdlib -static -lm -luv' main.n

import libc
 
fn main() {
	i32 r = libc.rand()
}

[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
import libc
 
fn main() {
    var output = "output.gz"
    var gzfile = zlib.gzopen(output.to_cstr(), "wb".to_cstr())
    if gzfile == null {
        throw errorf("failed to open gzip file")
    }
    // ...
}

import libc
 
var str = "hello"
libc.cstr ptr = str.to_cstr()  // get string address
string str2 = ptr.to_string() // cstr convert to nature string
 
// get rawptr type
rawptr<tm_t> time_ptr = &time_info
 
// get anyptr type
// any nature type (except floating point) can be converted to anyptr type
anyptr c_ptr = time_info as anyptr 

var bar = '' // stmt ending does not need to carry ; 
 
var global_v = 12 // except constant definitions, all other idents recommend lowercase underscore separation (including file names)
 
const GLOBAL_V = 12 // constants recommend uppercase underscore separation
 
if true {
    var foo = 1 // use 4 spaces for indentation
}
 
call_test(
    1,
    2, // multi-line parameters, need to add , on last line
)
 
var v = [
    1,
    2,
    3, // same as above
]
 
var m = {
    "a": 1,
    "b": 2, // same as above
}
 
type person_t:io.reader,io.writer = struct{ // no space needed between struct and {
	var f = fn() {
	
	}
	int a = 1
	int b
	bool c
}
 
var s = person_t{ // no space needed between struct ident and {
    name: "john",
    age: 18, // same as above
}
 
// 1. Function definition '{' and function declaration need to be on same line
// 2. Space needed between return parameter and ')'
// 3. Space needed between each parameter
// 4. No space needed for return value
fn test(int arg1, int arg2):int {
 
}
 
// for loop format
for int i = 0; i < 12; i += 1 {
 
}
 
// match format
match a {
	v -> {
	
	}
	_ -> {
	
	}
}