Standard Library

ZayneScript ships seven built-in modules accessible via the core: import prefix. Each module provides functions or a class that is loaded on demand — only import what you need.

core:io — Input / Output

Import with:

import { print, println, scan, parseNum, format,
         clearScreen, setColor, decompile } from "core:io";

print

print("x =", 42); // x = 42  (no newline)

println

println("Hello", "World"); // Hello World
println();                 // (blank line)

scan

const name = scan("Enter your name: ");
println("Hello,", name);

parseNum

const n = parseNum(scan("Enter a number: "));
println(n * 2);

format

const msg = format("Hello, {}! You are {} years old.", "Alice", 30);
println(msg); // Hello, Alice! You are 30 years old.

clearScreen

clearScreen();

setColor

setColor(32);          // green text
println("Success!");
setColor();            // reset

decompile

fn add(a, b) { return a + b; }
println(decompile(add));

core:math — Mathematics

Import with:

// Named imports
import { sqrt, pow, sin, cos, pi, e } from "core:math";

// Or wildcard — module bound as `math`
import "core:math";
println(math.sqrt(16)); // 4

Single-argument functions

Each accepts one numeric argument and returns a num:

Two-argument functions

Constants

import { sin, cos, sqrt, pow, pi, e } from "core:math";

println(sqrt(2));       // 1.4142135623730951
println(pow(2, 10));    // 1024
println(sin(pi / 2));   // 1
println(e);             // 2.718281828459045

core:os — Operating System Utilities

Import with:

import { getCwd, getPid, getUser, getType, system } from "core:os";

getCwd

println(getCwd()); // /home/alice/projects

getPid

println(getPid()); // 12345

getUser

println(getUser()); // alice

getType

if (getType() == "linux") {
    println("Running on Linux");
}

system

const code = system("ls -la");
println("exit:", code);

core:Array — Array Class

Import with:

import { Array } from "core:Array";

Array methods are available directly on every array literal via the prototype. You do not need to explicitly import core:Array to use the built-in methods — they are always present. Import it only when you need the Array class itself (e.g. to add static helpers at runtime).

push

const arr = [1, 2];
arr.push(3);
println(arr); // [1, 2, 3]

pop

const last = arr.pop();
println(last); // 3
println(arr);  // [1, 2]

length

println([10, 20, 30].length()); // 3

each

const nums    = [1, 2, 3, 4, 5];
const doubled = nums.each(fn(i, e) { return e * 2; });
println(doubled); // [2, 4, 6, 8, 10]

// Using a vararg function (index first, then element)
nums.each(println);
// 0 1
// 1 2
// 2 3 ...

keep

const evens = nums.keep(fn(i, e) { return e % 2 == 0; });
println(evens); // [2, 4]

Adding static helpers at runtime

Because Array is a first-class class value you can attach arbitrary static functions to it:

import { Array } from "core:Array";

Array.sum = fn(arr) {
    local total = 0;
    arr.each(fn(i, e) { total += e; });
    return total;
};

println(Array.sum([1, 2, 3, 4, 5])); // 15

core:Date — Date and Time

Import with:

import { Date } from "core:Date";
// Or wildcard:
import "core:Date";

Constructor

const now = new Date();
println(now.toString()); // e.g. Fri Apr 04 2026 14:30:00

const d1 = new Date("2023-12-25");
println(d1.getFullYear()); // 2023
println(d1.getMonth());    // 11  (0-based)
println(d1.getDate());     // 25

const d2 = new Date(2024, 0, 1, 12, 30, 45);
// year=2024, month=January(0), day=1, 12:30:45

const d3 = new Date(1705449600000); // from timestamp ms

Instance Getters

const d = new Date("2026-04-04T14:30:00");
println(d.getFullYear()); // 2026
println(d.getMonth());    // 3   (April = index 3)
println(d.getDate());     // 4
println(d.getDay());      // 6   (Saturday)
println(d.getHours());    // 14
println(d.getMinutes());  // 30
println(d.getSeconds());  // 0

getTime

println(new Date().getTime()); // e.g. 1743778200000

toString

println(new Date().toString());

core:Promise — Promises

Import with:

import { Promise } from "core:Promise";

Promises are created implicitly by calling any async function. You rarely construct them manually. The two instance methods below form the chaining API.

then

fn getData() async { return 42; }

getData()
    .then(fn(v) {
        println("value:", v); // value: 42
        return v * 2;
    })
    .then(fn(v) {
        println("doubled:", v); // doubled: 84
    });

error

fn mayFail() async {
    return somethingRisky();
}

mayFail()
    .then(fn(v) { println("Got:", v); })
    .error(fn(e) { println("Error:", e); });

Full async / Promise example

import { println } from "core:io";

fn step1() async { return "hello"; }
fn step2(s) async { return s + " world"; }

fn pipeline() async {
    const s = await step1();
    return await step2(s);
}

