Uya 编程语言

// 结构体定义
struct Vec3 {
  x: f32,
  y: f32,
  z: f32
}

// 函数定义
fn add(a: i32, b: i32) i32 {
  return a + b;
}

// 错误处理（支持预定义和运行时错误）
error DivisionByZero;  // 预定义错误（可选）

fn safe_divide(a: i32, b: i32) !i32 {
    if b == 0 {
        return error.DivisionByZero;  // 预定义错误
    }
    if a < 0 {
        return error.NegativeInput;   // 运行时错误，无需预定义
    }
    return a / b;
}

// 原子操作
struct Counter {
  value: atomic i32
}

fn increment(counter: *Counter) void {
  counter.value += 1;  // 自动原子 fetch_add
}

// 接口
interface IWriter {
  fn write(self: *Self, buf: *byte, len: i32) i32;
}

// FFI 调用
extern i32 printf(byte* fmt, ...);

// 泛型函数（可选特性）
fn id(x: T) T {
  return x;
}

// 显式宏（可选特性）
mc twice(n: i32) expr { n + n }

// 模块系统（v1.4）
// project/main.uya (main 模块)
export fn helper_func() i32 {
    return 42;
}

// project/std/io/file.uya (std.io 模块)
use main.helper_func;  // 导入 main 模块的函数

export struct File {
    fd: i32
}

export fn open_file(path: byte*) !File {
    let value: i32 = helper_func();  // 使用导入的函数
    return File{ fd: 1 };
}

// 数组切片操作
fn slice_example() void {
  const arr: [i32; 10] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

  // 基本切片：slice(arr, start, len) 返回从索引start开始，长度为len的元素
  const slice1: [i32; 3] = slice(arr, 2, 3);  // [2, 3, 4]

  // 操作符语法：arr[start:len] 等价于 slice(arr, start, len)
  const slice1b: [i32; 3] = arr[2:3];  // [2, 3, 4]，从索引2开始，长度为3

  // start 支持负数索引：-1表示最后一个元素，-2表示倒数第二个元素，以此类推
  // 负数索引从数组末尾开始计算：-n 转换为 len(arr) - n
  const slice2: [i32; 3] = slice(arr, -3, 3);  // [7, 8, 9]，从倒数第3个开始，长度为3
  const slice2b: [i32; 1] = slice(arr, -1, 1);  // [9]，从最后一个元素开始，长度为1

  // 操作符语法的负数索引
  const slice2c: [i32; 3] = arr[-3:3];  // [7, 8, 9]，从倒数第3个开始，长度为3

  // 从某个索引开始
  const slice3: [i32; 3] = slice(arr, 7, 3);   // [7, 8, 9]

  // 从开头开始
  const slice4: [i32; 3] = slice(arr, 0, 3);    // [0, 1, 2]
}

// 安全指针算术操作
fn pointer_arith_example() void {
  const arr: [i32; 10] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
  const ptr: &i32 = &arr[0];  // 指向数组首元素的指针

  // 指针算术：ptr + offset，编译器验证边界安全
  const offset_ptr: &i32 = ptr + 5;  // 指向第6个元素
  if offset_ptr < &arr[10] {       // 边界检查
    const val: i32 = *offset_ptr;    // 安全解引用
    printf("Value at offset 5: %d\n", val);
  }

  // 循环中的指针算术
  for i: i32 = 0; i < 10; i += 1 {
    const current_ptr: &i32 = ptr + i;  // 编译器证明 i < 10，安全
    printf("arr[%d] = %d\n", i, *current_ptr);
  }
}

fn main() i32 {
  printf("Hello, Uya!\n");

  // 使用泛型
  const x: i32 = id(42);

  // 使用宏
  const y: i32 = twice(5);  // 编译期展开为 5 + 5

  // 使用切片
  slice_example();

  // 使用指针算术
  pointer_arith_example();

  return 0;
}

struct Counter {
  value: atomic i32
}

fn increment(counter: *Counter) void {
  counter.value += 1;  // 自动原子 fetch_add
  const v: i32 = counter.value;  // 自动原子 load
  counter.value = 10;  // 自动原子 store
}