标准库

RGC 标准库为开箱即用的功能提供 API 契约，包含内建核心与标准库模块，参考 Python / Rust 规划生态。

通用约定

• 类型使用 PascalCase：List、Maybe、Result
• 函数与方法使用 snake_case：read_file、push
• 模块名小写：core、io、math
• 变量默认可变，容器按 move 语义传递，借用使用 @ / @var

错误处理

• 可恢复错误返回 Result[T, Err]，不抛异常、不静默失败
• 所有可能失败的 API 在签名中体现 Result
• ? 运算符：Err 时提前返回，Ok 时取出载荷

def parse_double(s: str) -> Result[int, str] {
    n = s.to_int()?
    return Result[int, str].Ok(n * 2)
}

def main() {
    match parse_double("21") {
        case Ok(n) => print(n)             # 42
        case Err(e) => print("failed:", e)
    }
}

? 只能用于返回 Result 的函数，且错误类型必须一致；成功载荷暂支持 int / float / bool / str / None。

容器

List[T]

def main() {
    list = List[int]()
    list.push(1)
    list.push(2)
    list.clear()
    print(list.len())   # 0
}

Maybe[T] 与 Result[T, Err]

def parse_int(s: str) -> Result[int, str] {
    return s.to_int()
}

def main() {
    match parse_int("42") {
        case Ok(n) => print(n)                 # 42
        case Err(e) => print("failed:", e)
    }
}

range

range(n)、range(start, end)、range(start, end, step) 生成整数序列，仅用于 for 循环；结束值不包含，负步长递减，步长为 0 时不迭代。

def main() {
    for i in range(5) {
        print(i)          # 0 1 2 3 4
    }
    for i in range(1, 6, 2) {
        print(i)          # 1 3 5
    }
}

文件 IO

import io

def main() {
    print(write_file("/tmp/rgc.txt", "hello\n").is_ok())   # True
    print(io.append_file("/tmp/rgc.txt", "world\n").is_ok()) # True
    print(io.exists("/tmp/rgc.txt"))                       # True
    print(read_file("/tmp/rgc.txt").unwrap())
    print(io.remove_file("/tmp/rgc.txt").is_ok())          # True
}

io 按 C 字符串语义读写（内容遇 NUL 截断），二进制内容用 bytes：

import bytes

def main() {
    data = bytes.bytes_new(2)
    data.push(0)
    data.push(255)
    print(bytes.write_bytes("/tmp/rgc.bin", @data).ok)   # True
    back = bytes.read_bytes("/tmp/rgc.bin")
    print(back.ok, back.size, back.data.get(1))          # True 2 255
}

压缩与归档：gzip.compress_to_file / decompress_file 直接读写 .gz；tar.list_entries / extract / create / builder 读写 tar（ustar / GNU LongLink / PAX），两者组合可处理 .tar.gz。

import bytes
import gzip
import tar

def main() {
    b = tar.builder()
    payload = bytes.bytes_from_str("hello\n")
    b.add_file("pkg/hello.txt", @payload)
    made = b.finish()
    archive = made.data
    print(gzip.compress_to_file(@archive, "/tmp/pkg.tar.gz", 9).ok)  # True
    loaded = gzip.decompress_file("/tmp/pkg.tar.gz")
    raw = loaded.data
    l = tar.list_entries(@raw)
    print(l.ok, l.entries.len())                         # True 1
}

格式化

format(fmt, args...) 使用字面量格式串与 {} 占位符，支持 int / float / bool / str：

def main() {
    name = "RGC"
    print(format("hi {}, len = {}", name, name.len()))   # hi RGC, len = 3
}

数学

math 为内建虚拟模块；abs / min / max / sqrt / pow / floor / ceil 也可省略前缀直接调用。

import math

def main() {
    print(math.sqrt(16), math.pow(2, 10))   # 4.000000 1024.000000
    print(abs(-5), max(2, 9.5))             # 5 9.500000
}

时间与随机

time / random 同样无需源文件，import 后通过模块名调用。

import random
import time

def main() {
    start = time.now_monotonic()
    time.sleep(0.01)
    print("slept", time.now_monotonic() > start)   # slept True

    random.seed(7)                                  # 固定种子 → 可复现序列
    print("dice", random.random_int(1, 6))          # dice 4
    print("unit", random.random_float() >= 0.0)     # unit True
}

