CatBase

# Python - 缩进问题示例
def main():
    if True:
        print("Hello")  # 如果缩进少一个空格，可能导致语法错误
    else:
        print("World")

# CatBase - 大括号代码块
def main(args:list[str]) {
    if True {
        print("Hello")  # 大括号明确定义代码块范围
    } else {
        print("World")
    }
}

# Python - 变量类型不明确
name = "Tom"          # 字符串
age = 25              # 整数
items = [1, 2, 3]    # 列表
# 程序员需要阅读代码才能推断变量类型

# CatBase - 变量类型明确
name:str = "Tom"           # 字符串类型
age:int = 25               # 整数类型
items:list[int] = [1, 2, 3]  # 整数列表类型
# 变量类型一目了然，提高代码可读性

#include <stdio.h>
int main() {
    printf("Hello, World!\n");
    return 0;
}

print("Hello, World!")

def main(args:list[str]) {
    print("Hello, World!")
}

#include <stdio.h>
#include <stdlib.h>

int main() {
    FILE *fp = fopen("test.txt", "r");
    if (fp == NULL) {
        printf("Cannot open file\n");
        return 1;
    }
    
    char buffer[1024];
    while (fgets(buffer, sizeof(buffer), fp) != NULL) {
        printf("%s", buffer);
    }
    
    fclose(fp);
    return 0;
}

with open("test.txt", "r") as f:
    print(f.read())

def main(args:list[str]) {
    f:File = file("test.txt", "r")
    content:str = f.read()
    f.close()
    print(content)
}

def main(args:list[str]) {
    print("Hello, World!")
}

Hello, World!

# 编译源文件
catcc source.cat

# 编译并运行
catcc source.cat && ./source

# 或者
catcc run source.cat

$ catcc -v
CatBase Compiler (catcc) 0.0.11

# 1. 人工查版本
catcc -v
# → CatBase Compiler (catcc) 0.0.11

# 2. 在 shell 脚本中检测版本
if [[ "$(catcc -v)" != *"0.0.11"* ]]; then
    echo "需要 catcc 0.0.11 或更高版本"
    exit 1
fi

# 3. 在 CI 中断言最低版本
REQUIRED="CatBase Compiler (catcc) 0.0.11"
if [[ "$(catcc --version)" != "$REQUIRED" ]]; then
    echo "CatBase 版本不匹配，要求 $REQUIRED"
    exit 1
fi

# 编译时不生成 .o 文件
catcc -no-emit-obj source.cat

# 生成共享库
catcc -shared mylib.cat

# 静态链接（适合极小资源环境，如嵌入式系统）
catcc -static source.cat

# 生成最小体积的可执行文件
catcc -O ReleaseSmall source.cat

# 安全优先（带运行时检查）
catcc -O ReleaseSafe source.cat

# 指定输出文件名
catcc -o myprogram source.cat

# 生成极小体积的静态链接可执行文件（约 13 KB）
catcc -static -O ReleaseSmall source.cat

import "./libmysqlclient.so"

def main(args:list[str]) {
    # 连接数据库...
}

catcc -static source.cat

Warning: -static is incompatible with .so import, ignoring static linking

# 动态链接（默认）
catcc source.cat
# 生成的 source 依赖: libc.so, libm.so 等

# 静态链接
catcc -static source.cat
# 生成的 source 不依赖任何动态库

# 查看可执行文件的动态库依赖
ldd ./source

# 静态链接后的可执行文件
ldd ./source
# 输出: "not a dynamic executable"

catbase/
├── package.json
├── language-configuration.json
└── syntaxes/
    └── catbase.tmLanguage

{
  "name": "catbase-language",
  "displayName": "CatBase Language",
  "description": "CatBase programming language support for VS Code",
  "version": "1.0.0",
  "publisher": "catbase",
  "engines": {
    "vscode": "^1.60.0"
  },
  "categories": [
    "Programming Languages"
  ],
  "contributes": {
    "languages": [
      {
        "id": "catbase",
        "aliases": ["CatBase", "catbase"],
        "extensions": [".cat"],
        "configuration": "./language-configuration.json"
      }
    ],
    "grammars": [
      {
        "language": "catbase",
        "scopeName": "source.catbase",
        "path": "./syntaxes/catbase.tmLanguage"
      }
    ]
  }
}

{
  "comments": {
    "lineComment": "#",
    "blockComments": ["/*", "*/"]
  },
  "brackets": [
    ["{", "}"],
    ["[", "]"],
    ["(", ")"]
  ],
  "autoClosingPairs": [
    ["{", "}"],
    ["[", "]"],
    ["(", ")"],
    ["\"", "\""],
    ["'", "'"]
  ],
  "surroundingPairs": [
    ["{", "}"],
    ["[", "]"],
    ["(", ")"],
    ["\"", "\""],
    ["'", "'"]
  ],
  "indentationRules": {
    "increaseIndentPattern": "\\{[^}]*$",
    "decreaseIndentPattern": "^\\s*\\}"
  }
}

name: CatBase
scopeName: source.catbase
patterns:
  - include: '#comments'
  - include: '#strings'
  - include: '#keywords'
  - include: '#types'
  - include: '#numbers'
  - include: '#functions'

repository:
  comments:
    patterns:
      - name: comment.line.catbase
        begin: "#"
        end: "$"
      - name: comment.block.catbase
        begin: "/\\*"
        end: "\\*/"

  strings:
    patterns:
      - name: string.quoted.double.catbase
        begin: "\""
        end: "\""
        patterns:
          - name: string.escape.catbase
            match: \\.
      - name: string.quoted.single.catbase
        begin: "'"
        end: "'"
        patterns:
          - name: string.escape.catbase
            match: \\.

  keywords:
    patterns:
      - name: keyword.control.catbase
        match: \b(def|if|else|for|while|return|break|try|catch|except|finally|thread|async|await|import|from|as|not|and|or|in|is)\b
      - name: keyword.other.catbase
        match: \b(True|False|None)\b

  types:
    patterns:
      - name: storage.type.catbase
        match: \b(i64|i32|i16|i8|u64|u32|u16|u8|f64|f32|bool|str|list|dict|bytes|any)\b

  numbers:
    patterns:
      - name: constant.numeric.catbase
        match: \b\d+(\.\d+)?\b
      - name: constant.numeric.hex.catbase
        match: \b0x[0-9a-fA-F]+\b

  functions:
    patterns:
      - name: entity.name.function.catbase
        match: '[a-zA-Z_][a-zA-Z0-9_]*(?=\s*\()'

# 复制整个文件夹到扩展目录
cp -r vscode-extension ~/.vscode/extensions/catbase

# Windows 可使用:
# xcopy /E /I vscode-extension "%USERPROFILE%\.vscode\extensions\catbase"

cd vscode-extension
code --install-extension .

变量名:类型 = 初始值

def main(args:list[str]) {
    # 整数类型
    age:int = 25

    # 浮点数类型
    price:float = 19.99

    # 字符串类型
    name:str = "CatBase"

    # 布尔类型
    is_active:bool = True

    # 字节类型（0-255 的整数）
    ascii_a:byte = byte(65)         # 'A' 的 ASCII 码
    ascii_z:byte = byte(90)         # 'Z' 的 ASCII 码

    print("Name: ", name, "\n")
    print("Age: ", age, "\n")
    print("Price: ", price, "\n")
    print("Active: ", is_active, "\n")
    print("ASCII a: ", ascii_a, " (char: ", chr(ascii_a), ")\n")
    print("ASCII z: ", ascii_z, " (char: ", chr(ascii_z), ")\n")
}

Name: CatBase
Age: 25
Price: 19.99
Active: true
ASCII a: 65 (char: A)
ASCII z: 90 (char: Z)

def main(args:list[str]) {
    # byte 构造函数
    b1:byte = byte(65)        # 65
    b2:byte = byte(255)       # 255（最大）
    b3:byte = byte(0)         # 0（最小）
    b4:byte = byte(None)      # 0

    # 单字符 bytes 字面量（方案 C - 自动提升为 byte）
    b5:byte = b"A"            # 65 ('A')
    b6:byte = b"Z"            # 90 ('Z')
    b7:byte = b"\xFF"         # 255（十六进制转义）
    b8:byte = b"\x00"         # 0（空字节）

    # byte ↔ int 互相赋值
    n:int = 100
    b9:byte = n               # int → byte (自动)
    n2:int = b9               # byte → int (自动)

    # byte 与 chr 配合
    c:str = chr(byte(65))     # "A"
    c2:str = chr(b5)          # "A"（字面量方式也行）

    print("byte(65) = ", b1, "\n")
    print("b\"A\" = ", b5, "\n")
    print("b\"\\xFF\" = ", b7, "\n")
    print("chr(byte(65)) = ", c, "\n")
}

# 错误示例 - 不能使用内置函数名
def file() -> int {  # 编译错误！
    return 1
}

