CatBase

# Python - indentation issue example
def main():
    if True:
        print("Hello")  # Missing one space of indentation may cause a syntax error
    else:
        print("World")

# CatBase - brace-delimited code blocks
def main(args:list[str]) {
    if True {
        print("Hello")  # Braces clearly define the scope of the block
    } else {
        print("World")
    }
}

# Python - variable types are unclear
name = "Tom"          # string
age = 25              # integer
items = [1, 2, 3]    # list
# Programmers must read the code to infer variable types

# CatBase - explicit variable types
name:str = "Tom"           # string type
age:int = 25               # integer type
items:list[int] = [1, 2, 3]  # list of integers type
# Variable types are clear at a glance, improving code readability

#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!

# Compile source file
catcc source.cat

# Compile and run
catcc source.cat && ./source

# Or
catcc run source.cat

$ catcc -v
CatBase Compiler (catcc) 0.0.11

# 1. Manual version check
catcc -v
# → CatBase Compiler (catcc) 0.0.11

# 2. Version check in shell scripts
if [[ "$(catcc -v)" != *"0.0.11"* ]]; then
    echo "Requires catcc 0.0.11 or higher"
    exit 1
fi

# 3. CI minimum version assertion
REQUIRED="CatBase Compiler (catcc) 0.0.11"
if [[ "$(catcc --version)" != "$REQUIRED" ]]; then
    echo "CatBase version mismatch, requires $REQUIRED"
    exit 1
fi

# Do not generate .o file during compilation
catcc -no-emit-obj source.cat

# Generate shared library
catcc -shared mylib.cat

# Static linking (suitable for minimal resource environments, such as embedded systems)
catcc -static source.cat

# Generate the smallest executable
catcc -O ReleaseSmall source.cat

# Safety first (with runtime checks)
catcc -O ReleaseSafe source.cat

# Specify output file name
catcc -o myprogram source.cat

# Generate a minimal-size statically linked executable (about 13 KB)
catcc -static -O ReleaseSmall source.cat

import "./libmysqlclient.so"

def main(args:list[str]) {
    # Connect to the database...
}

catcc -static source.cat

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

# Dynamic linking (default)
catcc source.cat
# Generated source depends on: libc.so, libm.so, etc.

# Static linking
catcc -static source.cat
# Generated source does not depend on any dynamic libraries

# View the dynamic library dependencies of the executable
ldd ./source

# Statically linked executable
ldd ./source
# Output: "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*\()'

# Copy the entire folder to the extensions directory
cp -r vscode-extension ~/.vscode/extensions/catbase

# Windows can use:
# xcopy /E /I vscode-extension "%USERPROFILE%\.vscode\extensions\catbase"

cd vscode-extension
code --install-extension .

variable_name:type = initial_value

def main(args:list[str]) {
    # integer type
    age:int = 25

    # float type
    price:float = 19.99

    # string type
    name:str = "CatBase"

    # boolean type
    is_active:bool = True

    # byte type (0-255 integer)
    ascii_a:byte = byte(65)         # 'A' ASCII code
    ascii_z:byte = byte(90)         # 'Z' ASCII code

    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 constructor
    b1:byte = byte(65)        # 65
    b2:byte = byte(255)       # 255 (max)
    b3:byte = byte(0)         # 0 (min)
    b4:byte = byte(None)      # 0

    # Single-character bytes literal (Method C - auto-promotes to byte)
    b5:byte = b"A"            # 65 ('A')
    b6:byte = b"Z"            # 90 ('Z')
    b7:byte = b"\xFF"         # 255 (hex escape)
    b8:byte = b"\x00"         # 0 (null byte)

    # byte ↔ int automatic conversion
    n:int = 100
    b9:byte = n               # int → byte (automatic)
    n2:int = b9               # byte → int (automatic)

    # byte with chr
    c:str = chr(byte(65))     # "A"
    c2:str = chr(b5)          # "A" (literal also works)

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

# Error example - cannot use built-in function names
def file() -> int {  # Compile error!
    return 1
}

# Error example - cannot use built-in type names
def main(args:list[str]) {
    Thread:Thread = 1  # Compile error!
}

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]) {
    # list type
    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]) {
    # dictionary type
    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 client
    sock:TCPSocket = tcpsocket()
    sock.connect("example.com", 80)

    # TCP server
    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 client
    ws:WebSocket = websocket("ws://example.com/ws", None)

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

    # Configuration file
    cfg:Config = config("app.conf")

    # File object
    f:File = file("test.txt", "r")

    # Audio stream
    stream:RecordStream = recordStream(rate=16000, channels=1)

    # Resources need to be closed after use
    client.close()
    ws.close()
    ser.close()
    f.close()
    stream.close()
}