JSON

json 是 lib/json.rg 源码模块，提供解析、构造与序列化。解析结果用 JsonParse { ok, error, value } 表示。

import json

def main() {
    r = json.parse("{\"name\": \"RGC\", \"stars\": 42, \"tags\": [\"lang\", \"llvm\"]}")
    if r.ok {
        v = r.value
        tags = json.get(@v, "tags")
        print(json.as_str(json.get(@v, "name")))   # RGC
        print(json.len(@tags))                     # 2
        print(json.stringify(@v))                  # {"name":"RGC","stars":42,"tags":["lang","llvm"]}
    } else {
        print("invalid json:", r.error)
    }
}

构造示例：

import json

def main() {
    obj = json.object()
    json.set(@var obj, "id", json.int_value(7))
    xs = json.array()
    json.push(@var xs, json.str_value("a"))
    json.push(@var xs, json.str_value("b"))
    json.set(@var obj, "items", xs)
    print(json.stringify(@obj))   # {"id":7,"items":["a","b"]}
}

字符串转义支持 \" \\ \/ \b \f \n \r \t 与 \uXXXX（含 UTF-16 代理对）；原始控制字符、孤立代理项与 \u0000 会被拒绝。数字按标准 JSON 校验并限制在 i64 范围内，嵌套深度上限 256 层。

修改已有子项用 set_at / remove_at / remove；get 返回副本，修改嵌套结构时也可先构造子树再 set 挂回。

import json

def main() {
    r = json.parse("\"\\u4f60\\u597d\\ud83d\\ude00\"")
    v = r.value
    print(json.as_str(@v))            # 你好😀

    a = json.parse("[1,2,3]")
    av = a.value
    json.set_at(@var av, 1, json.int_value(20))
    ok = json.remove_at(@var av, 0)
    print(ok, json.stringify(@av))    # True [20,3]
}

字符码点

chr(cp) 把 Unicode 码点转成 UTF-8 字符串（内建，无需 import）；非法码点（负数、> 0x10FFFF、代理区）会 panic。chr(0) 返回空串（字符串以 NUL 结尾）。

def main() {
    print(chr(233))        # é
    print(chr(20320))      # 你
    print(chr(128512))     # 😀
}

正则表达式

regex 是 lib/regex.rg 源码模块，按字节匹配的回溯引擎，支持 . * + ? {m} {m,} {m,n} | ( ) (?: ) [ ] [^ ] ^ $ \d \w \s \b \B、反向引用 \1–\99 与贪婪/惰性量词（*? +? ?? {m,n}?）。search 返回 ReMatch（ok / start / end / groups，groups[0] 为整体匹配）；replace 在模式含捕获组时展开 $1 / ${1}。不支持 Unicode 字符类、lookaround 与命名组。

import regex

def main() {
    rx = regex.compile("^(ab)+c?$")
    if rx.ok {
        print(regex.is_match(@rx, "ababc"))      # True
        print(regex.is_match(@rx, "abx"))        # False
        print(regex.replace(@rx, "ababc", "-"))  # -
    } else {
        print("bad pattern:", rx.error)
    }
    rx2 = regex.compile("ab+")
    print(regex.find(@rx2, "xxabbb"))            # 2
    rx3 = regex.compile("^a{2,3}$")
    print(regex.is_match(@rx3, "aaa"))           # True
    word = regex.compile("\\bcat\\b")
    print(regex.is_match(@word, "a cat!"))       # True
    print(regex.is_match(@word, "concat"))       # False

    pair = regex.compile("(\\w+)@(\\w+)")
    m = regex.search(@pair, "user@host")
    if m.ok {
        print(m.groups.get(1), m.groups.get(2))            # user host
        print(regex.replace(@pair, "user@host", "$2:$1"))  # host:user
    }
    lazy = regex.compile("<(.+?)>")
    print(regex.search(@lazy, "<a><b>").groups.get(0))     # <a>
}

系统

import os

def main() {
    print("home_set", os.getenv("HOME").is_some())   # home_set True
    print("cwd_ok", os.getcwd().is_ok())             # cwd_ok True
    os.setenv("RGC_DEMO", "1")
    os.exit(0)
}

