Rex 编程语言语法参考（二）：库语法

fn main() {
    // 基础：绝对值 / 取整
    print(math.abs_int(-5))            // 5
    print(math.floor(3.7))             // 3
    print(math.ceil(3.2))              // 4
    print(math.round(3.5))             // 4

    // 幂运算与对数
    print(math.sqrt(16.0))             // 4.0
    print(math.pow(2.0, 10.0))         // 1024.0
    print(math.log(math.e()))          // 1.0

    // 比较与限制
    print(math.max(1.0, 5.0))          // 5.0
    print(math.clamp(7.0, 0.0, 5.0))   // 5.0

    // 整数运算
    print(math.factorial(5))           // 120
    print(math.gcd(12, 18))            // 6
    print(math.pi())                   // 3.141592653589793
}

fn build_json() -> str {
    let b: int = string.builder_create()
    defer string.builder_free(b)      // defer 保证释放
    string.builder_append(b, "{\"items\": [")
    var i: int = 0
    while i < 10000 {
        string.builder_append(b, string.from_int(i))
        string.builder_append(b, ",")
        i = i + 1
    }
    string.builder_append(b, "]}")
    return string.builder_tostr(b)    // 仅此处分配一次，O(n)
}

fn main() {
    // 大小写与去除空白
    print(string.upper("hello"))          // HELLO
    print(string.lower("WORLD"))          // world
    print(string.strip("  hi  "))         // hi

    // 截取 / 替换 / 重复
    print(string.substr("hello", 1, 3))   // ell
    print(string.replace("a-b-c", "-", "+")) // a+b+c
    print(string.repeat("ab", 3))         // ababab

    // 查找与判断（返回 1/0）
    print(string.find("hello", "ll"))     // 2
    print(string.contains("hello", "ell")) // 1
    print(string.startswith("hello", "he")) // 1

    // 类型转换
    print(string.toint("42") + 1)         // 43
    print(string.from_int(7))             // 7
    print(string.from_float(3.5))         // 3.5
}

fn main() {
    io.write_line("请输入你的名字:")
    let name: str = io.read_line()
    io.write("你好, ")
    io.write_line(name)                        // 输出到标准输出

    io.write_line("请输入一个整数:")
    let n: int = io.read_int()
    io.write_line(string.concat("n * 2 = ", string.from_int(n * 2)))

    io.error_line("这是一条错误信息")            // 写入标准错误
}

fn main() {
    // 写入 / 读取
    file.write("data.txt", "hello rex")
    print(file.exists("data.txt"))            // 1
    print(file.read("data.txt"))              // hello rex

    // 追加与信息
    file.append("data.txt", "\nline2")
    print(file.size("data.txt"))              // 字节数（含换行）
    print(file.is_file("data.txt"))           // 1

    // 文件操作
    file.rename("data.txt", "data2.txt")
    file.delete("data2.txt")

    // 目录操作
    file.mkdir("mydir")
    print(file.is_dir("mydir"))               // 1
    file.rmdir("mydir")

    // 路径操作
    print(file.basename("a/b/c.txt"))         // c.txt
    print(file.extname("a/b/c.txt"))          // .txt
}

fn main() {
    // 环境变量
    os.setenv("MY_VAR", "123")
    print(os.getenv("MY_VAR"))               // 123

    // 系统信息
    print(os.get_platform())                 // 例如 win32
    print(os.get_cpu_count())                // 例如 8
    print(os.get_pid())                      // 当前进程 ID

    // 执行系统命令
    let out: str = os.exec_output("echo hello")
    print(out)                               // hello
}

fn main() {
    random.seed(42)                          // 固定种子，结果可复现
    print(random.random())                   // [0.0, 1.0) 随机浮点
    print(random.int(100))                   // [0, 100) 随机整数
    print(random.range(10, 20))              // [10, 20) 随机整数
    print(random.int_range(1, 6))            // [1, 6]，掷骰子
    print(random.uniform(0.0, 1.0))          // [0.0, 1.0) 均匀浮点
}