q:Queue = queue(maxsize)  # maxsize of 0 means an unlimited queue

def producer(q:Queue) {
    i:int = 0
    while i < 5 {
        msg:str = str(i * 100)
        q.put(msg, -1)  # blocking wait to put
        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()  # wait for all tasks and threads to complete
    print("Test completed!\n")
}

def main(args:list[str]) {
    x = 10  # Error: must explicitly declare the type
}

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

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

variable_name:type = initial_value

# Global variable declaration (outside functions)
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 function_name(parameter:type, ...) -> return_type {
    # function body
    return value
}

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")
    
    # Iterate through all arguments
    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

# Compile
catcc hello.cat

# Run with arguments
./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] is the program name
    }
}

./myprog hello world
# Output:
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, runs normally
./test_main_simplified a b c       # OK, a b c are ignored
./test_main_simplified --help      # OK, --help is ignored

# ===== Full form (receives arguments) =====
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
    }
}

# ===== Simplified form (no arguments) =====
def main() {
    print("This is a simple program with no command-line arguments.\n")
}

def main(args:list[str]) {
    # This is a comment
    print("Hello")  # This is also a comment
}

Hello

def main(args:list[str]) {
    /*
     * This is a
     * multi-line comment
     */
    print("Hello")
}

Hello

def main(args:list[str]) {
    """
    This is a
    triple-quote comment
    """
    print("Hello")
}

Hello

def main(args:list[str]) {
    // This is a comment
    print("Hello")  // This is also a comment
}

Hello

def main(args:list[str]) {
    # Simple code block
    {
        x:int = 10
        print("x = ", x, "\n")
    }
    
    # Code block in conditional statement
    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

# Use subtypes to declare external functions, exactly matching C function signatures
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
    
    # Basic f-string usage
    msg:str = f"Hello, {name}!"
    print(msg, "\n")
    
    # Embed multiple variables
    info:str = f"{name} version {version}"
    print(info, "\n")
    
    # Embed expressions
    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]) {
    # Create a list
    nums:list[int] = [1, 2, 3, 4, 5]
    
    # Access elements
    print("First: ", nums[0], "\n")
    print("Last: ", nums[4], "\n")
    
    # Modify elements
    nums[0] = 10
    print("Modified: ", nums, "\n")
    
    # List length
    print("Length: ", len(nums), "\n")
}

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

def main(args:list[str]) {
    # Create a dictionary
    person:dict[str, str] = {"name": "Tom", "age": "20", "city": "Beijing"}
    
    # Access values
    print("Name: ", person["name"], "\n")
    print("Age: ", person["age"], "\n")
    
    # Modify values
    person["age"] = 21
    print("Updated: ", person, "\n")
    
    # Add new key-value pairs
    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]) {
    # Create ASCII bytes
    data:bytes = b"Hello"
    print(data)
    print("\n")

    # Create bytes containing hexadecimal data
    # \xHH represents a hexadecimal byte value
    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 data - uses static pool
    small:bytes = bytes_alloc(64)       # static pool
    print("small bytes: ", len(small), "\n")

    # Large data - uses heap
    large:bytes = bytes_alloc(100000)   # heap allocation

    # 1MB image data
    image:bytes = bytes_alloc(1920 * 1080 * 3)  # 1080p RGB

    # Must explicitly free
    bytes_free(small)
    bytes_free(large)
    bytes_free(image)
}

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

    # Write data
    data[0] = byte(72)   # 'H'
    data[1] = byte(101)  # 'e'
    data[2] = byte(108)  # 'l'

    # Read data
    b:byte = data[0]   # 72
    print("data[0] = ", b, "\n")

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

    bytes_free(data)
}