网络

net 是 lib/net.rg 源码模块，提供同步阻塞 TCP（IPv4/IPv6、主机名、连接/收发超时、 Unix 域）；udp（lib/udp.rg）通过 extern def 调用 libc 提供 UDP；http （lib/http.rg）实现 HTTP 客户端，原生支持 http:// 与 https://，含重定向、 keep-alive 连接池、gzip/deflate 与请求体压缩、trailer、Cookie 与代理，HTTPS 默认经 ALPN 协商 HTTP/2；http2（lib/http2.rg）提供 HTTP/2 帧层、HPACK 与流控；tls （lib/tls.rg）是纯 RGC 的 TLS 1.3 客户端（RFC 8446，不链接 OpenSSL），支持证书链/ 主机名校验、SNI、ALPN 与客户端证书（mTLS），https（lib/https.rg）是兼容层； gzip（lib/gzip.rg）为纯 RGC 的 DEFLATE/gzip/zlib 实现（CRC-32/Adler-32、多 member、 stored/fixed/dynamic 块），不依赖 zlib。TLS 所需的 SHA-2、HKDF、AES-GCM、 ChaCha20-Poly1305、X25519、P-256、RSA 与 ASN.1/X.509 均由 lib/ 下的源码模块实现， 链接期无需额外的密码库。编译器内建 tcp_* 原语直接调用 libc socket。

import net

def main() {
    l = net.listen("127.0.0.1:0")          # 端口 0：内核分配临时端口
    if not l.ok {
        print("listen failed:", l.error)
        return
    }
    listener = l.listener
    port = listener.local_port()

    c = net.connect_to("127.0.0.1", port)
    if not c.ok {
        print("connect failed:", c.error)
        return
    }
    client = c.stream
    a = listener.accept()
    if not a.ok {
        print("accept failed:", a.error)
        return
    }
    server = a.stream

    client.send("ping")
    r = server.recv(64)
    print(r.ok, r.value)                   # True ping
    server.send("pong")
    r2 = client.recv(64)
    print(r2.ok, r2.value)                 # True pong
    client.close()
    server.close()
    listener.close()
}

行为要点：

• 地址：net.connect("host:port") / net.listen("host:port")，或结构化 connect_to(host, port) / listen_on(host, port)；主机名经 getaddrinfo 解析， 支持 IPv4/IPv6（IPv6 写作 "[::1]:8080"）；端口 0 仅用于监听（临时端口）。
• 超时：connect_timeout(addr, ms) / connect_to_timeout(host, port, ms) 控制连接， TcpStream.set_timeout(ms) / TcpListener.accept_timeout(ms) 控制收发；超时错误为 timeout。
• send 阻塞直到全部字节写出，返回实际发送字节数；recv(max) 对端关闭时返回 ok=True, value=""，真实错误返回 ok=False 与 strerror 文本；二进制收发用 send_bytes / recv_bytes（Bytes）。
• Unix 域：connect_unix(path) / listen_unix(path)（抽象地址以 @ 开头）。
• 连接/监听/接收结果用 TcpConnect / TcpListen / TcpAccept / TcpRecv 包装类承载（Result 暂不支持自定义类型载荷）。
• 不会因对端提前关闭而收到 SIGPIPE（内部使用 MSG_NOSIGNAL）。

UDP

import udp

def main() {
    b = udp.open("127.0.0.1:0")            # 端口 0：内核分配临时端口
    if not b.ok {
        print("bind failed:", b.error)
        return
    }
    s = b.sock
    s.send_to("ping", "127.0.0.1", s.local_port())
    r = s.recv_from(1024)
    print(r.ok, r.data, r.host, r.port)    # True ping 127.0.0.1 <port>
    s.close()
}

udp.open("host:port") / open_on(host, port) 绑定本地地址（IPv4/IPv6/主机名） ；send_to(data, host, port) / send_bytes(data, host, port) 发送一个数据报， recv_from(max) 阻塞接收一个数据报（UdpRecv{ok,error,data,data_bytes,host,port}）； 保留数据报边界，空数据报返回 ok=True, data=""，超出 max 的部分被截断。 data 按 C 字符串处理（strlen 语义，遇 NUL 截断），二进制内容用 data_bytes。 set_timeout(ms) 设置收发超时，超时返回 ok=False, error="timeout"。