fn main() {
    // 创建日期（内部为 Unix 时间戳，秒）
    let d: int = datetime.from_ymd(2025, 7, 29)
    print(datetime.get_year(d))              // 2025
    print(datetime.get_month(d))             // 7
    print(datetime.get_day(d))               // 29
    print(datetime.get_weekday(d))           // 2（2025-07-29 是周二）

    // 日期运算
    let next: int = datetime.add_days(d, 7)
    print(datetime.diff_days(next, d))       // 7

    // 判断与边界
    print(datetime.is_weekend(d))            // 0（周二）
    print(datetime.is_leap_year_for(2024))   // 1
    print(datetime.days_in_month(2024, 2))   // 29（闰年 2 月）
    print(datetime.get_quarter(d))           // 3（第三季度）
}

fn main() {
    var arr: int[] = [64, 34, 25, 12, 22, 11]

    // 原地排序（升序），结果写回原数组
    collections.sort_int(arr, 6)
    print(arr[0])                            // 11（最小值）
    print(arr[5])                            // 64（最大值）

    // 查找与统计
    print(collections.find_int(arr, 6, 25))  // 2
    print(collections.min_int(arr, 6))       // 11
    print(collections.max_int(arr, 6))       // 64
    print(collections.sum_int(arr, 6))       // 168
}

fn main() {
    let start: int = time.now()              // 毫秒时间戳
    print(time.year())                       // 当前年份
    print(time.hour())                       // 当前小时
    print(time.format_datetime())            // 如 2026-08-05 14:30:00
    time.sleep(100)                          // 休眠 100 毫秒
    print(time.elapsed(start))               // >= 100
}

fn worker(a: int, b: int) -> int {
    return a * 1000 + b
}

fn float_worker(x: float) -> float {
    return x * 2.5
}

fn main() {
    let h1: int = thread.spawn(worker, 1, 2)
    let r1: int = thread.join(h1)   // 1002

    // 多线程并行
    let ha: int = thread.spawn(worker, 1, 1)
    let hb: int = thread.spawn(worker, 2, 2)
    let total: int = thread.join(ha) + thread.join(hb)  // 3003

    // float 返回值用 join_float
    let hf: int = thread.spawn(float_worker, 3.5)
    let rf: float = thread.join_float(hf)   // 8.75

    // 线程内休眠（必须 join，见下方注意事项）
    let hs: int = thread.spawn(worker, 9, 9)
    thread.sleep(100)
    thread.join(hs)
}

let mid: int = thread.mutex_create()
let h1: int = thread.spawn(mutex_worker, mid)
let h2: int = thread.spawn(mutex_worker, mid)
thread.join(h1)
thread.join(h2)
thread.mutex_destroy(mid)

fn counter_worker(n: int, counter: ptr) -> int {
    var i: int = 0
    while i < n {
        thread.atomic_add(counter, 1)
        i = i + 1
    }
    return 0
}

let counter: ptr = thread.counter_create()
let h1: int = thread.spawn(counter_worker, 1000, counter)
let h2: int = thread.spawn(counter_worker, 1000, counter)
let h3: int = thread.spawn(counter_worker, 1000, counter)
thread.join(h1)
thread.join(h2)
thread.join(h3)
print(thread.atomic_get(counter))   // 3000
thread.counter_free(counter)

re.match("Hello", "Hello World")               // 1
re.match("World", "Hello World")               // 0（match 只从头匹配）
re.search("World", "Hello World")              // 1
re.fullmatch("Hello World", "Hello World")     // 1
re.fullmatch("Hello", "Hello World")           // 0

re.find("\\d+", "abc123def456")      // "123"
re.findall("\\d+", "a1b22c333")      // "1\n22\n333"
re.replace("\\d+", "#", "a1b22c333") // "a#b#c#"
re.split("[,\\s]+", "a, b,c  d")     // "a\nb\nc\nd"

re.escape("a.b+c")   // "a\.b\+c"
re.is_valid("\\d+")  // 1
re.is_valid("[")     // 0