def main(args:list[str]) {
    # str → bytes
    s:str = "Hello"
    b:bytes = bytes(s)         # copy data, bytes has independent memory
    print("b[0] = ", b[0], "\n")  # 72

    # bytes → str
    s2:str = str(b)             # copy data, str has independent memory
    print("s2 = ", s2, "\n")   # "Hello"

    # None conversion
    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 returns data pointer
    data:bytes = bytes_alloc(100)
    data[0] = byte(65)   # 'A'

    p:Pointer = pointer_of(data)   # points to data[0], directly passable to C
    if !p.is_null() {
        v:byte = p.get(byte)
        print("p.get(byte) = ", v, "\n")

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

    # int: pointer_of returns variable address
    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]) {
    # Single character → byte type
    b1:byte = b"A"             # 65
    b2:byte = b"\xFF"          # 255

    # Multi-character → bytes type
    bs1:bytes = b"Hello"        # [72, 101, 108, 108, 111]
    bs2:bytes = b"\x01\x02\x03"  # [1, 2, 3]

    # Use literals directly when assigning to bytes arrays
    buf:bytes = bytes_alloc(5)
    buf[0] = b"H"              # 72
    buf[1] = b"e"              # 101
    buf[2] = b"\x6C"           # 108 ('l')

    # Fully equivalent to the byte() constructor
    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" (empty)

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

    # Send text data
    ser.write(b"Hello, Serial!\n")

    # Send binary protocol data (Modbus example)
    # Frame format: device address(1) + function code(1) + data(N) + CRC(2)
    modbus_frame:bytes = b"\x01\x03\x00\x00\x00\x0A"
    ser.write(modbus_frame)

    # Read response
    data:str = ser.read(1024)
    print("Received: ")
    print(data)
    print("\n")

    # Close serial port
    ser.close()
    print("Serial port closed\n")
}

Serial port opened successfully
Serial port closed

def main(args:list[str]) {
    # Construct the first 20 bytes of the IP header
    version_ihl:bytes = b"\x45"      # Version(4) + Header length(5)
    tos:bytes = b"\x00"              # Type of service
    total_length:bytes = b"\x00\x14"  # Total length (20)
    identification:bytes = b"\x00\x00" # Identification
    flags_offset:bytes = b"\x40\x00"  # Flags + Fragment offset
    ttl:bytes = b"\x40"              # Time to live (64)
    protocol:bytes = b"\x06"         # Protocol (TCP)
    checksum:bytes = b"\x00\x00"      # Checksum
    src_ip:bytes = b"\xC0\xA8\x01\x01" # Source IP (192.168.1.1)
    dst_ip:bytes = b"\xC0\xA8\x01\x02" # Destination IP (192.168.1.2)

    # Combine the complete IP header
    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

# Test that any type can store values of various types
def main(args:list[str]) {
    # Create an any type variable, initialized to None
    x: any = None
    print("x (None) =", str(x), ", type =", type(x))

    # Store a string
    x = "hello"
    print("x (str) =", str(x), ", type =", type(x))

    # Store an integer
    x = 42
    print("x (int) =", str(x), ", type =", type(x))

    # Store a float
    x = 3.14
    print("x (float) =", str(x), ", type =", type(x))

    # Store a boolean
    x = True
    print("x (bool) =", str(x), ", type =", type(x))

    # Store a list
    x = [1, 2, 3]
    print("x (list) =", x, ", type =", type(x))

    # Store a dict
    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 parsing returns dict[str, any]
    data: dict[str, any] = {"name": "Alice", "age": 25, "score": 95.5}

    # Use any type to receive the return value of get
    name: any = data.get("name")
    age: any = data.get("age")
    missing: any = data.get("missing")   # Non-existent key returns None

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

    # Extract specific types from any values
    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]) {
    # Multiple branches to handle different types
    x: any = "hello"
    if x is int {
        print("integer:", x + 1, "\n")          # x is narrowed to int here
    } else if x is str {
        print("string:", str(len(x)), "\n")  # x is narrowed to str here
    } else if x is None {
        print("null value\n")
    } else {
        print("other type:", str(type(x)), "\n")
    }
}