HTTP 客户端分为模块级一次性函数与可配置的 HttpClient：

import http

def main() {
    r = http.get("https://example.com/")          # http:// 与 https:// 均支持
    if not r.ok {
        print("request failed:", r.error)
        return
    }
    res = r.response
    print(res.status)                             # 200
    print(res.version, res.url)
    print(http.header(@res, "Content-Type"))
    print(res.body.len(), res.body_bytes.len)     # 二进制正文用 body_bytes

    p = http.post("http://127.0.0.1:8080/echo", "hello")
    print(p.ok, p.response.status)

    # 连接复用 + 自定义头 + Cookie + 代理
    c = http.new_client()
    c.headers.push("X-Token: secret")
    c.set_proxy("http://127.0.0.1:3128")
    a = c.get("http://service.invalid/a")
    b = c.get("http://service.invalid/b")         # 复用同一 keep-alive 连接
    c.close()
}

HttpResponse 字段为 status / version / headers: List[str] / trailers: List[str] / body: str / body_bytes: Bytes / url: str；http.header(res, name) 大小写不敏感， 未找到返回空串（@ 只作用于变量，需先 res = r.response）；chunked trailer 用 http.trailer(res, name) 查询。

HttpClient 默认：timeout_ms=30000、connect_timeout_ms=10000、max_redirects=10、 max_body=32 MiB、max_header=64 KiB、max_idle=8、verify_tls=True、http2=True、 keep_alive=True、follow_redirects=True、compress_request=False。支持：

• 任意方法：get / post / request / get_with / post_with / request_with / request_bytes（二进制请求体）；
• 重定向：301/302/303 将非 GET/HEAD 改为 GET，307/308 保留方法与正文，跨主机去掉 Authorization 与 Host，相对 Location 按 RFC 3986 合并；
• keep-alive 连接池、gzip/deflate 自动解压、trailer 暴露、Cookie 罐 （Domain/Path/Secure/Max-Age）、1xx 跳过、HEAD/204/304 无正文；
• 请求体压缩（compress_request=True 时 gzip 并发送 Content-Encoding: gzip）；
• HTTP 代理（明文 absolute-form、HTTPS CONNECT 隧道 + Proxy-Authorization）；
• 客户端证书：client_cert / client_key 或 set_client_cert(cert, key)；
• 限额（response body too large / response header too large）与超时（timeout）；
• 查询串：http.encode_query(pairs) / http.decode_query(q)、url_encode / url_decode；
• 异步：http.get_async / post_async / request_async 返回 Task[HttpResult]， 一任务一线程，可配合 asyncio.gather / asyncio.wait_any 并发多个请求。

HTTP/2

HTTPS 请求默认在 ALPN 中提供 h2，服务端选中时自动走 HTTP/2（res.version == "HTTP/2"， trailer 仍写入 res.trailers），否则回退 HTTP/1.1；c.http2 = False 可关闭协商。 HTTP/2 仅支持 TLS（不支持 h2c），不支持服务端推送。HttpClient 按请求顺序复用连接； 需要在单连接上并发多个 GET 时直接使用低层 http2.get_many（遵守服务端 MAX_CONCURRENT_STREAMS，单流失败互不影响）。

import http

def main() {
    c = http.new_client()
    r = c.get("https://example.com/")
    if r.ok {
        print(r.response.version)             # HTTP/2 或 HTTP/1.1
        print(r.response.status)
    }
    c.close()
}

需要自行管理连接或使用 HPACK/帧编解码时直接 import http2：

import http2

def main() {
    c = http2.connect("example.com", 443, 10000, True, "", "", "")
    if not c.ok {
        print("connect failed:", c.error)
        return
    }
    hs = List[str]()
    hs.push("user-agent: rgc-demo")
    conn = c.conn
    r = http2.request(conn, "GET", "https", "example.com", "/", hs,
                      "", 0, False, 65536, 33554432)
    if r.ok {
        print(r.status, r.body.len)           # 200 <字节数>
    }

    # 并发多路复用（仅 GET），响应顺序与 paths 一致
    paths = List[str]()
    paths.push("/a")
    paths.push("/b")
    rs = http2.get_many(conn, "https", "example.com", paths, hs, 65536, 1048576)
    if rs.ok {
        i = 0
        while i < rs.responses.len() {
            one = rs.responses.get(i)
            print(i, one.ok, one.status, one.body.len)
            i = i + 1
        }
    }
    conn.close()
}

