External packages

quadpm get https://github.com/quadrate-language/json

use json
use http

fn main() {
    // Use json module
    "{\"name\": \"test\"}" json::parse! -> obj

    // Use http module
    "https://api.example.com" http::get! -> response
}

# Install a single package
quadpm get https://github.com/quadrate-language/json

# Install a specific version/ref
quadpm get https://github.com/quadrate-language/json@v1.0.0

# Install all dependencies from qd.json
quadpm install

# List installed packages
quadpm list

# Update a package
quadpm update json

# Remove a package
quadpm remove json

use sqlite

fn main() {
    // Open in-memory database
    ":memory:" sqlite::open! -> db

    // Create table
    "CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, age INTEGER)"
    db sqlite::exec!

    // Insert data
    "INSERT INTO users (name, age) VALUES ('Alice', 30)"
    db sqlite::exec!

    // Query with prepared statement
    "SELECT id, name, age FROM users" db sqlite::prepare! -> stmt

    stmt sqlite::step! -> has_row
    has_row 1 == if {
        0 stmt sqlite::column_int -> id
        1 stmt sqlite::column_text -> name
        2 stmt sqlite::column_int -> age
        name print " is " print age print " years old" print nl
    }

    stmt sqlite::finalize
    db sqlite::close
}

use http

fn handle_root(c:ptr -- ) {
    -> c
    c 200 "Hello, World!" http::string
}

fn handle_users(c:ptr -- ) {
    -> c
    c "id" http::param -> id
    c 200 id http::string
}

fn main() {
    http::engine -> e

    // Register routes
    e "/" &handle_root http::GET
    e "/users/:id" &handle_users http::GET

    // Start server
    e ":8080" http::run
}

use json

fn main() {
    // Parse JSON
    "{\"name\": \"Alice\", \"age\": 30}" json::parse! -> obj

    // Access fields
    obj "name" json::get_string -> name
    obj "age" json::get_int -> age

    name print " is " print age print nl

    // Create JSON
    json::object -> person
    person "name" "Bob" json::set_string
    person "age" 25 json::set_int

    person json::stringify -> output
    output print nl
}

use net

fn main() {
    // TCP client
    "127.0.0.1" 8080 net::connect! -> sock

    "GET / HTTP/1.0\r\n\r\n" sock net::send!

    1024 sock net::recv! -> response
    response print nl

    sock net::close
}

use crypto

fn main() {
    "Hello, World!" -> msg

    msg crypto::sha256 -> hash
    "SHA256: " print hash print nl

    msg crypto::md5 -> md5_hash
    "MD5: " print md5_hash print nl

    msg crypto::crc32 -> checksum
    "CRC32: " print checksum print nl
}

use regex

fn main() {
    "hello123world" -> text
    "[0-9]+" regex::compile! -> re

    text re regex::match! if {
        "Found numbers" print nl
    }

    text re regex::find_all! -> matches
    matches len 0 do i {
        i matches nth print nl
    }

    re regex::free
}

use compress

fn main() {
    "Hello, World! This is a test string for compression." -> data

    // Compress
    data compress::gzip! -> compressed
    "Compressed size: " print compressed str::len print nl

    // Decompress
    compressed compress::gunzip! -> decompressed
    decompressed print nl
}