def main(args: list[str]) {
    # Use the value after excluding None
    x: any = 42
    if x is not None {
        if x is int {
            print("non-null int:", x * 2, "\n")
        }
    }
}

def main(args: list[str]) {
    # Extract nested structures from dict[str, any] with multiple guards
    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("user name:", 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("other type\n") }
    }
}

def main(args: list[str]) {
    x: any = "world"
    s: str = str(x)     # Direct conversion, no guard needed
    print(s, "!\n")     # Output: world!
}

def main(args: list[str]) {
    # Method 1: assign directly after guard (recommended)
    x: any = 42
    if x is int {
        n: int = x       # Already confirmed int, assign directly
        print("n =", n, "\n")
    }

    # Method 2: without guard, int(any) returns 0 (default behavior)
    y: any = "100"
    m: int = int(y)      # y is not int, returns 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() works normally after the guard
        if b {
            print("non-empty string is treated as true\n")
        }
    }
}

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

    # Basic field access + guard
    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")   # Can directly add 1 after guard
    }

    # Nested structure
    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]

    # Branch on type during iteration
    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]) {
    # Outer dict's value is a list, list elements are 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]   # Index access
        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]: can call .put after guard; list: can call .append after guard
    d: dict[str, any] = {"a": 1}
    if d is dict {
        d.put("b", 2)             # .put can be called after guard
    }

    xs: list[any] = [1, 2]
    if xs is list {
        xs.append(3)              # .append can be called after guard
    }
    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")   # Use directly after guard
    } 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            # store int
    x = "now string"        # reassign to str
    x = [1, 2, 3]           # reassign to list
    x = {"k": "v"}          # reassign to dict
    print("final type:", str(type(x)), "\n")  # any:dict
}

def main(args: list[str]) {
    # typed → any → typed (information not lost)
    n: int = 42
    x: any = n              # int → any
    if x is int {
        m: int = x          # any → int
        print("round trip:", m, "\n")
    }

    # Container: dict[str, int] → any → take back and modify
    d: dict[str, int] = {"a": 1, "b": 2}
    x = d
    if x is dict {
        x.put("c", 3)        # can put after guard
        print("modified:", str(len(x)), "\n")  # 3
    }
}

def main(args:list[str]) {
    # String to integer
    n:int = int("42")
    print("int('42') = ", n, "\n")
    
    # Integer to string
    s:str = str(123)
    print("str(123) = '", s, "'\n")
    
    # Integer to float
    f:float = float(10)
    print("float(10) = ", f, "\n")
    
    # String to float
    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

# Declared with struct
struct Point {
    x: int
    y: int
}

# Declared with class (completely equivalent to above)
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")           # ← call set.add() on field `key`
    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}
    }
    # call methods on struct fields
    d.ids.add(4)
    d.names.append("carol")
    d.config["max"] = 100
    # nested set() constructors automatically infer from field types
    d.ids.contains(1)            # true
    d.names.len()                # 3
    print(d)
}

struct Profile {
    friends: set[str]    # friends (auto-dedup)
    blocked: set[str]    # block list (auto-dedup)
}