低层 API：http2.connect / attach / request / get_many、encode_request_headers / encode_response_headers / encode_trailers、new_decoder / decode_block、 encode_frame。实现覆盖 SETTINGS/PING/WINDOW_UPDATE/GOAWAY/RST_STREAM、 HEADERS/CONTINUATION/DATA、HPACK（静态表 + 动态表 + Huffman 解码）与连接/流双流控； get_many 按流分发响应、逐流限额与取消。

HTTPS / TLS

http 已原生支持 https://（TLS 由 lib/tls.rg 提供）；https 模块是兼容层， https.get / https.post 直接调用 http，get_insecure / post_insecure 关闭证书校验。

import http
import https
import tls

def main() {
    r = https.get("https://example.com/")
    if r.ok {
        print(r.response.status)                       # 200
        print(http.header(@r.response, "Content-Type"))
    } else {
        print("request failed:", r.error)              # 证书/网络错误
    }

    # 自签名 / 本地测试：跳过证书校验
    local = https.get_insecure("https://127.0.0.1:8443/")
    print(local.ok)

    # 低层 TLS
    c = tls.connect("example.com", 443, 10000, True)
    if c.ok {
        s = c.conn
        s.send("GET / HTTP/1.1\r\nHost: example.com\r\n\r\n")
        print(s.recv(4096).value)
        s.close()
    }
}

https.get / https.post 校验证书链与主机名（DNS 名发 SNI，IP 字面量按 IP 校验）， 失败返回证书错误原因；get_insecure / post_insecure 跳过校验。 底层 tls.connect(host, port, timeout_ms, verify) 返回 TlsResult{ok,error,conn}， TlsConn 提供 send / recv / recv_bytes / get_version / close； tls.connect_with_ca 可指定 PEM CA 文件，tls.connect_mtls / connect_on_mtls 携带客户端证书（cert_file / key_file，key_file 为空时复用证书文件）。 tls.connect_alpn / connect_on_alpn 在握手时提供 ALPN，TlsConn.get_alpn() 读取 协商结果（h2 / http/1.1）。 HttpClient 通过 client_cert / client_key / set_client_cert 启用 mTLS。 系统 CA 可用 SSL_CERT_FILE / SSL_CERT_DIR 覆盖。https 模块仅接受 https://（默认端口 443）。

未实现：TLS 会话恢复参数暴露、异步流式客户端（await 尚未接入事件循环，见「事件循环」）。 HTTP/2 并发多路复用由 http2.get_many 提供（仅 GET）。

异步

async def 函数在调用时立即派生一个线程并返回 Task[T]；await 等待任务完成并 取回结果，只能在 async 函数内使用；asyncio.run(task) 在普通函数中同步等待； asyncio.gather(tasks) 等待一组任务并按顺序收集结果；asyncio.wait_any(tasks) 返回首个已完成任务的下标（空列表为 -1，不消费任务）；task.done() 查询任务是否已完成； task.wait(ms) 最多等待给定毫秒数，超时返回 False 且不消费任务；task.cancel() 发起协作式取消，任务内用 asyncio.cancelled() 轮询。

import asyncio
import time

async def add_async(a: int, b: int) -> int {
    time.sleep(0.02)
    return a + b
}

async def slow() -> int {
    time.sleep(0.25)
    return 1
}

async def cancellable() -> int {
    i = 0
    while i < 100 {
        if asyncio.cancelled() {
            return -1
        }
        time.sleep(0.01)
        i = i + 1
    }
    return 0
}