// 读取 cJSON 节点（C 结构体）的 type 字段：next=0, prev=8, child=16, type=24
let root: ptr = json_parse(text)
let type_field: int = mem.read_i32(root, 24)

// 读取字符串节点的 valuestring（char* 指针，偏移 32）
let name_node: ptr = json_get(root, "name")
let name_ptr: int = mem.read_i64(name_node, 32)   // char* 地址
let name_val: str = mem.read_str(name_ptr as ptr)  // 读取 C 字符串

var m: Map[str, int] = {}
map.set(m, "a", 1)
map.set(m, "b", 2)
if map.has(m, "a") {
    print(map.get(m, "a"))   // 1
}
print(map.len(m))            // 2
map.free(m)

var s: Set[int] = set.create()
set.add(s, 10)
if set.has(s, 10) {
    print(set.len(s))   // 1
}
set.free(s)

// 必须整模块导入！
// selective import（如 import json_parse from "lib/json.rex"）会过滤掉 extern 声明，导致链接失败
import "lib/json.rex"
import "lib/http.rex"

import "lib/json.rex"

fn main() {
    // 解析
    let root: ptr = json_parse("{\"name\": \"Rex\", \"age\": 30, \"tags\": [\"a\", \"b\"]}")
    if root == null {
        print("解析失败:", json_error())
        return
    }
    print(json_string(json_get(root, "name")))       // Rex
    print(json_number(json_get(root, "age")) as int) // 30

    // 遍历数组
    let tags: ptr = json_get(root, "tags")
    for i in range(0, json_size(tags)) {
        print(json_string(json_get_at(tags, i)))
    }

    // 构建
    let obj: ptr = json_obj()
    json_add_obj(obj, "id", json_num(1.0))
    json_add_obj(obj, "ok", json_bool(1))
    print(json_print_min(obj))                        // {"id":1,"ok":true}

    json_free(root)
    json_free(obj)
}

import "lib/http.rex"
import "lib/json.rex"

fn main() {
    // GET + JSON 解析
    let body: str = http_get("https://httpbin.org/get", 10000)
    let root: ptr = json_parse(body)
    if root != null {
        print(json_string(json_get(root, "url")))
        json_free(root)
    }

    // POST JSON
    let resp: str = http_post("https://httpbin.org/post",
                              "{\"hello\": \"world\"}",
                              "application/json", 10000)
    print("status =", http_status())

    // 错误处理
    try {
        http_get("http://127.0.0.1:9/", 2000)
    } catch err {
        print("请求失败:", err)
    }
}

import "lib/crypto.rex"

fn main() {
    // 哈希摘要（API 签名常用）
    print(crypto_sha256("hello"))            // 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824

    // HMAC 签名
    print(crypto_hmac_sha256("secret", "message"))

    // AES-256-CBC 加解密（密钥/IV 为 hex）
    let key: str = "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"
    let iv: str  = "101112131415161718191a1b1c1d1e1f"
    let cipher: str = crypto_aes_encrypt_cbc_256(key, iv, "Hello, Rex!")
    print("密文:", cipher)                     // Base64
    print("明文:", crypto_aes_decrypt_cbc_256(key, iv, cipher))

    // Base64 / Hex 编码
    print(crypto_base64_encode("Hello"))       // SGVsbG8=
    print(crypto_base64_decode("SGVsbG8="))    // Hello
    print(crypto_hex_encode("AB"))             // 4142
    print(crypto_hex_decode("4142"))           // AB
}

// 标准库函数内置，直接以命名空间调用，无需 import、无需 extern
fn main() {
    let pi: float = math.pi()
    print("π =", pi)
    print("sin(π/2) =", math.sin(pi / 2.0))
    print("cos(0) =", math.cos(0.0))
}

fn main() {
    let path: str = "test.txt"
    if file.exists(path) == 1 {
        let content: str = file.read(path)
        print("Content:", content)
    }
}

fn main() {
    random.seed(42)
    for i in range(0, 5) {
        print("Random:", random.int(100))
    }
}