def main() {
    alice: Profile = Profile {
        friends: set(["bob", "carol", "bob", "dave"]),    # duplicate "bob" auto-dedup
        blocked: set(["eve", "mallory"])
    }
    print(alice.friends)         # {'carol', 'dave', 'bob'}
    print(alice.blocked)         # {'eve', 'mallory'}

    # Call methods on fields directly: the compiler automatically
    # promotes alice to var and adds @constCast to alice.friends.
    alice.friends.add("frank")
    alice.friends.add("carol")   # duplicate, set already has it
    print(alice.friends)         # {'carol', 'dave', 'bob', 'frank'}

    # query APIs
    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'}

    # chained access: box.inner.tags infers set[str] from Inner.tags
    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 elements may be struct, sidesteps the recursive struct restriction
}
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"]) },     # duplicate "a" dedup
                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() {
    # ❌ Error: missing struct name "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() {
    # ✅ Correct: include the struct name explicitly
    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"
    }
}

// Using composition for "Dog contains Animal" (instead of "Dog inherits Animal")
class Dog {
    animal: Animal      // Composition: Dog internally contains an 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)          // Access composed object's field
}

def main(args:list[str]) {
    # Any type can be initialized with 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

    # Use is None to check for emptiness
    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 values can be printed directly
    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

    # Assign real values
    xint = 1
    ystr = "1"
    xfloat = 1
    xbool = True
    xbyte = b"A"
    xbytes = b"hello"
    xany = "a"
    xlist = [1, 2]
    xdict = {"b": "AAA"}

    # Use is not None to check whether a value has been assigned
    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] returns 0 when key not found
    data: dict[str, int] = {"b": 1}
    v: int = data.get("a")
    print(v)         # 0

    # dict[str, any] returns None when key not found
    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]) {
    # Create an any variable, initialized to None
    x: any = None
    print("x (None) =", str(x), ", type =", type(x))   # x (None) = None , type = any:None

    # Fetch a missing key from dict[str, any]
    data: dict[str, any] = {"name": "Alice"}
    missing: any = data.get("missing")
    if missing is None {
        print("missing key returns None")              # hit
    }
}

def greet(name: str) {       # no return type
    print("Hello,", name)
    # implicitly returns 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]                # ← declared as any
        name: any = nd.get("name", "")  # ← compile error: cannot call method on 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]    # ← use concrete type dict[str, any]
        name: any = nd.get("name", "")  # ← .get() is now allowed
        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

# ===== Bad: calling method on any =====
def bad_example(data: list[any]) {
    item: any = data[0]
    return item.get("name", "")   # compile error
}

# ===== Warning: indexing into any =====
def warning_example(data: list[any]) {
    item: any = data[0]
    return item["name"]           # soft warning
}

# ===== Good: use a concrete type =====
def good_example(data: list[dict[str, any]]) {
    item: dict[str, any] = data[0]
    return item.get("name", "")   # OK
}

# ===== Flexible but controlled: any + conversion =====
def flex_example(data: list[any]) {
    item: any = data[0]
    return str(item)              # OK: built-in function, not a method
}

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

    # √ Recommended: use directly after guard
    if x is int {
        n: int = x          # Direct assignment to int, no int(x) needed
        print("n + 10 =", n + 10, "\n")
    }

    # × Redundant: converting again after the guard
    if x is int {
        n: int = int(x)     # Redundant conversion; compiler allows but it's unnecessary
    }
}

def main(args: list[str]) {
    # Safe to use after checking "is not None"
    x: any = 42
    if x is not None {
        if x is int {
            print(x, "\n")
        }
    }
}

def main(args: list[str]) {
    # Standard pattern for handling nested dict[str, any] structures
    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"]}
    }

    # Standard access pattern: get → guard → recurse
    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]) {
    # Iterate a mixed-type 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 {
    # Given a path list, drill down layer by layer
    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
    }
}

# Return value can be str / int / None (caller must guard)
def lookup(key: str) -> any {
    if key == "name" {
        return "Alice"
    } else if key == "age" {
        return 30
    }
    return None
}