async def driver() {
    t = add_async(40, 2)
    print(await t)                        # 42

    a = slow()
    b = slow()
    print((await a) + (await b))          # 2，总耗时约 0.25s

    tasks = List[Task[int]]()
    tasks.push(add_async(1, 2))
    tasks.push(add_async(3, 4))
    print(await tasks.get(0), await tasks.get(1))   # 3 4

    ts = List[Task[int]]()
    ts.push(slow())
    ts.push(slow())
    print(ts.get(0).done())               # 多半为 False
    vals = await asyncio.gather(ts)       # 并行等待，结果按入参顺序
    print(vals.len())                     # 2

    wa = List[Task[int]]()
    fa = cancellable()                    # 慢任务，支持取消
    fb = add_async(1, 2)                  # 快任务
    wa.push(fa)
    wa.push(fb)
    idx = asyncio.wait_any(wa)            # 1：快任务先完成，不消费任务
    print(idx, await wa.get(idx))         # 1 3
    fa.cancel()                           # 其余任务可协作取消
    print(await fa)                       # -1

    w = slow()
    print(w.wait(100))                    # False：100ms 内未完成
    print(w.wait(1000))                   # True：已等够
    print(await w)                        # 1：wait 不消费任务

    c = cancellable()
    print(c.cancel())                     # True：记录取消请求
    print(c.cancelled())                  # True
    print(await c)                        # -1：任务在检查点退出
}

def main() {
    asyncio.run(driver())
    print(asyncio.run(add_async(20, 22)))           # 42
}

行为要点：

• Task[T] 是内建泛型类（字段 handle），只能由 async 调用产生，不能直接构造。
• await / asyncio.gather 消费任务：同一个 Task 变量只能等待一次；丢弃未等待的 任务会泄漏其结果盒（进程退出由 OS 回收）。
• asyncio.gather 接受 List[Task[T]] 变量（调用后该列表被消费），返回 Task[List[T]]，可再 await 或交给 asyncio.run；空列表返回空列表。
• asyncio.wait_any 接受 List[Task[T]]，轮询完成标志并返回首个已完成任务的下标 （按列表顺序；全部未完成时约每 1ms 重试），空列表返回 -1；不消费任务，之后仍可 await 对应任务、cancel 其余任务或再次 wait_any。
• task.done() 原子读取完成标志，不阻塞；await 之后任务变量已被消费，不能再查询。
• task.wait(ms) 轮询完成标志，任务完成返回 True，超时返回 False（ms <= 0 只查 一次）；不消费任务，之后仍可 await；只放弃等待，不取消或中断任务。
• task.cancel() 协作式记录取消请求，返回是否首次记录（已完成或重复请求返回 False）；不终止线程、不消费任务。task.cancelled() 查询请求标志， asyncio.cancelled() 查询当前任务（任务外恒为 False）；任务需自行轮询并在安全点 返回，忽略请求的任务会照常跑完（与 Go / C# 的协作模型一致）。
• 载荷支持标量、str 与自定义类；嵌套 await、Task[int] 注解与 List[Task[int]] 均可用。
• 限制：不支持 async def main、async 方法、借用参数/返回值；取消是协作式的；超时用 wait 轮询；一任务一线程，任务数受线程数限制；List / Map 跨线程写入需自行同步。 事件循环由独立的 event 模块提供（见下节），与 await 尚未打通。

实现：一任务一线程（pthread），用户程序以 -lpthread 链接。

事件循环（event）

event 是基于 Linux epoll 的单线程 selector：定时器用 timerfd，跨线程唤醒用 socketpair，全部通过 extern def 调用 libc。它不与线程池版 async 绑定，适合同时 等待大量 fd。

import event
import net

def main() {
    loop = event.new_loop()
    if not loop.is_open() {
        print(loop.error)
        return
    }

    l = net.listen_on("127.0.0.1", 8080)
    listener = l.listener
    listener.set_nonblocking(True)
    loop.add(listener.fd, 1, event.ev_in())

    while True {
        w = loop.wait(-1)              # <0 无限等待，0 只轮询一次
        i = 0
        while i < w.events.len() {
            e = w.events.get(i)
            if e.token == 1 {
                a = listener.try_accept()
                if a.ok and not a.again {
                    s = a.stream
                    s.set_nonblocking(True)
                    # 注册读写事件并处理请求
                }
            }
            i = i + 1
        }
    }
}