pipeline()
    .then(fn(result) {
        println(result); // hello world
    })
    .error(fn(e) {
        println("Failed:", e);
    });

core:sqlite — SQLite3 Database

Import with:

import { Database } from "core:sqlite";
// Or import both exported names:
import { Database, Statement } from "core:sqlite";

Overview

core:sqlite wraps the bundled SQLite3 amalgamation and exposes two classes:

• Database — represents an open SQLite connection.
• Statement — a compiled prepared statement returned by db.prepare(). You do not construct it directly.

Every new Database(...) call opens an independent connection. Multiple databases can be open simultaneously.

Database

Constructor

const db  = new Database("app.sqlite");   // file-based
const mem = new Database(":memory:");     // in-memory
const def = new Database();               // also in-memory

exec

db.exec(`
    CREATE TABLE IF NOT EXISTS users (
        id   INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT    NOT NULL,
        age  INTEGER
    );
`);

// Transactions
db.exec("BEGIN");
// ... statements ...
db.exec("COMMIT");

prepare

// One-shot INSERT — chain prepare().run()
const info = db.prepare("INSERT INTO users (name, age) VALUES (?, ?)").run("Alice", 30);
println(info.changes);         // 1
println(info.lastInsertRowid); // 1

// One-shot SELECT — chain prepare().all()
const rows = db.prepare("SELECT * FROM users WHERE age >= ?").all(18);
println(rows.length());

// Reusable statement
const stmt = db.prepare("SELECT * FROM users WHERE age >= ?");
const adults = stmt.all(18);
const first  = stmt.get(18);
stmt.finalize();

close

db.close();

Statement

A Statement is obtained via db.prepare(sql). Unlike the raw SQLite C API, you never call step / reset manually — the run / get / all methods handle the full lifecycle internally (modelled after better-sqlite3).

run

const r1 = db.prepare("INSERT INTO users (name, age) VALUES (?, ?)").run("Alice", 30);
println(r1.changes);         // 1
println(r1.lastInsertRowid); // 1

const r2 = db.prepare("UPDATE users SET age = ? WHERE name = ?").run(31, "Alice");
println(r2.changes); // 1

// Named parameters
const r3 = db.prepare("INSERT INTO users (name, age) VALUES (@name, @age)")
              .run({ name: "Bob", age: 25 });
println(r3.lastInsertRowid); // 2

get

const user = db.prepare("SELECT * FROM users WHERE id = ?").get(1);
println(user.name); // Alice
println(user.age);  // 31

// Named parameter
const byName = db.prepare("SELECT * FROM users WHERE name = @name")
                  .get({ name: "Bob" });
println(byName); // { id: 2, name: "Bob", age: 25 }

// Returns null when nothing matches
const missing = db.prepare("SELECT * FROM users WHERE id = ?").get(999);
println(missing); // null

all

const all = db.prepare("SELECT * FROM users").all();
all.each(fn(row, i) { println(row.id, row.name); });

// With a filter
const seniors = db.prepare("SELECT * FROM users WHERE age >= ?").all(30);
println(seniors.length());

// Reusable: call all() multiple times with different params
const stmt = db.prepare("SELECT * FROM users WHERE age >= ?");
println(stmt.all(18).length());
println(stmt.all(30).length());
stmt.finalize();

Type mapping

bind

// Positional permanent bind
const topUser = db.prepare("SELECT * FROM users WHERE id = ?").bind(1);
println(topUser.get()); // { id:1, name:"Alice", age:31 }
println(topUser.get()); // same result – statement is reused
topUser.finalize();

// Named permanent bind
const byName = db.prepare("SELECT * FROM users WHERE name = @name")
                  .bind({ name: "Bob" });
println(byName.get()); // { id:2, ... }
byName.finalize();

pluck

const stmt = db.prepare("SELECT id FROM users");

// Returns array of id values instead of array of objects
const ids = stmt.pluck().all();
ids.each(fn(id, i) { println(id); }); // 1  2  3 ...

stmt.pluck(false); // back to full row objects
const rows = stmt.all();

stmt.finalize();

columns

const stmt = db.prepare("SELECT id, name, age FROM users");
const cols = stmt.columns();
cols.each(fn(c, i) {
    println(c.name, c.type); // id INTEGER, name TEXT, age INTEGER
});
stmt.finalize();

finalize

stmt.finalize();

Common Patterns

In-memory scratch database

import { Database } from "core:sqlite";
import { println } from "core:io";

const db = new Database(":memory:");
db.exec("CREATE TABLE kv (key TEXT PRIMARY KEY, value TEXT)");

db.prepare("INSERT INTO kv VALUES (?, ?)").run("theme", "dark");

const row = db.prepare("SELECT value FROM kv WHERE key = ?").get("theme");
println(row.value); // dark
db.close();

Bulk insert wrapped in a transaction