# Accept any type, print its type and value
def inspect(x: any) {
    print("type =", str(type(x)), ", value =", str(x), "\n")
}

# × Anti-pattern
def bad(data: any) {
    return data.get("name")   # Error: cannot call method on any
}

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

# × Anti-pattern
def bad(x: any) -> any {
    if x is int {
        return x          # Already narrowed to int; no need to convert back to any
    }
    return None
}

# √ Correct
def good(x: any) -> int {
    if x is int {
        return x
    }
    return 0
}

# × Compile error
def bad(x: any) {
    return len(x)         # Error: any has no len() method
}

# √ Correct
def good(x: any) {
    if x is str {
        return len(x)     # len() works after guard
    }
    return 0
}

# × Wrong expectation
def bad(x: any) {
    return int(x)         # If x is actually "123", returns 0 (does not parse the string)
}

# √ Correct
def good(x: any) {
    if x is str {
        return int(x)     # Only after the guard does int() parse the string
    }
    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    # Equivalent to a = a + 5
    print("a += 5: ", a, "\n")
    
    a -= 3    # Equivalent to a = a - 3
    print("a -= 3: ", a, "\n")
    
    a *= 2    # Equivalent to a = a * 2
    print("a *= 2: ", a, "\n")
    
    a /= 4    # Equivalent to 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")
    
    # Use in conditional statements
    if "age" in data {
        print("Age exists!\n")
    }
    
    # Combined with 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]) {
    # Multiplication and division take precedence over addition and subtraction
    print("2 + 3 * 4 = ", 2 + 3 * 4, "\n")
    
    # Parentheses can change precedence
    print("(2 + 3) * 4 = ", (2 + 3) * 4, "\n")
    
    # Logical operations
    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("Adult\n")
    } else {
        print("Minor\n")
    }
}

Adult

def main(args:list[str]) {
    test_str:str = "hello"
    
    if test_str {
        print("String is not empty\n")
    }
    
    empty_str:str = ""
    if empty_str {
        print("String is not empty\n")
    } else {
        print("String is empty\n")
    }
}

String is not empty
String is empty

def main(args:list[str]) {
    score:int = 85
    
    if score >= 90 {
        print("Excellent\n")
    } else if score >= 80 {
        print("Good\n")
    } else if score >= 60 {
        print("Pass\n")
    } else {
        print("Fail\n")
    }
}

Good

def main(args:list[str]) {
    x:int = 10
    y:int = 20
    
    if x > 0 {
        if y > 0 {
            print("Both x and y are positive\n")
        } else {
            print("x is positive, y is negative\n")
        }
    } else {
        print("x is negative\n")
    }
}

Both x and y are positive

def main(args:list[str]) {
    # Iterate over a list
    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]) {
    # Iterate over a range
    for i in range(5) {
        print("i = ", i, "\n")
    }
}

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

def main(args:list[str]) {
    # Send an HTTP request (streaming mode)
    url:str = "http://localhost:19090/v1/chat/completions"
    data:dict[str,any] = {
        "model": "qwen",
        "messages": [{"role": "user", "content": "Hello"}],
        "stream": true
    }
    
    # Use stream=True to enable streaming mode
    response:Response = http_post(url, json=data, stream=True)
    
    # Check response status
    response.raise_for_status()
    
    # Iterate to read the streaming response
    for line in response.iter_lines() {
        print(line)
    }
}

data: {"id":"chatcmpl-xxx","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"Hello"},"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": "Hello"}],
        "stream": true
    }
    
    response:Response = http_post(url, json=data, stream=True)
    response.raise_for_status()
    
    # Parse the streaming response
    for line in response.iter_lines() {
        line_str:str = line
        if line_str.startswith("data: ") {
            # Extract the JSON part
            data_json:str = line_str[6:]
            
            # Parse JSON
            data_dict:dict = json_loads(data_json)
            
            # Check the choices field
            if "choices" in data_dict and data_dict["choices"] {
                # Get the content from delta
                delta:dict = data_dict["choices"][0].get("delta", {})
                content:any = delta.get("content", "")
                
                # Convert to string and print
                content_str:str = str(content)
                print(content_str, end="", flush=True)
            }
        }
    }
}