• event.new_loop() 创建 epoll 与唤醒通道；add(fd, token, events) / modify / remove 管理注册，events 用 ev_in() / ev_out() / ev_err() / ev_hup() / ev_rdhup() / ev_edge() 按位组合（|）。wait(timeout_ms) 每次最多返回 64 个 Event{token, events}，内核事件只带 token，调用方用 token 找回状态。
• 定时器：add_timer(token, delay_ms) 单次、add_interval(token, interval_ms) 周期、 cancel_timer(token) 取消、timer_count() 计数；到期事件带 ev_timeout()。
• 唤醒：loop.post(token) 同线程、event.post_fd(loop.wake_w, token) 跨线程； wait 返回 ev_wake() + token。
• 非阻塞 IO：配合 net.connect_start / connect_finish、TcpListener.try_accept、 TcpStream.try_recv / try_send 与 udp.UdpSocket.try_recv_from / try_send_to 使用；again=True 表示 EAGAIN，与真正的错误区分。
• 限制：Linux 专用；单次 wait 最多 64 个事件；token 取值 0..2^62-1 且同一 loop 内唯一；控制操作应在执行 wait 的线程调用（post / post_fd 可跨线程）。

模块总览

模块/分类	内容
core	内建类型、基本操作、to_string、chr、format
io	输入输出、文件读写/追加/存在性/删除、打印
math	abs / min / max / sqrt / pow / floor / ceil
time	now_monotonic / now / sleep
random	seed / random_int / random_float
os	exit / getenv / setenv / getcwd / system
json	parse / stringify / 构造 / 访问 / 修改
regex	compile / is_match / find / search / replace
bytes	二进制缓冲区（bytes_new / bytes_from_str / push / get / slice / append ...）与二进制安全文件读写（read_bytes / write_bytes）
net	TCP：同步 connect / connect_to / connect_timeout / listen / listen_on / resolve / connect_unix / listen_unix、TcpStream / TcpListener（IPv4/IPv6、超时、二进制）；非阻塞 connect_start / connect_finish、try_accept / try_recv / try_send / set_nonblocking
udp	UDP：同步 open / open_on、UdpSocket.send_to / send_bytes / recv_from / set_timeout / local_port / close；非阻塞 try_recv_from / try_send_to / set_nonblocking（IPv4/IPv6、二进制）
http	HTTP 客户端（含 HTTPS，默认协商 HTTP/2）：get / post / request / request_bytes、HttpClient（重定向、keep-alive、gzip/请求压缩、trailer、Cookie、代理、mTLS、限额、超时、http2 开关）
http2	HTTP/2（TLS ALPN）：connect / attach / request / get_many（并发多路复用 GET）、HPACK 编解码（new_decoder / decode_block / encode_*）、encode_frame；流控与 trailer
https / tls	https 为 http 兼容层（get / post / get_insecure / post_insecure）；tls.connect / connect_mtls / connect_alpn、TlsConn（纯 RGC TLS 1.3，含客户端证书与 ALPN）
密码学	纯 RGC：sha2（SHA-256/384/512）、hmac、hkdf、aes（AES-128/256-GCM）、chacha20poly1305、x25519、p256（P-256/P-384 ECDH/ECDSA）、rsa（PKCS#1 v1.5/PSS）、bigint、entropy；ASN.1/X.509：asn1、pkey、x509（证书链校验与系统 CA）
gzip	gzip 压缩/解压：compress / decompress / decompress_limit / decompress_mem / is_gzip / is_zlib（纯 RGC DEFLATE，stored/fixed/dynamic，多 member）；文件级 compress_to_file / decompress_file / decompress_file_limit
tar	tar 归档：list_entries / extract / create / builder（ustar、GNU LongLink、PAX；.tar.gz 配合 gzip）
asyncio	异步：async def / await / asyncio.run / asyncio.gather / asyncio.wait_any / asyncio.cancelled / Task.done / Task.wait / Task.cancel、Task[T]（pthread）
event	事件循环：new_loop / add / modify / remove / wait / add_timer / add_interval / cancel_timer / post / post_fd / close（epoll + timerfd + socketpair）
string	trim / find / replace / to_upper / to_lower / pad_left
list	sum_ints / min_int / max_int / sort_ints / sort_strs / join_ints
path	路径判断 / 拼接 / 取目录与文件名
错误处理	Result[T, Err]、? 传播、match 处理
序列	range(n) / range(start, end[, step])
工具	字符串处理、集合操作

错误处理原则

• 可恢复错误一律返回 Result，禁止静默失败。
• 程序员错误（如越界索引）直接终止并输出诊断信息。