# 错误示例 - 不能使用内置类型名
def main(args:list[str]) {
    Thread:Thread = 1  # 编译错误！
}

CatBase compilation errors:
  line 3: cannot use 'file' as function name: 'file' is a built-in function
  line 5: cannot use 'Thread' as variable name: 'Thread' is a built-in type

def main(args:list[str]) {
    # 列表类型
    numbers:list[int] = [1, 2, 3, 4, 5]
    
    print("Numbers: ", numbers, "\n")
    print("First: ", numbers[0], "\n")
}

Numbers: [1, 2, 3, 4, 5]
First: 1

def main(args:list[str]) {
    # 字典类型
    person:dict[str, str] = {"name": "Tom", "age": "20"}
    
    print("Person: ", person, "\n")
    print("Name: ", person["name"], "\n")
}

Person: {"name": "Tom", "age": 20}
Name: Tom

def main(args:list[str]) {
    # TCP客户端
    sock:TCPSocket = tcpsocket()
    sock.connect("example.com", 80)

    # TCP服务器
    server:TCPSocket = tcpsocket()
    server.bind("0.0.0.0", 8080)
    server.listen(128)
    client:TCPClient = server.accept()

    # UDP
    udp:UDPSocket = udpsocket()
    udp.sendto("Hello", "127.0.0.1", 9999)

    # WebSocket客户端
    ws:WebSocket = websocket("ws://example.com/ws", None)

    # 串口
    ser:Serial = serial("/dev/ttyUSB0", 115200)

    # 配置文件
    cfg:Config = config("app.conf")

    # 文件对象
    f:File = file("test.txt", "r")

    # 音频流
    stream:RecordStream = recordStream(rate=16000, channels=1)

    # 使用完成后需要关闭资源
    client.close()
    ws.close()
    ser.close()
    f.close()
    stream.close()
}

q:Queue = queue(maxsize)  # maxsize 为 0 表示无限制队列

def producer(q:Queue) {
    i:int = 0
    while i < 5 {
        msg:str = str(i * 100)
        q.put(msg, -1)  # 阻塞等待放入
        print("Producer: put ", msg, "\n")
        i = i + 1
    }
}

def consumer(q:Queue) {
    i:int = 0
    while i < 5 {
        if !q.empty() {
            msg:str = q.get_nowait()
            print("Consumer: get_nowait ", msg, "\n")
            q.task_done()
        } else {
            print("Consumer: queue is empty, waiting...\n")
        }
        sleep(1)
        i = i + 1
    }
}

def main(args:list[str]) {
    q:Queue = queue(10)
    thread producer(q)
    thread consumer(q)
    q.join()  # 等待所有任务和线程完成
    print("Test completed!\n")
}

def main(args:list[str]) {
    x = 10  # 错误：必须显式声明类型
}

line 3: [Type Error] Variable 'x' must be explicitly declared with a type

def main(args:list[str]) {
    x:int = 10  # 正确
}

变量名:类型 = 初始值

# 全局变量声明（位于函数外部）
MY_NAME: str = "CatBase"
MY_VERSION: int = 1
MY_PI: float = 3.14
IS_ACTIVE: bool = true

def main(args:list[str]) {
    print("Name: ")
    print(MY_NAME)
    print("\n")
    print("Version: ")
    print(MY_VERSION)
    print("\n")
    print("PI: ")
    print(MY_PI)
    print("\n")
}

Name: CatBase
Version: 1
PI: 3.14

def 函数名(参数:类型, ...) -> 返回类型 {
    # 函数体
    return 值
}

def greet() {
    print("Hello, World!")
}

def main(args:list[str]) {
    greet()
}

Hello, World!

def greet(name:str) {
    print("Hello, ", name, "!")
}

def main(args:list[str]) {
    greet("CatBase")
    greet("World")
}

Hello, CatBase!
Hello, World!

def add(a:int, b:int) -> int {
    return a + b
}

def main(args:list[str]) {
    result:int = add(5, 3)
    print("5 + 3 = ", result, "\n")
}

5 + 3 = 8

def main(args:list[str]) {
    print("Program started!\n")
    print("Number of arguments: ", len(args), "\n")
}

Program started!
Number of arguments: 1

def main(args:list[str]) {
    print("Program name: ", args[0], "\n")
    print("Number of arguments: ", len(args), "\n")
    
    # 遍历所有参数
    i:int = 0
    while i < len(args) {
        print("args[", i, "] = ", args[i], "\n")
        i = i + 1
    }
}

Program name: ./hello
Number of arguments: 4
args[0] = ./hello
args[1] = hello
args[2] = world
args[3] = 123

# 编译
catcc hello.cat

# 运行并传入参数
./hello hello world 123

def main(args: list[str]) {
    print("Number of args: ", len(args), "\n")
    if len(args) > 1 {
        print("First user arg: ", args[1], "\n")  # args[0] 是程序名
    }
}

./myprog hello world
# 输出:
Number of args: 3
First user arg: hello

def main() {
    print("Hello from simplified main!\n")
    print("This program does not need command-line arguments.\n")
}

