语法文档

import fmt // import 模块导入，fmt 模块是标准库的字符串格式化模块
 
fn main() { // fn 用于函数声明，main 函数作为程序的执行入口
	fmt.printf('hello %s', 'world') // 调用 fmt 模块中的 printf 函数进行格式化输出
}

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 不允许在全局作用域中声明 if 语句
}

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

int foo = 1 // v
u8 foo2 = 1 // v 字面量自动类型推导
 
float bar = 2.2 // v  
 
string car = 'hello world' // v 字符串使用单引号包裹  
string car2 = "hello world" // v 支持双引号
string car3 = `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
var baz2 = vec_new<string>('default value', 10) // 方式 2
 
{float} s = {} // v 声明空 set
var s = set_new<float>() // v 方式2
 
{string:float} m = {} // v 声明空 map
var m = map_new<string,float>() // v 方式2
 
(int,bool,bool) t = (1, true, false) // v 定义 tuple， 使用方式 t[0], t[1], t[2]
 
var (t1, t2, t3) = (1, true, 'hello') // tuple 解构声明
 
var sum = fn(int a, int b):int { // 闭包声明
	return a + b
}
 
 
var baz = [] // x, 无法推导 vec element 的类型
 
bar = null // x 不允许将 null 赋值给任何类型复合类型或者简单类型

// 方式 1 nullable
string? s = null
s = 'i am string'
 
// 方式 2
nullable<string> s2 = null 
s2 = 'hello world'
 
// 方式 3 union
type union_test = int|float|null
union_test u = null
 
// 方式 3 any
any s3 = null // any 是一种特殊类型的 union,默认包含任意类型

const PI = 3.14 // v float 类型，常量定义不能声明类型，编译器会自动进行推导
const STR = 'hello world' // v 字符串类型
const INDEX = 1 // v int 类型
const B = true // v bool 类型
 
const STR2 = STR + 'byebye' // v 常量之间折叠计算
const AREA = PI * 2 * 2 // v 计算示例，支持和常见的运算符
 
const RESULT = test() // x 常量定义只支持字面量 integer/float/string/bool 类型

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

// example: var ch = chan_new<int>()
// yield 直到 ch.recv() 收到消息唤醒当前 coroutine
for v in ch {
    println('recv v ->', v)  
}

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

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) // 调用匿名函数
}

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)

type calc_fn = fn(int,int):int  // 声明 fn 类型
  
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
 
}

// 这是返回值类型后置
func sum(a int, b int) (c int) {  
    c = a + b  
    return c  
}
 
// 这是返回值类型前置
fn sum(int a, int b):(int c) {
	c = a + b
	return c
}

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

/*
这是一个多行注释
可以跨越多行
*/
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 使用动态数组或者指针嵌套引用类型
	rawptr<node_t> next // v 通过裸指针引用
	ptr<node_t>? next // v 指针+nullable 引用
	node_t next // x 循环引用
	[node_t;2] foo // x 循环引用
	node2_t bar // x 循环引用
}
 
type nullable<T> = T|null // 自定义 union 类型 + 类型参数泛型
 
type throwable = interface{} // 接口定义，后续有详细介绍

int i = 42.5 as int  // 浮点数转整数
 
[u8] bytes = "hello" as [u8]  // 字符串转 vec
 
string str = bytes as string // vec<u8> 转换为 字符串
 
anyptr ptr = &i as anyptr  // rawptr<int> 转 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 // 自动推导转换
f64 b = 2.2 // 自动推导转换
any c = 1.1 // 无法推导，默认为 float 类型
 
i8 d = 1
i16 e = 1
i32 f = 1
any g = 1 // 无法推导，默认为 int 类型

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 {
	// 在类型扩展中使用 self 进行数据引用
    return self.length * self.width
}
 
type box<T> = struct{
	T length
	T width
}
 
// 泛型参数需要和类型声明保持一致
fn box<T>.area():T{
	return self.length * self.width
}

// 对于 string 来说这很简单, string 存储在堆中，所以可以直接进行调用
var str = 'hello world'
var c = str.find_char()
 
// 但是对于标量类型以及结构体来说，则需要使用 new 关键字将数据在堆中分配，比如
var s = new square(length=5, width=10) // s type is ptr<square>
var a = s.area() // self is ptr<square>

var s = square{}
 
// 如果 method 不会进行跨线程引用，也许我们可以通过 as 转换出一个非安全的指针欺骗编译器
(&s as anyptr as ptr<square>).area()
 
// 我们也可以使用内置的宏 @ula(unsafe load addr)，这个宏做了上面的类型转换
@ula(s).area()
 
// 如果我们希望内存安全的同时也不想调用 new 关键字进行堆分配呢？
// 那我们还能使用 @sla(safe load addr) 宏，其会触发简单的逃逸分析，将 s 默认在堆中分配。
@sla(s).area() 

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

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

type sub_t = struct{
	var name = 'alice' // 存在默认值时支持类型自动推导
}
 
type person_t = struct{
    string name = 'unnamed'
    bool active = true
 
    sub_t sub1         // 注意！此时没有默认值
    var sub2 = sub_t{} // 包含默认值
}
 
// 使用默认值初始化
// 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 不要使用匿名结构体, 虽然能够声明也无法进行初始化赋值, 仅用于内存结构转换使用
    string breed
}

string s1 = 'hello world' // 非特殊情况直接使用单引号声明字符串
string s2 = "hello world"
string s3 = `hello 
world`
 
// 使用 + 号进行字符串拼接
var 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
 
// 字符串遍历，按照 char 进行遍历
for v in s1 {
    // v 的类型为 u8，表示 ASCII 码值
    println(v)
}

// 方式 1 通过常量定义
const A = 97
const B = 99
 
u8 c = A
 
// 方式 2 通过数组引用
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')
	
	// 更多的方法可以参考标准库文档
}

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

// 声明与初始化
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> 声明
{string:int} empty = {}                // 空 map 声明方式 1
var empty = map_new<string,int>()      // 空 map 声明方式 2
 
// 插入/更新元素
m1['c'] = 3                   
 
// 获取元素值时, 如果元素不存在则会产生 panic error，需要通过 catch 拦截 panic
var v = m1['a']                
var v2 = m1['a'] catch e {
	// handle notfound
}
 
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)
}

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

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

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

[u8;3] array = [1, 2, 3] // 声明一个长度为 3，元素为 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 错误使用方式, 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 正确使用方式, 函数必须声明包含 errable(!), 使用 `!` 符号表示函数可能抛出错误
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 实现了 throwable interface, 可以调用相关 method
    println(e.msg())
    1 // catch body 的最后一行表达式具备值传递的效果，可以将 1 赋值给 result
}

try {
    var a = 1
    var b = a + 1
    rem(10, 0)
    var c = a + b
} catch e { // e 实现了 throwable interface, 可以调用相关 method
    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! 等同于 rust 中的 Result<int,err>
// int? 等同于 rust 中的 Option<int>
fn rem(int dividend, int divisor):int! {
	if divisor == 0 {
		// 等同于 return Err('xxx')
		throw errorf('divisor cannot zero')
	}
	
	// 等同于 return Ok(xxx)
	return dividend % divisor
}
 
fn main() {
	// 等同于 int result = rem(10, 0)?
	int result = rem(10, 0)
	
	/**
	等同于
	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 捕获方式与 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 的具体类型，则会在编译时触发自动类型断言
 
if foo is int {
	// auto as: foo = foo as int
    println("foo is an integer", foo + 1)
}
 
// x 无法进行自动类型推断
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 的范围小于 foo
 
type nullable2 = int|bool|null|string  
nullable2 bar2 = bar // v, nullable2 包含更大的类型范围

type measurable = interface{  
    fn area():int  
    fn perimeter():int
}
 
// 泛型参数声明
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')  
    }  
}

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 需要实现 to_str + area + update + perimeter 方法。
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  // 默认分支
}

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  // 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  // 匹配成功，返回值 msg 将赋值给 result 
        }  
        _ -> 'default'  
    }  
    println(result)  
}

// 单个类型参数
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)      // 类型自动推导
 
 
//  类型参数定义 method
type box<T> = struct {
    T value
}
 
fn box<T>.get():T {
    return self.value
}
 
// 类型参数 method 和 fn 泛型冲突，暂时无法同时使用
 
fn box<T>.get<U>():U { // x method 暂不支持泛型参数
}

// 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{
	fn bar()
}  
type test_interface2 = interface{
	fn bar()
}  
  
// 参数需要实现 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

import co // 标准库 co 包含一些协程常用函数
 
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())
        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()   //  在协程关闭状态下可以检查最近的读取或者写入操作是否成功

fn handle(chan<int> ch) {  
    for v in ch { // 编译器会自动调用 recv 并 yield 直到接收到数据
        println('recv v ->', v)  
    }  
}

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) // 读取类型 hash 值。
 
@async(delay_sum(1, 2), 0) //  创建协程
 
// 使用 ula 避免对 package struct 进行堆分配  
@ula(package).set_age(25) 
 
var a = @default(T) // 初始化默认值, 可以用于泛型中的默认值赋值

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

#linkid sleep  
fn sleep(int second)

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

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

// 基本导入，默认截取 user 作为模块 ident
import "user.n"
 
// 自定义模块关键字
import "user.n" as u
 
// 导入标准库
import fmt
 
fn main() {
    var new_user = user.create_user("alice")
    
    var another = u.create_user("bob")
    
    fmt.printf('name is %s', another.name)
}

# 基础信息
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         // 导入指定模块，也就是 rand/utils/seed.n 文件
import rand.utils.seed as s    // 自定义模块名称

[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()  // 获取字符串地址
string str2 = ptr.to_string() // cstr 转换为 nature 字符串
 
// 获取 rawptr 类型
rawptr<tm_t> time_ptr = &time_info
 
// 获取 anyptr 类型
// 任何 nature 类型(除了浮点型)都可以转换为 anyptr 类型
anyptr c_ptr = time_info as anyptr 

var bar = '' // stmt 结尾不需要携带 ; 
 
var global_v = 12 // 除了常量定义以外，其他任何 ident 都推荐小写下划线分词(包括文件名称)
 
const GLOBAL_V = 12 // 常量推荐大写下划线分词
 
if true {
    var foo = 1 // 使用 4 个空格进行缩进
}
 
call_test(
    1,
    2, // 多行参数, 需要在最后一行添加 ,
)
 
var v = [
    1,
    2,
    3, // 同上
]
 
var m = {
    "a": 1,
    "b": 2, // 同上
}
 
type person_t:io.reader,io.writer = struct{ // struct 和 { 之间不需要空格
	var f = fn() {
	
	}
	int a = 1
	int b
	bool c
}
 
var s = person_t{ // 结构体 ident 和 { 之间不需要空格
    name: "john",
    age: 18, // 同上
}
 
// 1. 函数定义 '{' 和函数声明需要在同一行
// 2. 返回参数和 ')' 之间需要空格
// 3. 每个参数之间需要空格
// 4. 返回值不需要空格
fn test(int arg1, int arg2):int {
 
}
 
// for 循环格式
for int i = 0; i < 12; i += 1 {
 
}
 
// match 格式
match a {
	v -> {
	
	}
	_ -> {
	
	}
}