import { Database } from "core:sqlite";

const db    = new Database("data.sqlite");
const names = ["Alice", "Bob", "Carol", "Dave", "Eve"];

db.exec("CREATE TABLE IF NOT EXISTS people (id INTEGER PRIMARY KEY, name TEXT)");
db.exec("BEGIN");

const stmt = db.prepare("INSERT INTO people (name) VALUES (?)");
names.each(fn(name, i) {
    stmt.run(name); // run() resets and re-executes automatically
});
stmt.finalize();

db.exec("COMMIT");
db.close();

Named parameters

// SQLite supports @name, :name, and $name placeholders.
// Pass a plain object to run / get / all to bind by name.
db.exec("CREATE TABLE IF NOT EXISTS products (id INTEGER PRIMARY KEY, sku TEXT, price NUM)");
db.prepare("INSERT INTO products (sku, price) VALUES (@sku, @price)")
  .run({ sku: "WIDGET-42", price: 9.99 });

const p = db.prepare("SELECT * FROM products WHERE sku = @sku")
             .get({ sku: "WIDGET-42" });
println(p.price); // 9.99

Pluck — collect a single column

const stmt = db.prepare("SELECT name FROM users ORDER BY name");
const names = stmt.pluck().all();
names.each(fn(n, i) { println(n); }); // Alice  Bob  Carol ...
stmt.finalize();

Multiple independent connections

const users  = new Database("users.sqlite");
const orders = new Database("orders.sqlite");
const cache  = new Database(":memory:");

// All three connections are fully independent.
users.close();
orders.close();
cache.close();

Error handling

import { Database } from "core:sqlite";
import { println } from "core:io";

const db = new Database(":memory:");
db.exec("CREATE TABLE t (id INTEGER PRIMARY KEY, val TEXT UNIQUE)");

try {
    db.prepare("INSERT INTO t VALUES (1, 'hello')").run();
    db.prepare("INSERT INTO t VALUES (1, 'hello')").run(); // duplicate PK
} catch (e) {
    println("Caught:", e);
}
db.close();

core:mongoose — HTTP Server

Import with:

import { Server } from "core:mongoose";

core:mongoose wraps the Mongoose embedded networking library to give ZayneScript an Express.js-style HTTP server. Create a Server, register routes, and call listen() — the event loop runs until close() is called.

Server class

constructor

import { Server } from "core:mongoose";
const app = new Server();

Routing

Route handlers receive (req, res) and are matched in registration order. The path is matched with Mongoose's glob patterns — use * as a wildcard segment.

app.get("/hello", fn(req, res) {
    res.send("Hello World!");
});

app.post("/users", fn(req, res) {
    res.status(201).json({ created: true });
});

Wildcard captures

Wildcards in the path are captured and exposed on req.params as numeric keys ("0", "1", …).

app.get("/users/*", fn(req, res) {
    const id = req.params["0"];  // e.g. "42" for /users/42
    res.json({ id: id });
});

listen / close

import { println } from "core:io";

app.listen(3000, fn(msg) {
    println(msg); // Server listening on port 3000
});

Request object

Available inside every route handler as the first argument.

Response object

Available inside every route handler as the second argument.

res.send(body)

res.json(value)

res.status(code)

res.redirect(url)

res.setHeader(name, value)

Middleware

import { println } from "core:io";

app.use(fn(req, res) {
    println(req.method, req.path);
});

Common Patterns

Simple REST-like API

import { Server } from "core:mongoose";
import { println } from "core:io";

const app = new Server();

app.get("/", fn(req, res) {
    res.send("Welcome!");
});

app.get("/greet/*", fn(req, res) {
    const name = req.params["0"];
    res.json({ message: "Hello, " + name + "!" });
});

app.post("/echo", fn(req, res) {
    res.setHeader("X-Echo", "true").send(req.body);
});

app.listen(8080, fn(msg) { println(msg); });

Request logging middleware

import { Server } from "core:mongoose";
import { println } from "core:io";

const app = new Server();

app.use(fn(req, res) {
    println("[" + req.method + "]", req.path);
});

app.get("/ping", fn(req, res) {
    res.send("pong");
});

app.listen(3000, fn(msg) { println(msg); });

JSON API with status codes

import { Server }  from "core:mongoose";
import { Database } from "core:sqlite";

const app = new Server();
const db  = new Database("app.sqlite");
db.exec("CREATE TABLE IF NOT EXISTS notes (id INTEGER PRIMARY KEY, text TEXT)");

app.get("/notes", fn(req, res) {
    const rows = db.prepare("SELECT * FROM notes").all();
    res.json(rows);
});

app.post("/notes", fn(req, res) {
    const info = db.prepare("INSERT INTO notes (text) VALUES (?)").run(req.body);
    res.status(201).json({ id: info.lastInsertRowid });
});

app.listen(4000, fn(msg) { println(msg); });