Hello! How can I help you?

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 example
    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")
        # Simulate an error here
    }
    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 {
        # Ensure the recording stream is closed and resources are released
        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

# Method 1: Explicitly specify the element type
def get_list1() -> list[int] {
    return [1, 2, 3, 4, 5]
}

# Method 2: Implicitly infer the element type
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("Method 1: ", result1, "\n")
    print("Method 2: ", result2, "\n")
}

Method 1:  [1, 2, 3, 4, 5] 
Method 2:  [1, 2, 3, 4, 5] 

# Method 1: Explicitly specify key-value types
def get_dict1() -> dict[str, int] {
    d:dict[str, int] = {"a": 1, "b": 2, "c": 3}
    return d
}

# Method 2: Implicitly infer key-value types
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("Method 1: ", result1, "\n")
    print("Method 2: ", result2, "\n")
    print("result1[\"a\"] = ", result1["a"], "\n")
    print("result2[\"y\"] = ", result2["y"], "\n")
}

Method 1:  {'a': 1, 'b': 2, 'c': 3} 
Method 2:  {'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) {
    # The callback function will be invoked
    callback(bytes("test data"))
}

def main(args:list[str]) {
    # Pass the on_audio_frame function as a parameter
    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 without a newline
    print("Hello ", end="", flush=True)
    print("World!", end="", flush=True)
    
    # Use the default newline
    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]) {
    # Parse a JSON string
    json_str:str = "{\"name\": \"Alice\", \"age\": 30, \"score\": 95.5}"
    data:dict = json_loads(json_str)
    
    # Extract values and convert to strings
    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]) {
    # Use None to represent a null value in CatBase
    value:any = None
    
    # Check whether it is null
    if value == None {
        print("Value is None\n")
    }
}

### 7.4 Base Conversion Functions

#### bin

`bin(x:int) : str` - Convert to binary

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")
    # Also accepts 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]) {
    # char ↔ integer
    c1:str = chr(65)        # "A"
    n1:int = ord("Z")       # 90
    print(c1, " has code ", n1, "\n")

    # string ↔ integer
    s1:str = str(65)        # "65"
    n2:int = int("42")      # 42
    print(s1, " + ", n2, " = ", int(s1) + n2, "\n")

    # byte type
    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("Original string: ", s, "\n")
    print("upper(): ", s.upper(), "\n")
    print("lower(): ", s.lower(), "\n")
    print("capitalize(): ", s.capitalize(), "\n")
    print("title(): ", s.title(), "\n")
}

Original string: Hello World
upper(): HELLO WORLD
lower(): hello world
capitalize(): Hello world
title(): Hello World

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

Original string: '   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("Original string: ", 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")
}

Original string: 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"
    
    # From index 6 to the end
    result1:str = s[6:]
    print("s[6:]: ", result1, "\n")
    
    # From index 0 to index 5 (exclusive)
    result2:str = s[0:5]
    print("s[0:5]: ", result2, "\n")
    
    # From index 6 to index 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("Original string: ", s, "\n")
    result:list = s.split(",")
    print("split(','): ", result, "\n")
    
    s2:str = "Hello\nWorld\n!"
    print("Original string: ", s2, "\n")
    result2:list = s2.splitlines()
    print("splitlines(): ", result2, "\n")
    
    items:list[str] = ["Hello", "World"]
    joined:str = ",".join(items)
    print("join(): ", joined, "\n")
}

Original string: apple,banana,cherry
split(','): [apple, banana, cherry]
Original string: Hello
World
!
splitlines(): [Hello, World, !]
join(): Hello,World

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

Original string: 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)
}