CatBase compilation warnings (non-fatal):
  --> test_main_simplified.cat:25
  |
   > |   25 | def main() {
     |   26 |     print("Hello from simplified main!\n")
  |
  [main-simplified] main function declared with no parameters.
    Hint: command-line arguments passed to the compiled binary will be ignored at runtime.
    To receive command-line arguments, declare main as: def main(args: list[str]) { ... }

./test_main_simplified             # OK，运行正常
./test_main_simplified a b c       # OK，a b c 被忽略
./test_main_simplified --help      # OK，--help 被忽略

# ===== 完整形式（接收参数）=====
def main(args: list[str]) {
    print("Program: ", args[0], "\n")
    i: int = 1
    while i < len(args) {
        print("Arg ", i, ": ", args[i], "\n")
        i = i + 1
    }
}

# ===== 简化形式（不接收参数）=====
def main() {
    print("This is a simple program with no command-line arguments.\n")
}

def main(args:list[str]) {
    # 这是一个注释
    print("Hello")  # 这也是注释
}

Hello

def main(args:list[str]) {
    /*
     * 这是一个
     * 多行注释
     */
    print("Hello")
}

Hello

def main(args:list[str]) {
    """
    这是一个
    三引号注释
    """
    print("Hello")
}

Hello

def main(args:list[str]) {
    // 这是一个注释
    print("Hello")  // 这也是注释
}

Hello

def main(args:list[str]) {
    # 简单的代码块
    {
        x:int = 10
        print("x = ", x, "\n")
    }
    
    # 条件语句中的代码块
    if True {
        print("True block\n")
    } else {
        print("False block\n")
    }
}

x = 10
True block

def main(args:list[str]) {
    a:int = 10
    b:int = -20
    c:int = 0
    
    print("a = ", a, "\n")
    print("b = ", b, "\n")
    print("c = ", c, "\n")
}

a = 10
b = -20
c = 0

def main(args:list[str]) {
    pi:float = 3.14159
    neg:float = -2.5
    zero:float = 0.0
    
    print("pi = ", pi, "\n")
    print("neg = ", neg, "\n")
    print("zero = ", zero, "\n")
}

pi = 3.14159
neg = -2.5
zero = 0.0

import "./libmylib.so" as mylib

# 使用子类型声明外部函数，精确匹配 C 函数签名
from mylib import process_byte(data: u8) -> i32
from mylib import get_coordinate() -> f32
from mylib import write_buffer(buf: bytes, len: u32) -> i64

def main(args:list[str]) {
    result:i32 = mylib.process_byte(65)
    print("Result: ", result, "\n")
}

def main(args:list[str]) {
    s1:str = "Hello"
    s2:str = 'World'
    s3:str = ""
    s4:str = ''
    
    print("s1 = ", s1, "\n")
    print("s2 = ", s2, "\n")
    print("s3 = '", s3, "'\n")
    print("s4 = '", s4, "'\n")
    print("s1 + s2 = ", s1 + " " + s2, "\n")
}

s1 = Hello
s2 = World
s3 = ''
s4 = ''
s1 + s2 = Hello World

def main(args:list[str]) {
    name:str = "CatBase"
    version:int = 1
    
    # 基本 f-string 用法
    msg:str = f"Hello, {name}!"
    print(msg, "\n")
    
    # 嵌入多个变量
    info:str = f"{name} version {version}"
    print(info, "\n")
    
    # 嵌入表达式
    a:int = 10
    b:int = 20
    result:str = f"Sum = {a + b}"
    print(result, "\n")
}

Hello, CatBase!
CatBase version 1
Sum = 30

def main(args:list[str]) {
    t:bool = True
    f:bool = False
    
    print("t = ", t, "\n")
    print("f = ", f, "\n")
}

t = True
f = False

def main(args:list[str]) {
    # 创建列表
    nums:list[int] = [1, 2, 3, 4, 5]
    
    # 访问元素
    print("First: ", nums[0], "\n")
    print("Last: ", nums[4], "\n")
    
    # 修改元素
    nums[0] = 10
    print("Modified: ", nums, "\n")
    
    # 列表长度
    print("Length: ", len(nums), "\n")
}

First: 1
Last: 5
Modified: [10, 2, 3, 4, 5]
Length: 5

def main(args:list[str]) {
    # 创建字典
    person:dict[str, str] = {"name": "Tom", "age": "20", "city": "Beijing"}
    
    # 访问值
    print("Name: ", person["name"], "\n")
    print("Age: ", person["age"], "\n")
    
    # 修改值
    person["age"] = 21
    print("Updated: ", person, "\n")
    
    # 添加新键值对
    person["country"] = "China"
    print("After add: ", person, "\n")
}

Name: Tom
Age: 20
Updated: {"name": "Tom", "age": 21}
After add: {"name": "Tom", "age": 21, "city": "Beijing", "country": "China"}

def main(args:list[str]) {
    # 创建 ASCII bytes
    data:bytes = b"Hello"
    print(data)
    print("\n")

    # 创建包含十六进制数据的 bytes
    # \xHH 表示十六进制字节值
    hex_data:bytes = b"\x01\x02\x03\x04"
    print("Hex data length: ")
    print(len(hex_data))
    print("\n")
}

Hello
Hex data length: 4

def main(args:list[str]) {
    # 小数据 - 使用静态池
    small:bytes = bytes_alloc(64)       # 静态池
    print("small bytes: ", len(small), "\n")

    # 大数据 - 使用堆
    large:bytes = bytes_alloc(100000)   # 堆分配

    # 1MB 图像数据
    image:bytes = bytes_alloc(1920 * 1080 * 3)  # 1080p RGB

    # 必须显式释放
    bytes_free(small)
    bytes_free(large)
    bytes_free(image)
}

def main(args:list[str]) {
    data:bytes = bytes_alloc(10)

    # 写入数据
    data[0] = byte(72)   # 'H'
    data[1] = byte(101)  # 'e'
    data[2] = byte(108)  # 'l'

    # 读取数据
    b:byte = data[0]   # 72
    print("data[0] = ", b, "\n")

    # 长度
    print("length: ", bytes_len(data), "\n")

    bytes_free(data)
}

def main(args:list[str]) {
    # str → bytes
    s:str = "Hello"
    b:bytes = bytes(s)         # 复制数据，bytes 独立内存
    print("b[0] = ", b[0], "\n")  # 72

    # bytes → str
    s2:str = str(b)             # 复制数据，str 独立内存
    print("s2 = ", s2, "\n")   # "Hello"

    # None 转换
    empty_b:bytes = bytes(None)
    empty_s:str = str(None)
    print("empty bytes len: ", len(empty_b), "\n")
}

def main(args:list[str]) {
    # bytes：pointer_of 返回数据指针
    data:bytes = bytes_alloc(100)
    data[0] = byte(65)   # 'A'

    p:Pointer = pointer_of(data)   # 指向 data[0]，可直接传 C
    if !p.is_null() {
        v:byte = p.get(byte)
        print("p.get(byte) = ", v, "\n")

        p.set(byte, 90)            # 写入 'Z'
        print("data[0] after set: ", data[0], "\n")
    }

    # int：pointer_of 返回变量地址
    n:int = 42
    p2:Pointer = pointer_of(n)
    p2.set(int, 100)
    print("n after set: ", n, "\n")

    bytes_free(data)
}

def main(args:list[str]) {
    # 单字符 → byte 类型
    b1:byte = b"A"             # 65
    b2:byte = b"\xFF"          # 255

    # 多字符 → bytes 类型
    bs1:bytes = b"Hello"        # [72, 101, 108, 108, 111]
    bs2:bytes = b"\x01\x02\x03"  # [1, 2, 3]

    # 在 bytes 数组中赋值时可直接用字面量
    buf:bytes = bytes_alloc(5)
    buf[0] = b"H"              # 72
    buf[1] = b"e"              # 101
    buf[2] = b"\x6C"           # 108 ('l')

    # 与 byte() 构造函数完全等价
    if b1 == byte(65) {
        print("✓ b\"A\" == byte(65)\n")
    }
}

type(b"A")      # → "byte"
type(b"AB")     # → "bytes"
type(b"hello")  # → "bytes"
type(b"")       # → "bytes"（空）

def main(args:list[str]) {
    # 打开串口
    ser:Serial = serial("/dev/ttyUSB0", 115200)
    print("Serial port opened successfully\n")

    # 发送文本数据
    ser.write(b"Hello, Serial!\n")

    # 发送二进制协议数据（Modbus 示例）
    # 帧格式：设备地址(1) + 功能码(1) + 数据(N) + CRC(2)
    modbus_frame:bytes = b"\x01\x03\x00\x00\x00\x0A"
    ser.write(modbus_frame)

    # 读取响应
    data:str = ser.read(1024)
    print("Received: ")
    print(data)
    print("\n")

    # 关闭串口
    ser.close()
    print("Serial port closed\n")
}

Serial port opened successfully
Serial port closed

def main(args:list[str]) {
    # 构造 IP 头的前 20 字节
    version_ihl:bytes = b"\x45"      # 版本(4) + 首部长度(5)
    tos:bytes = b"\x00"              # 服务类型
    total_length:bytes = b"\x00\x14"  # 总长度 (20)
    identification:bytes = b"\x00\x00" # 标识
    flags_offset:bytes = b"\x40\x00"  # 标志 + 片偏移
    ttl:bytes = b"\x40"              # 生存时间 (64)
    protocol:bytes = b"\x06"         # 协议 (TCP)
    checksum:bytes = b"\x00\x00"      # 校验和
    src_ip:bytes = b"\xC0\xA8\x01\x01" # 源 IP (192.168.1.1)
    dst_ip:bytes = b"\xC0\xA8\x01\x02" # 目标 IP (192.168.1.2)

    # 组合完整的 IP 头
    ip_header:bytes = version_ihl + tos + total_length + identification + flags_offset + ttl + protocol + checksum + src_ip + dst_ip

    print("IP header length: ")
    print(len(ip_header))
    print("\n")
    print("IP header hex: ")
    print(ip_header)
    print("\n")
}

IP header length: 20
IP header hex: E5 00 14 00 00 40 00 40 06 00 00 C0 A8 01 01 C0 A8 01 02

# 测试 any 类型可以存储任意类型的值
def main(args:list[str]) {
    # 创建一个 any 类型的变量，初始化为 None
    x: any = None
    print("x (None) =", str(x), ", type =", type(x))

    # 存储字符串
    x = "hello"
    print("x (str) =", str(x), ", type =", type(x))

    # 存储整数
    x = 42
    print("x (int) =", str(x), ", type =", type(x))

    # 存储浮点数
    x = 3.14
    print("x (float) =", str(x), ", type =", type(x))

    # 存储布尔值
    x = True
    print("x (bool) =", str(x), ", type =", type(x))

    # 存储列表
    x = [1, 2, 3]
    print("x (list) =", x, ", type =", type(x))

    # 存储字典
    x = {"key": "value"}
    print("x (dict) =", x, ", type =", type(x))

    print("\nAll types stored successfully in any variable!")
}

x (None) = None , type = any:None
x (str) = hello , type = any:str
x (int) = 42 , type = any:int
x (float) = 3.14 , type = any:float
x (bool) = true , type = any:bool
x (list) = [list] , type = any:list
x (dict) = [dict] , type = any:dict

All types stored successfully in any variable!

def main(args:list[str]) {
    # JSON 解析返回 dict[str, any]
    data: dict[str, any] = {"name": "Alice", "age": 25, "score": 95.5}

    # 使用 any 类型接收 get 返回值
    name: any = data.get("name")
    age: any = data.get("age")
    missing: any = data.get("missing")   # 不存在的 key 返回 None

    print("name =", str(name), ", type =", type(name))
    print("age =", str(age), ", type =", type(age))
    print("missing =", str(missing), ", type =", type(missing))

    # 从 any 值中提取具体类型
    name_str: str = str(data.get("name"))
    age_int: int = int(data.get("age"))
    score_float: float = float(data.get("score"))

    print("name_str =", name_str)
    print("age_int =", age_int)
    print("score_float =", score_float)
}

name = Alice , type = any:str
age = 25 , type = any:int
missing = None , type = any:None
name_str = Alice
age_int = 25
score_float = 95.5

def main(args: list[str]) {
    # 多个分支分别处理不同类型
    x: any = "hello"
    if x is int {
        print("整数:", x + 1, "\n")          # x 在这里被窄化为 int
    } else if x is str {
        print("字符串:", str(len(x)), "\n")  # x 在这里被窄化为 str
    } else if x is None {
        print("空值\n")
    } else {
        print("其他类型:", str(type(x)), "\n")
    }
}

def main(args: list[str]) {
    # 排除 None 后再使用
    x: any = 42
    if x is not None {
        if x is int {
            print("非空整数:", x * 2, "\n")
        }
    }
}

def main(args: list[str]) {
    # dict[str, any] 中取嵌套结构 → 多层守卫
    data: dict[str, any] = {"user": {"name": "Alice", "age": 30}}
    if data.get("user") is dict {
        user: any = data.get("user")
        if user.get("name") is str {
            name: any = user.get("name")
            print("用户名:", str(name), "\n")
        }
    }
}

def main(args: list[str]) {
    x: any = 42
    match x {
        int  => { print("int:", x + 1, "\n") }
        str  => { print("str:", x, "\n") }
        list => { print("list len:", len(x), "\n") }
        _      => { print("其他类型\n") }
    }
}

def main(args: list[str]) {
    x: any = "world"
    s: str = str(x)     # 直接转换，无需守卫
    print(s, "!\n")     # 输出: world!
}

def main(args: list[str]) {
    # 方式 1：守卫后可直接赋值（推荐）
    x: any = 42
    if x is int {
        n: int = x       # 已确认是 int，直接赋值
        print("n =", n, "\n")
    }

    # 方式 2：未守卫时 int(any) 会返回 0（int() 的默认行为）
    y: any = "100"
    m: int = int(y)      # y 不是 int，返回 0
    print("m =", m, "\n")
}

def main(args: list[str]) {
    x: any = 3.14
    if x is float {
        f: float = x
        print("f =", f, "\n")
    }
}

def main(args: list[str]) {
    x: any = "yes"
    if x is str {
        s: str = x
        b: bool = bool(s)         # 守卫后 bool() 正常工作
        if b {
            print("非空字符串视为 true\n")
        }
    }
}

def main(args: list[str]) {
    # 模拟 JSON 数据
    data: dict[str, any] = {
        "name": "Alice",
        "age": 30,
        "scores": [90, 85, 92],
        "active": True,
        "profile": None
    }

    # 基本字段访问 + 守卫
    if data.get("name") is str {
        name: any = data.get("name")
        print("name:", str(name), "\n")
    }
    if data.get("age") is int {
        age: any = data.get("age")
        print("age:", age + 1, "\n")   # 守卫后可直接 + 1
    }

    # 嵌套结构
    if data.get("scores") is list {
        scores: any = data.get("scores")
        print("scores len:", len(scores), "\n")
    }
}

def main(args: list[str]) {
    items: list[any] = [1, "hello", True, 3.14, None]

    # 遍历时按类型分支处理
    for item in items {
        if item is int {
            print("int:", item * 2, "\n")
        } else if item is str {
            print("str:", str(item), "\n")
        } else if item is None {
            print("None\n")
        }
    }
}

def main(args: list[str]) {
    # 外层 dict 的 value 是 list，list 中元素是 any
    matrix: dict[str, list[any]] = {
        "row1": [1, "two", 3.0],
        "row2": [True, None, "end"]
    }

    if matrix.get("row1") is list {
        row: any = matrix.get("row1")
        first: any = row[0]   # 索引访问
        if first is int {
            print("first int:", first, "\n")
        }
        second: any = row[1]
        if second is str {
            print("second str:", str(second), "\n")
        }
    }
}

def main(args: list[str]) {
    # dict[str, any] → 守卫后 put / list 守卫后 append
    d: dict[str, any] = {"a": 1}
    if d is dict {
        d.put("b", 2)             # 守卫后可以调用 .put
    }

    xs: list[any] = [1, 2]
    if xs is list {
        xs.append(3)              # 守卫后可以调用 .append
    }
    print("d =", d, "\n")
    print("xs =", xs, "\n")
}

def get_value(flag: int) -> any {
    if flag == 0 {
        return "text"
    } else if flag == 1 {
        return 42
    }
    return None
}

def main(args: list[str]) {
    v: any = get_value(0)
    if v is str {
        print("got str:", str(v), "\n")
    } else if v is int {
        print("got int:", v + 1, "\n")   # 守卫后直接用
    } else {
        print("got None\n")
    }
}

def describe(x: any) -> str {
    if x is int {
        return "integer"
    } else if x is str {
        return "string"
    } else if x is list {
        return "list"
    }
    return "other"
}

def main(args: list[str]) {
    print(describe(42), "\n")        # integer
    print(describe("hi"), "\n")      # string
    print(describe([1, 2]), "\n")    # list
}

def main(args: list[str]) {
    x: any = 100            # 存 int
    x = "now string"        # 重赋值为 str
    x = [1, 2, 3]           # 重赋值为 list
    x = {"k": "v"}          # 重赋值为 dict
    print("final type:", str(type(x)), "\n")  # any:dict
}

def main(args: list[str]) {
    # typed → any → typed（信息不丢失）
    n: int = 42
    x: any = n              # int → any
    if x is int {
        m: int = x          # any → int
        print("round trip:", m, "\n")
    }

    # 容器：dict[str, int] → any → 取回修改
    d: dict[str, int] = {"a": 1, "b": 2}
    x = d
    if x is dict {
        x.put("c", 3)        # 守卫后可以 put
        print("modified:", str(len(x)), "\n")  # 3
    }
}

def main(args:list[str]) {
    # 字符串转整数
    n:int = int("42")
    print("int('42') = ", n, "\n")
    
    # 整数转字符串
    s:str = str(123)
    print("str(123) = '", s, "'\n")
    
    # 整数转浮点数
    f:float = float(10)
    print("float(10) = ", f, "\n")
    
    # 字符串转浮点数
    f2:float = float("3.14")
    print("float('3.14') = ", f2, "\n")
}

int('42') = 42
str(123) = '123'
float(10) = 10.0
float('3.14') = 3.14

# 用 struct 声明
struct Point {
    x: int
    y: int
}

# 用 class 声明（与上面完全等价）
class Point {
    x: int
    y: int
}

def main(args: list[str]) {
    a: Point = Point { x: 1, y: 2 }
    b: Point = Point { x: 3, y: 4 }
    print(a.x, a.y)
}

struct vst {
    key: set[str]
    value: set[str]
}

def main() {
    v: vst = vst { key: set(), value: set() }
    v.key.add("a")           # ← 对字段 key 调用 set.add()
    v.key.add("b")
    v.value.add("c")
    print(v)                 # vst{ key: {'a', 'b'}, value: {'c'} }
}

struct Data {
    ids: set[int]
    names: list[str]
    config: dict[str, any]
}

def main() {
    d: Data = Data {
        ids: set([1, 2, 3]),
        names: ["alice", "bob"],
        config: {"version": 1, "debug": false}
    }
    # 对 struct 字段调用方法
    d.ids.add(4)
    d.names.append("carol")
    d.config["max"] = 100
    # 嵌套 set 构造器自动按字段类型推导
    d.ids.contains(1)            # true
    d.names.len()                # 3
    print(d)
}

struct Profile {
    friends: set[str]    # 好友（自动去重）
    blocked: set[str]    # 黑名单（自动去重）
}

def main() {
    alice: Profile = Profile {
        friends: set(["bob", "carol", "bob", "dave"]),    # 重复 "bob" 自动去重
        blocked: set(["eve", "mallory"])
    }
    print(alice.friends)         # {'carol', 'dave', 'bob'}
    print(alice.blocked)         # {'eve', 'mallory'}

    # 直接对字段调用方法：编译器自动把 alice 升级为 var，
    # 并对 alice.friends 加 @constCast，无需手动处理
    alice.friends.add("frank")
    alice.friends.add("carol")   # 重复元素，set 内部已存在
    print(alice.friends)         # {'carol', 'dave', 'bob', 'frank'}

    # 查询接口
    print(alice.friends.contains("bob"))    # true
    print(alice.friends.contains("ghost"))  # false
}

struct Inner {
    tags: set[str]
}
struct Outer {
    name: str
    inner: Inner
}

def main() {
    box: Outer = Outer {
        name: "container",
        inner: Inner { tags: set(["alpha", "beta"]) }
    }
    print(box.name)              # container
    print(box.inner.tags)        # {'alpha', 'beta'}

    # 链式访问：box.inner.tags 自动按 Inner.tags 的 set[str] 类型推导
    box.inner.tags.add("gamma")
    print(box.inner.tags)        # {'alpha', 'gamma', 'beta'}
}

struct Inner {
    tags: set[str]
}
struct Middle {
    name: str
    items: list[Inner]    # list 元素可以是 struct，绕过递归 struct 限制
}
struct Outer {
    title: str
    middle: Middle
}

def main() {
    box: Outer = Outer {
        title: "demo",
        middle: Middle {
            name: "section-A",
            items: [
                Inner { tags: set(["a", "b", "a"]) },     # 重复 "a" 去重
                Inner { tags: set(["c", "d"]) }
            ]
        }
    }
    print(box.middle.items.len())                  # 2
    print(box.middle.items[0].tags)                # {'a', 'b'}
    box.middle.items[0].tags.add("a-new")
    print(box.middle.items[0].tags)                # {'a', 'b', 'a-new'}
}

struct Point {
    x: int
    y: int
}

def main() {
    # ❌ 错误：缺少 struct 名 "Point"
    v: Point = { x: 1, y: 2 }
}

[Type Error] Variable assignment type mismatch
  Variable 'v' declared as 'Point' but assigned value of type 'dict[str,int]'
  hint: did you forget the struct name? Use `Point { ... }` instead of `{ ... }`
  example: `Point { x: <value>, y: <value> }`

def main() {
    # ✅ 正确：显式带 struct 名
    v: Point = Point { x: 1, y: 2 }
    print(v)              # Point{ x: 1, y: 2 }
}

class Animal {
    name: str
    age: int

    def describe() -> str {
        return self.name + " is " + str(self.age) + " years old"
    }
}

// 用组合实现"Dog 包含 Animal"（而不是"Dog 继承 Animal"）
class Dog {
    animal: Animal      // 组合：Dog 内部包含一个 Animal
    breed: str

    def describe() -> str {
        return self.animal.describe() + " (" + self.breed + ")"
    }
}

def make_dog(name: str, age: int, breed: str) -> Dog {
    return Dog {
        animal: Animal { name: name, age: age },
        breed: breed
    }
}

def main(args: list[str]) {
    dog: Dog = make_dog("Rex", 5, "Labrador")
    print(dog.describe())                          // Rex is 5 years old (Labrador)
    print("Dog's name:", dog.animal.name)          // 访问组合对象的字段
}

def main(args:list[str]) {
    # 任意类型都可以用 None 初始化
    xint:int = None
    ystr:str = None
    xfloat: float = None
    xbool: bool = None
    xbyte: byte = None
    xbytes: bytes = None
    xany: any = None
    xlist: list[int] = None
    xdict: dict[str, str] = None

    # 用 is None 检查是否为空
    if xint is None {print("xint is None")}
    if ystr is None {print("ystr is None")}
    if xfloat is None {print("xfloat is None")}
    if xbool is None {print("xbool is None")}
    if xbyte is None {print("xbyte is None")}
    if xbytes is None {print("xbytes is None")}
    if xany is None {print("xany is None")}
    if xlist is None {print("xlist is None")}
    if xdict is None {print("xdict is None")}

    # None 值可以直接打印
    print(xint)        # None
    print(ystr)        # None
    print(xfloat)      # None
    print(xbool)       # None
    print(xbyte)       # None
    print(xbytes)      # None
    print(xany)        # None
    print(xlist)       # None
    print(xdict)       # None
}

xint is None
ystr is None
xfloat is None
xbool is None
xbyte is None
xbytes is None
xany is None
xlist is None
xdict is None
None
None
None
None
None
None
None
None
None

def main(args:list[str]) {
    xint:int = None
    ystr:str = None
    xfloat: float = None
    xbool: bool = None
    xbyte: byte = None
    xbytes: bytes = None
    xany: any = None
    xlist: list[int] = None
    xdict: dict[str, str] = None

    # 赋实际值
    xint = 1
    ystr = "1"
    xfloat = 1
    xbool = True
    xbyte = b"A"
    xbytes = b"hello"
    xany = "a"
    xlist = [1, 2]
    xdict = {"b": "AAA"}

    # 用 is not None 检查是否已赋值
    if xint is not None {print("xint is not None")}
    if ystr is not None {print("ystr is not None")}
    if xfloat is not None {print("xfloat is not None")}
    if xbool is not None {print("xbool is not None")}
    if xbyte is not None {print("xbyte is not None")}
    if xbytes is not None {print("xbytes is not None")}
    if xany is not None {print("xany is not None")}
    if xlist is not None {print("xlist is not None")}
    if xdict is not None {print("xdict is not None")}
}

xint is not None
ystr is not None
xfloat is not None
xbool is not None
xbyte is not None
xbytes is not None
xany is not None
xlist is not None
xdict is not None

def main(args:list[str]) {
    # dict[str, int] 找不到时返回 0
    data: dict[str, int] = {"b": 1}
    v: int = data.get("a")
    print(v)         # 0

    # dict[str, any] 找不到时返回 None
    any_data: dict[str, any] = {"name": "Alice", "age": 25}
    missing: any = any_data.get("nonexistent")
    if missing is None {
        print("key not found, value is None")
    }
}

def main(args: list[str]) {
    # 创建一个 any 类型的变量，初始化为 None
    x: any = None
    print("x (None) =", str(x), ", type =", type(x))   # x (None) = None , type = any:None

    # 从 dict[str, any] 中取不存在的 key
    data: dict[str, any] = {"name": "Alice"}
    missing: any = data.get("missing")
    if missing is None {
        print("missing key returns None")              # 命中
    }
}

def greet(name: str) {       # 无返回类型
    print("Hello,", name)
    # 隐式返回 None
}

def main(args: list[str]) {
    result: any = greet("CatBase")
    if result is None {
        print("greet() returned None")
    }
}

def main(args:list[str]) {
    raw: list[any] = [{"id": 1, "name": "Alice"}, {"id": 2, "name": "Bob"}]
    i: int = 0
    while i < len(raw) {
        nd: any = raw[i]                # ← 声明为 any
        name: any = nd.get("name", "")  # ← 编译错误：不能在 any 上调用方法
        print(name, "\n")
        i = i + 1
    }
}

CatBase compilation errors:
  --> test_graph.cat:71
  |
     |   69 |             i: int = 0
     |   70 |             while i < len(raw) {
   > |   71 |                 nd: any = raw[i]
     |   72 |                 if int(str(nd.get("id", 0))) == target_id {
     |   73 |                     print("Node{id=", nd.get("id", 0), ", label=", nd.get("label", "")}\n")
  |
  [any-misuse-error] cannot call method on variable 'nd' of type 'any'.
    Hint: Declare 'nd' with a more specific type. For a dict-like value, use 'dict[str, any]'. For a list, use 'list[T]'. For a struct, use the concrete struct name.

def main(args:list[str]) {
    raw: list[dict[str, any]] = [{"id": 1, "name": "Alice"}, {"id": 2, "name": "Bob"}]
    i: int = 0
    while i < len(raw) {
        nd: dict[str, any] = raw[i]    # ← 用具体类型 dict[str, any]
        name: any = nd.get("name", "")  # ← 现在可以调用 .get()
        print(name, "\n")
        i = i + 1
    }
}

CatBase compilation warnings (non-fatal):
  --> test_graph.cat:191
  |
     |  189 |                 nd: any = nodes[i]
     |  190 |                 if int(str(nd.get("id", 0))) == target_id {
   > |  191 |                     nd["props"] = props
     |  192 |                     found = 1
  |
  [any-usage] variable 'nd' is declared as 'any' but accessed with dict pattern ("props")
    Hint: declare it as 'dict[K, V]' (e.g. 'dict[str, any]') so static type checks can verify key access

# ===== 错误写法（any 上调用方法）=====
def bad_example(data: list[any]) {
    item: any = data[0]
    return item.get("name", "")   # 编译错误
}

# ===== 软警告写法（any 上索引访问）=====
def warning_example(data: list[any]) {
    item: any = data[0]
    return item["name"]           # 软警告
}

# ===== 正确写法（具体类型）=====
def good_example(data: list[dict[str, any]]) {
    item: dict[str, any] = data[0]
    return item.get("name", "")   # OK
}

# ===== 灵活但受控的写法（any + 转换）=====
def flex_example(data: list[any]) {
    item: any = data[0]
    return str(item)              # OK：调用内置函数（不是 method）
}

def main(args: list[str]) {
    x: any = 42

    # ✓ 推荐：守卫后直接用
    if x is int {
        n: int = x          # 直接赋值 int，不需要 int(x)
        print("n + 10 =", n + 10, "\n")
    }

    # ✗ 多余：已经守卫了还再转换
    if x is int {
        n: int = int(x)     # 多余的转换，编译器也允许但没必要
    }
}

def main(args: list[str]) {
    # 检查"不是 None"后即可安全使用
    x: any = 42
    if x is not None {
        if x is int {
            print(x, "\n")
        }
    }
}

def main(args: list[str]) {
    # 处理 dict[str, any] 嵌套结构的标准模式
    data: dict[str, any] = {"user": {"name": "Alice", "age": 30}}

    user: any = data.get("user")
    if user is dict {
        name: any = user.get("name")
        if name is str {
            print("name:", str(name), "\n")
        }
    }
}

def main(args: list[str]) {
    data: dict[str, any] = {
        "user": {"name": "Alice", "age": 30, "tags": ["admin", "user"]}
    }

    # 标准访问模式：取 → 守卫 → 递归
    if data.get("user") is dict {
        user: any = data.get("user")
        if user.get("tags") is list {
            tags: any = user.get("tags")
            if len(tags) > 0 {
                first: any = tags[0]
                if first is str {
                    print("first tag:", str(first), "\n")
                }
            }
        }
    }
}

def main(args: list[str]) {
    # 遍历混合类型 list
    items: list[any] = [1, "a", True, None]
    for item in items {
        if item is int {
            print("int:", item, "\n")
        } else if item is str {
            print("str:", str(item), "\n")
        }
    }
}

def get_nested_value(d: dict[str, any], path: list[str]) -> any {
    # 给定路径 list，逐层向下取
    current: any = d
    for key in path {
        if current is dict {
            current = current.get(key)
        } else {
            return None
        }
    }
    return current
}

def main(args: list[str]) {
    data: dict[str, any] = {"a": {"b": {"c": 42}}}
    result: any = get_nested_value(data, ["a", "b", "c"])
    if result is int {
        print("deep value:", result, "\n")   # 42
    }
}

# 返回值可能是 str / int / None（调用方必须守卫）
def lookup(key: str) -> any {
    if key == "name" {
        return "Alice"
    } else if key == "age" {
        return 30
    }
    return None
}

# 接受任意类型，打印其类型和值
def inspect(x: any) {
    print("type =", str(type(x)), ", value =", str(x), "\n")
}

# ✗ 反模式
def bad(data: any) {
    return data.get("name")   # 错误：any 上不能调用方法
}

# ✓ 正确
def good(data: dict[str, any]) {
    return data.get("name")   # OK
}

# ✗ 反模式
def bad(x: any) -> any {
    if x is int {
        return x          # 已窄化为 int，没必要再转 any
    }
    return None
}

# ✓ 正确
def good(x: any) -> int {
    if x is int {
        return x
    }
    return 0
}

# ✗ 编译错误
def bad(x: any) {
    return len(x)         # 错误：any 没有 len() 方法
}

# ✓ 正确
def good(x: any) {
    if x is str {
        return len(x)     # 守卫后 len() 可用
    }
    return 0
}

# ✗ 错误期望
def bad(x: any) {
    return int(x)         # 若 x 实际是 "123"，返回 0（不会解析字符串）
}

# ✓ 正确
def good(x: any) {
    if x is str {
        return int(x)     # 守卫后 int() 才能解析字符串
    }
    return 0
}

def main(args:list[str]) {
    a:int = 10
    b:int = 3
    
    print("a + b = ", a + b, "\n")
    print("a - b = ", a - b, "\n")
    print("a * b = ", a * b, "\n")
    print("a / b = ", a / b, "\n")
    print("a % b = ", a % b, "\n")
}

a + b = 13
a - b = 7
a \* b = 30
a / b = 3
a % b = 1

def main(args:list[str]) {
    a:int = 10
    
    a += 5    # 等价于 a = a + 5
    print("a += 5: ", a, "\n")
    
    a -= 3    # 等价于 a = a - 3
    print("a -= 3: ", a, "\n")
    
    a *= 2    # 等价于 a = a * 2
    print("a *= 2: ", a, "\n")
    
    a /= 4    # 等价于 a = a / 4
    print("a /= 4: ", a, "\n")
}

a += 5: 15
a -= 3: 12
a *= 2: 24
a /= 4: 6

def main(args:list[str]) {
    a:int = 5
    b:int = 3
    
    print("a == b: ", a == b, "\n")
    print("a != b: ", a != b, "\n")
    print("a < b: ", a < b, "\n")
    print("a > b: ", a > b, "\n")
    print("a <= b: ", a <= b, "\n")
    print("a >= b: ", a >= b, "\n")
}

a == b: false
a != b: true
a < b: false
a > b: true
a <= b: false
a >= b: true

def main(args:list[str]) {
    a:bool = True
    b:bool = False
    
    print("a and b: ", a and b, "\n")
    print("a or b: ", a or b, "\n")
    print("not a: ", not a, "\n")
    print("not b: ", not b, "\n")
}

a and b: false
a or b: true
not a: false
not b: true

def main(args:list[str]) {
    data:dict[str,any] = {"name": "Alice", "age": 30}
    
    print("name in data: ", "name" in data, "\n")
    print("city in data: ", "city" in data, "\n")
    
    # 在条件语句中使用
    if "age" in data {
        print("Age exists!\n")
    }
    
    # 结合 and 使用
    if "name" in data and data["name"] {
        print("Name is not empty!\n")
    }
}

name in data: true
city in data: false
Age exists!
Name is not empty!

def main(args:list[str]) {
    # 乘除优先于加减
    print("2 + 3 * 4 = ", 2 + 3 * 4, "\n")
    
    # 括号可以改变优先级
    print("(2 + 3) * 4 = ", (2 + 3) * 4, "\n")
    
    # 逻辑运算
    print("not 1 > 2: ", not 1 > 2, "\n")
}

2 + 3 \* 4 = 14
(2 + 3) \* 4 = 20
not 1 > 2: true

def main(args:list[str]) {
    age:int = 18
    
    if age >= 18 {
        print("成年人\n")
    } else {
        print("未成年人\n")
    }
}

成年人

def main(args:list[str]) {
    test_str:str = "hello"
    
    if test_str {
        print("字符串不为空\n")
    }
    
    empty_str:str = ""
    if empty_str {
        print("字符串不为空\n")
    } else {
        print("字符串为空\n")
    }
}

字符串不为空
字符串为空

def main(args:list[str]) {
    score:int = 85
    
    if score >= 90 {
        print("优秀\n")
    } else if score >= 80 {
        print("良好\n")
    } else if score >= 60 {
        print("及格\n")
    } else {
        print("不及格\n")
    }
}

良好

def main(args:list[str]) {
    x:int = 10
    y:int = 20
    
    if x > 0 {
        if y > 0 {
            print("x 和 y 都为正数\n")
        } else {
            print("x 为正数，y 为负数\n")
        }
    } else {
        print("x 为负数\n")
    }
}

x 和 y 都为正数

def main(args:list[str]) {
    # 遍历列表
    nums:list[int] = [1, 2, 3, 4, 5]
    
    for i in nums {
        print("Value: ", i, "\n")
    }
}

Value: 1
Value: 2
Value: 3
Value: 4
Value: 5

def main(args:list[str]) {
    fruits:list[str] = ["apple", "banana", "orange"]
    
    for i, v in fruits {
        print(i, ": ", v, "\n")
    }
}

0: apple
1: banana
2: orange

def main(args:list[str]) {
    # 遍历范围
    for i in range(5) {
        print("i = ", i, "\n")
    }
}

i = 0
i = 1
i = 2
i = 3
i = 4

def main(args:list[str]) {
    # 发送 HTTP 请求（流式模式）
    url:str = "http://localhost:19090/v1/chat/completions"
    data:dict[str,any] = {
        "model": "qwen",
        "messages": [{"role": "user", "content": "你好"}],
        "stream": true
    }
    
    # 使用 stream=True 启用流式模式
    response:Response = http_post(url, json=data, stream=True)
    
    # 检查响应状态
    response.raise_for_status()
    
    # 迭代读取流式响应
    for line in response.iter_lines() {
        print(line)
    }
}

data: {"id":"chatcmpl-xxx","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"你好"},"logprobs":null,"finish_reason":null}]}
data: {"id":"chatcmpl-xxx","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"！"},"logprobs":null,"finish_reason":null}]}
data: [DONE]

def main(args:list[str]) {
    url:str = "http://localhost:19090/v1/chat/completions"
    data:dict[str,any] = {
        "model": "qwen",
        "messages": [{"role": "user", "content": "你好"}],
        "stream": true
    }
    
    response:Response = http_post(url, json=data, stream=True)
    response.raise_for_status()
    
    # 解析流式响应
    for line in response.iter_lines() {
        line_str:str = line
        if line_str.startswith("data: ") {
            # 提取 JSON 部分
            data_json:str = line_str[6:]
            
            # 解析 JSON
            data_dict:dict = json_loads(data_json)
            
            # 检查 choices 字段
            if "choices" in data_dict and data_dict["choices"] {
                # 获取 delta 中的 content
                delta:dict = data_dict["choices"][0].get("delta", {})
                content:any = delta.get("content", "")
                
                # 转换为字符串打印
                content_str:str = str(content)
                print(content_str, end="", flush=True)
            }
        }
    }
}

你好！有什么可以帮你的吗？

def main(args:list[str]) {
    i:int = 0
    
    while i < 5 {
        print("i = ", i, "\n")
        i = i + 1
    }
}

i = 0
i = 1
i = 2
i = 3
i = 4

def main(args:list[str]) {
    # break 示例
    print("Break example:\n")
    for i in range(10) {
        if i == 5 {
            break
        }
        print(i, " ")
    }
    print("\n")
}

Break example:
0 1 2 3 4

def main(args:list[str]) {
    try {
        print("hello\n")
    }
    except {
        print("something went wrong\n")
    }
}

hello

def main(args:list[str]) {
    try {
        print("hello\n")
    }
    except e {
        print("Caught error: ")
        print(e)
    }
}

hello

def main(args:list[str]) {
    try {
        print("hello\n")
    }
    except Exception as e {
        print("Caught exception: ")
        print(e)
    }
}

hello

def main(args:list[str]) {
    try {
        try {
            print("inner try\n")
        }
        except Exception as e {
            print("inner except: ")
            print(e)
        }
    }
    except Exception as e {
        print("outer except: ")
        print(e)
    }
}

inner try

def main(args:list[str]) {
    try {
        x:int = 10
        y:int = 0
        if y == 0 {
            print("Error: Division by zero\n")
        }
    }
    except Exception as e {
        print("Caught: ")
        print(e)
    }
}

Error: Division by zero
Caught: error.RuntimeError

def main(args:list[str]) {
    try {
        print("hello\n")
    }
    catch {
        print("caught\n")
    }
}

hello

def main(args:list[str]) {
    try {
        print("try block\n")
    }
    except {
        print("catch block\n")
    }
    finally {
        print("finally block - always executes\n")
    }
}

try block
finally block - always executes

def main(args:list[str]) {
    try {
        print("try block - about to error\n")
        # 这里模拟一个错误
    }
    except {
        print("catch block\n")
    }
    finally {
        print("finally block - cleanup here\n")
    }
}

try block - about to error
catch block
finally block - cleanup here

def main(args:list[str]) {
    stream: RecordStream = recordStream(rate=16000, channels=1)

    try {
        data:bytes = record(5, "16000", "1", "", "1024")
        save_wav(data, "/tmp/recording.wav", "16000")
    }
    except {
        print("Error during recording\n")
    }
    finally {
        # 确保录音流被关闭，释放资源
        stream.close()
        print("Resources cleaned up\n")
    }
}

def greet(name:str) {
    print("Hello, ", name, "!\n")
}

def main(args:list[str]) {
    greet("CatBase")
}

Hello, CatBase!

def add(a:int, b:int) -> int {
    return a + b
}

def main(args:list[str]) {
    result:int = add(5, 3)
    print("5 + 3 = ", result, "\n")
}

5 + 3 = 8

def divide() -> list[int] {
    quotient:int = 1
    remainder:int = 2
    r:list[int]=[quotient, remainder]
    return r
}

def main(args:list[str]) {
    result:list[int] = divide()
    print(result[0],result[1])
}

def divide() -> list {
    quotient:int = 1
    remainder:int = 2
    r:list=[quotient, remainder]
    return r
}

def main(args:list[str]) {
    result:list = divide()
    print(result[0],result[1])
}

1 2

# 方式一：显式指定元素类型
def get_list1() -> list[int] {
    return [1, 2, 3, 4, 5]
}

# 方式二：隐式推断元素类型
def get_list2() -> list {
    return [1, 2, 3, 4, 5]
}

def main(args:list[str]) {
    result1:list[int] = get_list1()
    result2:list = get_list2()
    print("方式一: ", result1, "\n")
    print("方式二: ", result2, "\n")
}

方式一:  [1, 2, 3, 4, 5] 
方式二:  [1, 2, 3, 4, 5] 

# 方式一：显式指定键值类型
def get_dict1() -> dict[str, int] {
    d:dict[str, int] = {"a": 1, "b": 2, "c": 3}
    return d
}

# 方式二：隐式推断键值类型
def get_dict2() -> dict {
    d:dict[str, int] = {"x": 10, "y": 20, "z": 30}
    return d
}

def main(args:list[str]) {
    result1:dict[str, int] = get_dict1()
    result2:dict = get_dict2()
    print("方式一: ", result1, "\n")
    print("方式二: ", result2, "\n")
    print("result1[\"a\"] = ", result1["a"], "\n")
    print("result2[\"y\"] = ", result2["y"], "\n")
}

方式一:  {'a': 1, 'b': 2, 'c': 3} 
方式二:  {'x': 10, 'y': 20, 'z': 30} 
result1["a"] =  1 
result2["y"] =  20 

def factorial(n:int) -> int {
    if n <= 1 {
        return 1
    }
    return n * factorial(n - 1)
}

def main(args:list[str]) {
    print("5! = ", factorial(5), "\n")
    print("10! = ", factorial(10), "\n")
}

5! = 120
10! = 3628800

def greet(name:str, greeting:str) {
    print(greeting, ", ", name, "!\n")
}

def main(args:list[str]) {
    greet("Tom", "Hello")
    greet("Jerry", "Hi")
}

Hello, Tom!
Hi, Jerry!

def on_audio_frame(frame:bytes) {
    print("Received audio frame")
    print(len(frame))
}

def process_audio(callback:function) {
    # 回调函数会被调用
    callback(bytes("test data"))
}

def main(args:list[str]) {
    # 将 on_audio_frame 函数作为参数传递
    process_audio(on_audio_frame)
}

Received audio frame
9

def main(args:list[str]) {
    x:int = 10
    
    print("Outer x = ", x, "\n")
    
    {
        x:int = 20
        print("Inner x = ", x, "\n")
    }
    
    print("Outer x after block = ", x, "\n")
}

Outer x = 10
Inner x = 20
Outer x after block = 10

def main(args:list[str]) {
    print("Hello\n")
    print("Number: ", 42, "\n")
    print("Bool: ", True, "\n")
}

Hello
Number: 42
Bool: true

def main(args:list[str]) {
    # 不换行打印
    print("Hello ", end="", flush=True)
    print("World!", end="", flush=True)
    
    # 使用默认换行
    print("\nDone!")
}

Hello World!
Done!

def main(args:list[str]) {
    print("abs(-5) = ", abs(-5), "\n")
    print("abs(5) = ", abs(5), "\n")
    print("abs(0) = ", abs(0), "\n")
}

abs(-5) = 5
abs(5) = 5
abs(0) = 0

def main(args:list[str]) {
    print("max(5, 3) = ", max(5, 3), "\n")
    print("max(-10, 10) = ", max(-10, 10), "\n")
}

max(5, 3) = 5
max(-10, 10) = 10

def main(args:list[str]) {
    print("min(5, 3) = ", min(5, 3), "\n")
    print("min(-10, 10) = ", min(-10, 10), "\n")
}

min(5, 3) = 3
min(-10, 10) = -10

def main(args:list[str]) {
    nums:list[int] = [1, 2, 3, 4, 5]
    print("sum([1,2,3,4,5]) = ", sum(nums), "\n")
    print("sum([]) = ", sum([]), "\n")
}

sum([1,2,3,4,5]) = 15
sum([]) = 0

def main(args:list[str]) {
    print("pow(2, 3) = ", pow(2, 3), "\n")
    print("pow(5, 0) = ", pow(5, 0), "\n")
    print("pow(10, 2) = ", pow(10, 2), "\n")
}

pow(2, 3) = 8
pow(5, 0) = 1
pow(10, 2) = 100

def main(args:list[str]) {
    print("round(3.7) = ", round(3.7), "\n")
    print("round(3.2) = ", round(3.2), "\n")
    print("round(3.5) = ", round(3.5), "\n")
    print("round(3.14159, 2) = ", round(3.14159, 2), "\n")
}

round(3.7) = 4
round(3.2) = 3
round(3.5) = 4
round(3.14159, 2) = 3.14

def main(args:list[str]) {
    print("int('42') = ", int("42"), "\n")
    print("int(3.7) = ", int(3.7), "\n")
    print("int(True) = ", int(True), "\n")
}

int('42') = 42
int(3.7) = 3
int(True) = 1

def main(args:list[str]) {
    print("float(10) = ", float(10), "\n")
    print("float('3.14') = ", float("3.14"), "\n")
}

float(10) = 10.0
float('3.14') = 3.14

def main(args:list[str]) {
    print("str(123) = '", str(123), "'\n")
    print("str(3.14) = '", str(3.14), "'\n")
    print("str(True) = '", str(True), "'\n")
}

str(123) = '123'
str(3.14) = '3.14'
str(True) = 'true'

def main(args:list[str]) {
    # 解析 JSON 字符串
    json_str:str = "{\"name\": \"Alice\", \"age\": 30, \"score\": 95.5}"
    data:dict = json_loads(json_str)
    
    # 提取值并转换为字符串
    name:str = str(data["name"])
    age:str = str(data["age"])
    score:str = str(data["score"])
    
    print("Name: ", name, "\n")
    print("Age: ", age, "\n")
    print("Score: ", score, "\n")
}

Name: Alice
Age: 30
Score: 95.5

def main(args:list[str]) {
    # CatBase 中使用 None 表示空值
    value:any = None
    
    # 判断是否为空
    if value == None {
        print("Value is None\n")
    }
}

### 7.4 进制转换函数

#### bin

`bin(x:int) : str` - 转换为二进制

def main(args:list[str]) {
    print("bin(5) = '", bin(5), "'\n")
    print("bin(10) = '", bin(10), "'\n")
    print("bin(255) = '", bin(255), "'\n")
}

bin(5) = '0b101'
bin(10) = '0b1010'
bin(255) = '0b11111111'

def main(args:list[str]) {
    print("oct(8) = '", oct(8), "'\n")
    print("oct(10) = '", oct(10), "'\n")
    print("oct(64) = '", oct(64), "'\n")
}

oct(8) = '0o10'
oct(10) = '0o12'
oct(64) = '0o100'

def main(args:list[str]) {
    print("hex(255) = '", hex(255), "'\n")
    print("hex(16) = '", hex(16), "'\n")
    print("hex(4096) = '", hex(4096), "'\n")
}

hex(255) = '0xff'
hex(16) = '0x10'
hex(4096) = '0x1000'

def main(args:list[str]) {
    print("chr(65) = '", chr(65), "'\n")
    print("chr(97) = '", chr(97), "'\n")
    print("chr(48) = '", chr(48), "'\n")
    # 同样接受 byte 类型
    b:byte = byte(90)
    print("chr(byte(90)) = '", chr(b), "'\n")
}

chr(65) = 'A'
chr(97) = 'a'
chr(48) = '0'
chr(byte(90)) = 'Z'

def main(args:list[str]) {
    print("ord('A') = ", ord("A"), "\n")
    print("ord('a') = ", ord("a"), "\n")
    print("ord('0') = ", ord("0"), "\n")
}

ord('A') = 65
ord('a') = 97
ord('0') = 48

def main(args:list[str]) {
    # 字符 ↔ 整数
    c1:str = chr(65)        # "A"
    n1:int = ord("Z")       # 90
    print(c1, " has code ", n1, "\n")

    # 字符串 ↔ 整数
    s1:str = str(65)        # "65"
    n2:int = int("42")      # 42
    print(s1, " + ", n2, " = ", int(s1) + n2, "\n")

    # byte 类型
    b:byte = byte(255)
    print("byte(255) as char: ", chr(b), "\n")
}

def main(args:list[str]) {
    print("len('hello') = ", len("hello"), "\n")
    print("len([1,2,3]) = ", len([1, 2, 3]), "\n")
    print("len({'a':1}) = ", len({"a": 1}), "\n")
}

len('hello') = 5
len([1,2,3]) = 3
len({'a':1}) = 1

def main(args:list[str]) {
    print("range(5) = ", range(5), "\n")
    print("range(2, 5) = ", range(2, 5), "\n")
}

range(5) = [0, 1, 2, 3, 4]
range(2, 5) = [2, 3, 4]

def main(args:list[str]) {
    s:str = "Hello World"
    print("原字符串: ", s, "\n")
    print("upper(): ", s.upper(), "\n")
    print("lower(): ", s.lower(), "\n")
    print("capitalize(): ", s.capitalize(), "\n")
    print("title(): ", s.title(), "\n")
}

原字符串: Hello World
upper(): HELLO WORLD
lower(): hello world
capitalize(): Hello world
title(): Hello World

def main(args:list[str]) {
    s:str = "   Hello World   "
    print("原字符串: '", s, "'\n")
    print("strip(): '", s.strip(), "'\n")
    print("lstrip(): '", s.lstrip(), "'\n")
    print("rstrip(): '", s.rstrip(), "'\n")
}

原字符串: '   Hello World   '
strip(): 'Hello World'
lstrip(): 'Hello World   '
rstrip(): '   Hello World'

def main() {
    s:str = "  Hello, World!  "
    print("s.trim()       = '", s.trim(), "'")
    print("s.trim(' !')   = '", s.trim(" !"), "'")

    c:str = "hi"
    print("c.center(6, '-') = '", c.center(6, "-"), "'")
    print("c.ljust(5, '.')  = '", c.ljust(5, "."), "'")
    print("c.rjust(5, '.')  = '", c.rjust(5, "."), "'")
    print("'42'.zfill(5)    = '", "42".zfill(5), "'")
    print("'-42'.zfill(5)   = '", "-42".zfill(5), "'")
}

s.trim()       = 'Hello, World!'
s.trim(' !')   = 'Hello, World'
c.center(6, '-') = '--hi--'
c.ljust(5, '.')  = 'hi...'
c.rjust(5, '.')  = '...hi'
'42'.zfill(5)    = '00042'
'-42'.zfill(5)   = '-0042'

def main() {
    rp:str = "TestHook"
    print("'TestHook'.removeprefix('Test') = '", rp.removeprefix("Test"), "'")
    print("'TestHook'.removesuffix('Hook') = '", rp.removesuffix("Hook"), "'")

    p:str = "hello world hello"
    parts:list[str] = p.partition("world")
    print("partition('world') = ", parts)
    parts3:list[str] = p.rpartition("hello")
    print("rpartition('hello') = ", parts3)

    print("'HELLO'.casefold()  = '", "HELLO".casefold(), "'")
    print("'Hello'.swapcase()  = '", "Hello".swapcase(), "'")
    print("'a\\tb'.expandtabs(4) = '", "a\tb".expandtabs(4), "'")
}

'TestHook'.removeprefix('Test') = 'Hook'
'TestHook'.removesuffix('Hook') = 'Test'
partition('world') = ["hello ","world"," hello"]
rpartition('hello') = ["hello world ","hello",""]
'HELLO'.casefold()  = 'hello'
'Hello'.swapcase()  = 'hELLO'
'a\tb'.expandtabs(4) = 'a   b'

def main(args:list[str]) {
    s:str = "Hello World Hello"
    print("原字符串: ", s, "\n")
    print("find('World'): ", s.find("World"), "\n")
    print("rfind('Hello'): ", s.rfind("Hello"), "\n")
    print("count('l'): ", s.count("l"), "\n")
    print("startswith('Hello'): ", s.startswith("Hello"), "\n")
    print("endswith('World'): ", s.endswith("World"), "\n")
}

原字符串: Hello World Hello
find('World'): 6
rfind('Hello'): 12
count('l'): 3
startswith('Hello'): true
endswith('World'): false

def main(args:list[str]) {
    s:str = "Hello World"
    
    # 从索引 6 到末尾
    result1:str = s[6:]
    print("s[6:]: ", result1, "\n")
    
    # 从索引 0 到索引 5（不包含）
    result2:str = s[0:5]
    print("s[0:5]: ", result2, "\n")
    
    # 从索引 6 到索引 11
    result3:str = s[6:11]
    print("s[6:11]: ", result3, "\n")
}

s[6:]:  World
s[0:5]: Hello
s[6:11]: World

def main(args:list[str]) {
    s:str = "apple,banana,cherry"
    print("原字符串: ", s, "\n")
    result:list = s.split(",")
    print("split(','): ", result, "\n")
    
    s2:str = "Hello\nWorld\n!"
    print("原字符串: ", s2, "\n")
    result2:list = s2.splitlines()
    print("splitlines(): ", result2, "\n")
    
    items:list[str] = ["Hello", "World"]
    joined:str = ",".join(items)
    print("join(): ", joined, "\n")
}

原字符串: apple,banana,cherry
split(','): [apple, banana, cherry]
原字符串: Hello
World
!
splitlines(): [Hello, World, !]
join(): Hello,World

def main(args:list[str]) {
    s:str = "Hello World"
    print("原字符串: ", s, "\n")
    print("replace('World', 'CatBase'): ", s.replace("World", "CatBase"), "\n")
}

原字符串: Hello World
replace('World', 'CatBase'): Hello CatBase

def main(args:list[str]) {
    print("'hello'.islower(): ", "hello".islower(), "\n")
    print("'HELLO'.isupper(): ", "HELLO".isupper(), "\n")
    print("'Hello'.istitle(): ", "Hello".istitle(), "\n")
    print("'123'.isdigit(): ", "123".isdigit(), "\n")
    print("'abc'.isalpha(): ", "abc".isalpha(), "\n")
    print("'abc123'.isalnum(): ", "abc123".isalnum(), "\n")
    print("'   '.isspace(): ", "   ".isspace(), "\n")
    print("'123'.isnumeric(): ", "123".isnumeric(), "\n")
}

'hello'.islower(): true
'HELLO'.isupper(): true
'Hello'.istitle(): true
'123'.isdigit(): true
'abc'.isalpha(): true
'abc123'.isalnum(): true
'   '.isspace(): true
'123'.isnumeric(): true

def main(args:list[str]) {
    result:str = exec("echo hello")
    print("exec result: ", result, "\n")
}

exec result: hello

def main(args:list[str]) {
    print("Before sleep\n")
    sleep(1)
    print("After sleep\n")
}

Before sleep
After sleep

def main(args:list[str]) {
    t:float = time()
    print("Current timestamp: ")
    print(t)
}

Current timestamp: 1717412345.0

def main(args:list[str]) {
    start:float = perf_counter()
    # 模拟耗时操作
    s:int = 0
    for i in range(1000000) {
        s = s + i
    }
    end:float = perf_counter()
    print("Elapsed: ")
    print((end - start) / 1000000000.0, " seconds")
}