array

import tinox.core.array;

The array module provides the helper class Arrays that encapsulates frequently needed operations on List<Int64>: searching, statistics (min, max, sum, average), transformations (reverse, filter), sorting via bubble sort, and generating ranges and prefilled lists.

Classes & Methods

Example

import tinox.core.array;

class Main
{
    fnc main() -> Int32
    {
        let zahlen: List<Int64> = [-3, 7, 2, -1, 5, 0, 9];

        let pos: List<Int64> = Arrays::filterPositive(zahlen);
        // pos = [7, 2, 5, 9]

        let sortiert: List<Int64> = Arrays::bubbleSort(pos);
        // sortiert = [2, 5, 7, 9]

        let min: Int64 = Arrays::findMin(sortiert);   // 2
        let max: Int64 = Arrays::findMax(sortiert);   // 9
        let s: Int64   = Arrays::sum(sortiert);       // 23
        let avg: Int64 = Arrays::average(sortiert);   // 5

        let idx: Int64 = Arrays::indexOfInt(sortiert, 7);  // 2
        let hat5: Bool = Arrays::containsInt(sortiert, 5); // true

        let rev: List<Int64> = Arrays::reverseInt(sortiert);
        // rev = [9, 7, 5, 2]

        let r: List<Int64>   = Arrays::range(1, 6);   // [1,2,3,4,5]
        let f: List<Int64>   = Arrays::fill(0, 4);    // [0,0,0,0]
        let ok: Bool         = Arrays::isSorted(sortiert); // true
        return 0;
    }
}

collections

import tinox.core.collections;

The collections module provides three generic data structures: a LIFO Stack<T>, a FIFO Queue<T>, and an ordered value pair Pair<T, U>. The factory class Collections contains shorthand methods for creating them.

Classes & Methods

Example

import tinox.core.collections;

class Main
{
    fnc main() -> Int32
    {
        // Stack-Verwendung
        let s: Stack<Int64> = Stack<Int64>::new();
        s.push(10);
        s.push(20);
        s.push(30);
        let top: Int64 = s.peek();   // 30
        let popped: Int64 = s.pop();    // 30
        let groesse: Int64 = s.size(); // 2

        // Queue-Verwendung
        let q: Queue<String> = Collections::newQueue<String>();
        q.enqueue("alpha");
        q.enqueue("beta");
        q.enqueue("gamma");
        let erstes: String = q.dequeue(); // "alpha"
        let leer: Bool     = q.isEmpty(); // false

        // Pair-Verwendung
        let p: Pair<String, Int64> = Collections::newPair<String, Int64>("Alter", 42);
        let schluessel: String = p.getFirst();  // "Alter"
        let alter: Int64       = p.getSecond(); // 42
        return 0;
    }
}

heap

import tinox.core.heap;

The heap module implements a generic binary heap (Heap<T>) with a customizable comparator, as well as the pre-built specializations MinHeap<T> (smallest element first) and MaxHeap<T> (largest element first). The internal helper methods siftUp, siftDown, and buildHeap are also available.

Classes & Methods

Example

import tinox.core.heap;

class Main
{
    fnc main() -> Int32
    {
        // Min-Heap: kleinstes Element zuerst
        let min: MinHeap<Int64> = MinHeap<Int64>::new();
        MinHeap::push(min, 5);
        MinHeap::push(min, 1);
        MinHeap::push(min, 3);
        let smallest: Int64  = MinHeap::peek(min);  // 1
        let removed: Int64   = MinHeap::pop(min);   // 1
        let nextOne: Int64   = MinHeap::pop(min);   // 3

        // Max-heap: largest element first
        let max: MaxHeap<Int64> = MaxHeap<Int64>::new();
        MaxHeap::push(max, 5);
        MaxHeap::push(max, 1);
        MaxHeap::push(max, 8);
        let largest: Int64 = MaxHeap::pop(max);   // 8

        // Generic heap with custom comparator (min-heap for Float64)
        let cmp: fnc(Float64, Float64) -> Bool = fnc(a: Float64, b: Float64) -> Bool { return a < b; };
        let h: Heap<Float64> = Heap<Float64>::newWithCompare(cmp);
        Heap::push(h, 3.14);
        Heap::push(h, 1.41);
        let leer: Bool = Heap::isEmpty(h);         // false
        let anz: Int64 = Heap::size(h);            // 2

        // buildHeap: build heap from list
        let h2: Heap<Int64> = Heap<Int64>::new();
        Heap::buildHeap(h2, [9, 4, 7, 2, 6]);
        let root: Int64 = Heap::peek(h2);        // 2
        return 0;
    }
}

queue

import tinox.core.queue;

The queue module provides two specialized queue types. PriorityQueue<T> orders elements by an integer priority value (lower number = higher priority). CircularBuffer<T> is a ring-buffer-like buffer with fixed capacity that accepts no further elements when full.

Classes & Methods

Example

import tinox.core.queue;

class Main
{
    fnc main() -> Int32
    {
        // Priority queue
        let pq: PriorityQueue<String> = PriorityQueue<String>::new();
        PriorityQueue::enqueue(pq, "Low",      10);
        PriorityQueue::enqueue(pq, "Critical",   1);
        PriorityQueue::enqueue(pq, "Medium",     5);

        let first: String  = PriorityQueue::dequeue(pq); // "Critical"
        let second: String  = PriorityQueue::dequeue(pq); // "Medium"
        let size: Int64     = PriorityQueue::size(pq);    // 1

        // Ring buffer with capacity 3
        let buf: CircularBuffer<Int64> = CircularBuffer<Int64>::new(3);
        let ok1: Bool = CircularBuffer::push(buf, 100); // true
        let ok2: Bool = CircularBuffer::push(buf, 200); // true
        let ok3: Bool = CircularBuffer::push(buf, 300); // true
        let ok4: Bool = CircularBuffer::push(buf, 400); // false – full

        let voll: Bool  = CircularBuffer::isFull(buf);  // true
        let wert: Int64 = CircularBuffer::pop(buf);     // 100
        let leer: Bool  = CircularBuffer::isEmpty(buf); // false
        return 0;
    }
}

set

import tinox.core.set;

The set module provides the generic class Set<T> that implements an ordered set without duplicates. In addition to basic operations (add, remove, contains check), the class supports classic set operations: union, intersection, difference, and subset check.

Classes & Methods

Example

import tinox.core.set;

class Main
{
    fnc main() -> Int32
    {
        let a: Set<Int64> = Set<Int64>::new();
        Set::add(a, 1);
        Set::add(a, 2);
        Set::add(a, 3);
        Set::add(a, 2); // Duplikat – wird ignoriert

        let b: Set<Int64> = Set<Int64>::new();
        Set::add(b, 2);
        Set::add(b, 3);
        Set::add(b, 4);

        let u: Set<Int64> = Set::union(a, b);        // {1,2,3,4}
        let s: Set<Int64> = Set::intersection(a, b); // {2,3}
        let d: Set<Int64> = Set::difference(a, b);   // {1}

        let enthalten: Bool = Set::contains(a, 3);    // true
        let groesse: Int64  = Set::size(a);            // 3

        let c: Set<Int64> = Set<Int64>::new();
        Set::add(c, 2);
        Set::add(c, 3);
        let teilmenge: Bool = Set::isSubsetOf(c, a);  // true

        let entfernt: Bool  = Set::remove(a, 1);       // true
        let leer: Bool      = Set::isEmpty(a);         // false
        return 0;
    }
}

sort

import tinox.core.sort;

The sort module provides the Sort class with three classic sorting algorithms for List<Int64>: Quicksort (average O(n log n), in-place via partition), Merge Sort (stable, splits and merges recursively), and Insertion Sort (efficient for small or nearly sorted lists). All methods return the sorted list.

Classes & Methods

Example

import tinox.core.sort;

class Main
{
    fnc main() -> Int32
    {
        let daten: List<Int64> = [64, 25, 12, 22, 11];

        // Quicksort
        let qs: List<Int64> = Sort::quickSort(daten);
        // qs = [11, 12, 22, 25, 64]

        // Merge-Sort
        let ms: List<Int64> = Sort::mergeSort(daten);
        // ms = [11, 12, 22, 25, 64]

        // Insertion sort (good for small lists)
        let small: List<Int64> = [5, 3, 1, 4, 2];
        let is: List<Int64> = Sort::insertionSort(small);
        // is = [1, 2, 3, 4, 5]

        // Manual partition for custom algorithms
        let arr: List<Int64> = [3, 6, 8, 10, 1, 2, 1];
        let pivotIdx: Int64 = Sort::partition(arr, 0, arr.len() - 1);
        return 0;
    }
}

iter

import tinox.core.iter;

The iter module provides functional iteration tools. The Iter class offers methods for generating number and repetition sequences (range, rangeStep, repeat, cycle), as well as transformation and aggregation methods (map, filter, reduce, enumerate, zip). The Iterator class encapsulates the state of a running iterator with hasNext / next.

Classes & Methods

Example

import tinox.core.iter;

class Main
{
    fnc main() -> Int32
    {
        // Number range with step
        let it: Iterator = Iter::rangeStep(0, 10, 2);
        while it.hasNext()
        {
            let n: Int64 = it.next(); // 0, 2, 4, 6, 8
        }

        // map: square numbers
        let nums: List<Int64> = [1, 2, 3, 4, 5];
        let squares: List<Int64> = Iter::map<Int64, Int64>(nums, fnc(x: Int64) -> Int64 { return x * x; });
        // [1, 4, 9, 16, 25]

        // filter: only even numbers
        let even: List<Int64> = Iter::filter<Int64>(nums, fnc(x: Int64) -> Bool { return x % 2 == 0; });
        // [2, 4]

        // reduce: sum
        let sum: Int64 = Iter::reduce<Int64, Int64>(nums, 0, fnc(acc: Int64, x: Int64) -> Int64 { return acc + x; });
        // 15

        // enumerate
        let pairs: List<Pair<Int64, Int64>> = Iter::enumerate<Int64>(nums);
        // [(0,1),(1,2),(2,3),(3,4),(4,5)]

        // zip
        let letters: List<String> = ["a", "b", "c"];
        let combined = Iter::zip<Int64, String>(nums, letters);
        // [(1,"a"),(2,"b"),(3,"c")]

        // repeat
        let zeros: List<Int64> = Iter::repeat<Int64>(0, 5);
        // [0, 0, 0, 0, 0]
        return 0;
    }
}

graph

import tinox.core.graph;

The graph module implements a generic directed graph Graph<V>, where nodes are identified by String identifiers and edges carry a Float64 weight. Included are breadth-first search (BFS), depth-first search (DFS), and the Dijkstra algorithm for computing shortest paths. The helper class GraphEdge describes a weighted edge.

Classes & Methods

Example

import tinox.core.graph;

class Main
{
    fnc main() -> Int32
    {
        let g: Graph<String> = Graph<String>::new();

        Graph::addNode(g, "A", "City A");
        Graph::addNode(g, "B", "City B");
        Graph::addNode(g, "C", "City C");
        Graph::addNode(g, "D", "City D");

        Graph::addEdge(g, "A", "B", 4.0);
        Graph::addEdge(g, "A", "C", 2.0);
        Graph::addEdge(g, "C", "B", 1.0);
        Graph::addEdge(g, "B", "D", 5.0);
        Graph::addEdge(g, "C", "D", 8.0);

        // Breadth-first search from A
        Graph::bfs(g, "A", fnc(id: String) -> Nothing {
            // Visit order: A, B, C, D
        });

        // Depth-first search from A
        Graph::dfs(g, "A", fnc(id: String) -> Nothing {
            // Visit order (depth-first): A, B, D, C
        });

        // Dijkstra: shortest path from A to D
        let distance: Float64 = Graph::dijkstra(g, "A", "D");
        // A->C (2.0) + C->B (1.0) + B->D (5.0) = 8.0

        // Get neighbors of C
        let nb: List<GraphEdge> = Graph::neighbors(g, "C");
        // nb[0].to = "B", nb[0].weight = 1.0
        return 0;
    }
}

trie

import tinox.core.trie;

The trie module implements a prefix tree (trie) for efficient storage and search of strings. In addition to exact word search and prefix check, the trie provides an autocomplete function that lists all words stored in the tree with a given prefix. The internal node structure TrieNode manages child nodes as Map<String, TrieNode>.

Classes & Methods

Example

import tinox.core.trie;

class Main
{
    fnc main() -> Int32
    {
        let t: Trie = Trie::new();

        // Insert words
        Trie::insert(t, "apfel");
        Trie::insert(t, "apfelbaum");
        Trie::insert(t, "aprikose");
        Trie::insert(t, "banane");
        Trie::insert(t, "birne");

        // Exact search
        let found: Bool    = Trie::search(t, "apfel");     // true
        let missing: Bool  = Trie::search(t, "apfelkuchen"); // false

        // Prefix check
        let hatAp: Bool     = Trie::startsWith(t, "ap");    // true
        let hatXy: Bool     = Trie::startsWith(t, "xy");    // false

        // Autocomplete
        let suggestions: List<String> = Trie::autocomplete(t, "ap");
        // ["apfel", "apfelbaum", "aprikose"] (order depends on map keys)

        let bSuggestions: List<String> = Trie::autocomplete(t, "b");
        // ["banane", "birne"]

        let noSuggestions: List<String> = Trie::autocomplete(t, "z");
        // []
        return 0;
    }
}

math

import tinox.core.math;

The math module provides basic mathematical operations for integer values. It includes mathematical constants (π, e, τ), comparison and absolute value operations, power and factorial calculation, and a simple pseudo-random number generator based on a linear congruential generator (LCG).

Classes & Methods

Example

import tinox.core.math;

class Main
{
    fnc main() -> Int32
    {
        // Konstanten ausgeben
        let pi: Float64 = Math::pi();
        let e: Float64  = Math::e();
        println("Pi = " + pi.toString());
        println("e  = " + e.toString());

        // Grundoperationen
        let a: Int64 = -7;
        let b: Int64 = 3;
        println("abs(-7)    = " + Math::abs(a).toString());
        println("min(-7, 3) = " + Math::min(a, b).toString());
        println("max(-7, 3) = " + Math::max(a, b).toString());
        println("square(5)  = " + Math::square(5).toString());

        // Power and factorial
        println("2^10       = " + Math::pow(2, 10).toString());
        println("7!         = " + Math::factorial(7).toString());

        // Pseudo-random
        let rnd: Int64 = Math::randomSeed(42);
        println("randomSeed(42) = " + rnd.toString());
        return 0;
    }
}

mathf

import tinox.core.mathf;

The mathf module extends basic math with floating-point operations. It provides square root, power, absolute value, rounding (floor/ceil/round), clamp, linear interpolation, and trigonometric and logarithmic functions. All inputs and outputs are based on Float64.

Classes & Methods

Example

import tinox.core.mathf;

class Main
{
    fnc main() -> Int32
    {
        // Wurzel und Rundung
        let r: Float64 = Mathf::sqrt(2.0);
        println("sqrt(2) = " + r.toString());
        println("floor(2.9)  = " + Mathf::floor(2.9).toString());
        println("ceil(2.1)   = " + Mathf::ceil(2.1).toString());
        println("round(2.5)  = " + Mathf::round(2.5).toString());

        // Clamp und Lerp
        let clamped: Float64 = Mathf::clamp(150.0, 0.0, 100.0);
        println("clamp(150, 0, 100) = " + clamped.toString());
        let mid: Float64 = Mathf::lerp(0.0, 10.0, 0.5);
        println("lerp(0, 10, 0.5) = " + mid.toString());

        // Trigonometrie
        let angle: Float64 = Mathf::pi() / 4.0;
        println("sin(pi/4) = " + Mathf::sin(angle).toString());
        println("cos(pi/4) = " + Mathf::cos(angle).toString());

        // Logarithmen
        println("log(e)   = " + Mathf::log(Mathf::e()).toString());
        println("log10(100) = " + Mathf::log10(100.0).toString());
        return 0;
    }
}

mathx

import tinox.core.mathx;

The mathx module provides extended number-theoretic and combinatorial functions: GCD, LCM, primality test, next prime, Fibonacci sequence, binomial coefficient, permutations, modular exponentiation, and digit sum and digit count.

Classes & Methods

Example

import tinox.core.mathx;

class Main
{
    fnc main() -> Int32
    {
        // ggT und kgV
        println("gcd(48, 18) = " + Mathx::gcd(48, 18).toString());
        println("lcm(4, 6)   = " + Mathx::lcm(4, 6).toString());

        // Primzahlen
        println("isPrime(17) = " + Mathx::isPrime(17).toString());
        println("isPrime(18) = " + Mathx::isPrime(18).toString());
        println("nextPrime(20) = " + Mathx::nextPrime(20).toString());

        // Fibonacci
        println("fibonacci(10) = " + Mathx::fibonacci(10).toString());

        // Kombinatorik
        println("C(10, 3) = " + Mathx::combinations(10, 3).toString());
        println("P(5, 2)  = " + Mathx::permutations(5, 2).toString());

        // Modulare Potenz und Ziffernanalyse
        println("modPow(2, 10, 1000) = " + Mathx::modPow(2, 10, 1000).toString());
        println("digitSum(12345)     = " + Mathx::digitSum(12345).toString());
        println("digitCount(99999)   = " + Mathx::digitCount(99999).toString());
        return 0;
    }
}

complex

import tinox.core.complex;

The complex module provides complex numbers as immutable value types. It supports creation from Cartesian and polar coordinates, all four basic arithmetic operations, magnitude, phase, conjugation, reciprocal, and the complex functions exp, log, and pow. Output is as a readable string in the form a±bi.

Classes & Methods

Example

import tinox.core.complex;

class Main
{
    fnc main() -> Int32
    {
        // Erzeugung
        let a: Complex = Complex::new(3.0, 4.0);
        let b: Complex = Complex::new(1.0, -2.0);

        // Grundrechenarten
        println("a + b = " + Complex::toString(Complex::add(a, b)));
        println("a - b = " + Complex::toString(Complex::subtract(a, b)));
        println("a * b = " + Complex::toString(Complex::multiply(a, b)));
        println("a / b = " + Complex::toString(Complex::divide(a, b)));

        // Betrag und Phase
        println("|a| = " + Complex::magnitude(a).toString());
        println("arg(a) = " + Complex::phase(a).toString());

        // Conjugation and reciprocal
        println("conj(a)      = " + Complex::toString(Complex::conjugate(a)));
        println("reciprocal(b)= " + Complex::toString(Complex::reciprocal(b)));

        // Polar-Erzeugung und Potenz
        let c: Complex = Complex::fromPolar(1.0, Mathf::pi() / 2.0);
        println("fromPolar(1, pi/2) = " + Complex::toString(c));
        println("a^2 = " + Complex::toString(Complex::pow(a, 2.0)));
        return 0;
    }
}

decimal

import tinox.core.decimal;

The decimal module implements fixed-point decimal numbers with arbitrary precision based on strings. It enables lossless addition, subtraction, and multiplication without floating-point rounding errors. Division is available with selectable precision (decimal places). Useful for financial and accounting applications.

Classes & Methods

Example

import tinox.core.decimal;

class Main
{
    fnc main() -> Int32
    {
        // Create from different sources
        let price:   Decimal = Decimal::new("1999");
        let tax:     Decimal = Decimal::fromInt(319);
        let rate:    Decimal = Decimal::fromFloat(0.035);

        // Basic arithmetic
        let total: Decimal = Decimal::add(price, tax);
        println("Price + Tax = " + Decimal::toString(total));

        let diff: Decimal = Decimal::subtract(price, tax);
        println("Difference = " + Decimal::toString(diff));

        let qty:    Decimal = Decimal::fromInt(3);
        let product: Decimal = Decimal::multiply(price, qty);
        println("3 x Price = " + Decimal::toString(product));

        // Division with precision
        let result: Decimal = Decimal::divide(price, qty, 4);
        println("Price / 3 (4 digits) = " + Decimal::toString(result));
        return 0;
    }
}

random

import tinox.core.random;

The random module provides a convenient interface for generating random values. It provides methods for random integers, floating-point numbers, and booleans, and allows random selection of an element, shuffling, and drawing a random sample from a list. Additionally, a random alphanumeric string can be generated.

Classes & Methods

Example

import tinox.core.random;

class Main
{
    fnc main() -> Int32
    {
        // Simple random values
        println("nextInt(100)  = " + Random::nextInt(100).toString());
        println("nextFloat()   = " + Random::nextFloat().toString());
        println("nextBool()    = " + Random::nextBool().toString());

        // Pick from a list
        let colors: List = ["red", "green", "blue", "yellow"];
        println("pickOne = " + Random::pickOne(colors));

        // Shuffle
        let nums: List = [1, 2, 3, 4, 5, 6, 7, 8];
        let shuffled: List = Random::shuffle(nums);
        println("shuffle([1..8]) has " + shuffled.len().toString() + " elements");

        // Sample
        let sample: List = Random::sample(colors, 2);
        println("sample(colors, 2) = " + sample.join(", "));

        // Random string
        let token: String = Random::generateString(16);
        println("Token = " + token);
        return 0;
    }
}

string

import tinox.core.string;

The string module provides the Strings class that bundles frequently needed string operations as static methods: length query, uppercase/lowercase, search, extraction, transformation, splitting, joining, and conversion functions from numbers to strings.

Classes & Methods

Example

import tinox.core.string;

class Main
{
    fnc main() -> Int32
    {
        let text: String = "  Hello, Tinox-World!  ";

        // Basic operations
        println("Length (trimmed): " + Strings::length(Strings::trim(text)).toString());
        println("Uppercase:        " + Strings::toUpperCase(Strings::trim(text)));
        println("Lowercase:        " + Strings::toLowerCase(Strings::trim(text)));

        // Search and check
        println("Contains 'Tinox': " + Strings::contains(text, "Tinox").toString());
        println("Starts with '  H': " + Strings::startsWith(text, "  H").toString());
        println("Ends with '!  ':   " + Strings::endsWith(text, "!  ").toString());

        // Transformation
        println("Reverse:   " + Strings::reverse("Tinox"));
        println("Repeat:    " + Strings::repeat("ab", 4));
        println("Replace:   " + Strings::replace(text, "Tinox", "World"));

        // Split and join
        let parts: List = Strings::split("a,b,c,d", ",");
        println("Parts: " + Strings::join(parts, " | "));

        // Number conversion
        println(Strings::intToString(42) + " / " + Strings::floatToString(3.14));
        return 0;
    }
}

fmt

import tinox.core.fmt;

The fmt module provides printf-like formatting for strings. The Fmt class supports the placeholders %s (string), %d (integer), %f (float), %x (hexadecimal), and %b (binary), as well as %% for a literal percent sign. Output can be produced both as a string and printed directly to the console.

Classes & Methods

Example

import tinox.core.fmt;

class Main
{
    fnc main() -> Int32
    {
        // Simple string interpolation
        let name: String = Fmt::sprintf("Hello, %s!", ["Tinox"]);
        println(name);

        // Mixed types in one line
        Fmt::printlnf("User: %s | Age: %d | Balance: %f EUR",
                      ["Alice", "30", "123.45"]);

        // Hexadecimal and binary output
        Fmt::printlnf("255 in hex: %x", ["255"]);
        Fmt::printlnf("255 in bin: %b", ["255"]);

        // Literal percent sign
        Fmt::printlnf("Discount: 20%%", []);

        // Reuse sprintf return value
        let line: String = Fmt::sprintf("[%s] Error %d", ["WARN", "404"]);
        println(line);
        return 0;
    }
}

format

import tinox.core.format;

The format module provides helper functions for displaying and aligning values. It enables right-aligned and left-aligned padding of strings to a minimum width, conversion of integers to binary and hexadecimal representations, and formatting of an integer with fixed field width.

Classes & Methods

Example

import tinox.core.format;

class Main
{
    fnc main() -> Int32
    {
        // Padding
        println(Format::padLeft("42", 6, " "));    // "    42"
        println(Format::padLeft("42", 6, "0"));    // "000042"
        println(Format::padRight("OK", 8, "."));   // "OK......"

        // Number bases
        println("255 binary: "  + Format::intToBinary(255));   // "11111111"
        println("255 hex:   "  + Format::intToHex(255));      // "ff"
        println("4096 hex:  "  + Format::intToHex(4096));     // "1000"

        // Tabular output
        var i: Int64 = 1;
        while i <= 5
        {
            println(Format::formatInt(i, 4) + " | " + Format::formatInt(i * i, 6));
            i = i + 1;
        }
        return 0;
    }
}

regex

import tinox.core.regex;

The regex module provides regular expressions for Tinox. The Regex class offers methods for checking matches, finding the first or all occurrences, globally replacing, and splitting text by a pattern. Execution delegates to native runtime functions (regexIsMatch, regexFindFirst, etc.).

Classes & Methods

Example

import tinox.core.regex;

class Main
{
    fnc main() -> Int32
    {
        let text: String = "Order no: 1042, Qty: 3, Price: 29.99 EUR";

        // Match check
        let hasNumber: Bool = Regex::isMatch("[0-9]+", text);
        println("Contains numbers: " + hasNumber.toString());

        // Find first match
        let firstNumber: String = Regex::findFirst("[0-9]+", text);
        println("First number: " + firstNumber);

        // Find all matches
        let allNumbers: List = Regex::findAll("[0-9]+\\.?[0-9]*", text);
        println("All numbers: " + allNumbers.join(", "));

        // Replace
        let sanitized: String = Regex::replaceAll("[0-9]+", text, "###");
        println("Anonymized: " + sanitized);

        // Split
        let csv: String = "alpha;  beta;gamma; delta";
        let parts: List = Regex::split(";\\s*", csv);
        println("Parts: " + parts.join(", "));
        return 0;
    }
}

uri

import tinox.core.uri;

The uri module provides functions for working with URIs and URLs. It allows encoding and decoding of URIs (fully or component-wise) as well as decomposing a URL into its parts: scheme, host, path, query string, and fragment. The parser result is returned as a UriParts structure.

Classes & Methods

Example

import tinox.core.uri;

class Main
{
    fnc main() -> Int32
    {
        // Encoding and decoding
        let raw: String = "Search term: Daily fresh!";
        let encoded: String = Uri::encodeComponent(raw);
        println("Encoded:   " + encoded);
        println("Decoded:   " + Uri::decodeComponent(encoded));

        // Encode full URI
        let url: String = "https://example.com/search?q=Tinox Docs&lang=en";
        println("URI encoded: " + Uri::encode(url));

        // Parse URL
        let complex: String = "https://api.tinox.dev:8080/v1/users?limit=10&page=2#results";
        let parts: UriParts = Uri::parse(complex);
        println("Scheme:   " + parts.scheme);
        println("Host:     " + parts.host);
        println("Path:     " + parts.path);
        println("Query:    " + parts.query);
        println("Fragment: " + parts.fragment);

        // Simple URL without path
        let simple: UriParts = Uri::parse("ftp://files.example.org");
        println("FTP host: " + simple.host);
        return 0;
    }
}

fs

import tinox.core.fs;

The fs module provides basic filesystem operations. It covers reading, writing, copying, moving, and deleting files as well as creating, listing, and removing directories.

Classes & Methods

Example

import tinox.core.fs;

// Create directory and write files
Fs::createDirectory("/tmp/demo");

Fs::writeFile("/tmp/demo/hello.txt", "Hello, Tinox!\n");
Fs::appendFile("/tmp/demo/hello.txt", "Second line.\n");

// Read file and print
let content: String = Fs::readFile("/tmp/demo/hello.txt");
print(content);

// Copy file and delete original (= move)
Fs::copyFile("/tmp/demo/hello.txt", "/tmp/demo/backup.txt");
Fs::deleteFile("/tmp/demo/hello.txt");

// List directory contents
let entries: List<String> = Fs::listDirectory("/tmp/demo");
var i: Int64 = 0;
while i < entries.len()
{
    print(entries[i] + "\n");
    i = i + 1;
}

// Clean up
Fs::deleteFile("/tmp/demo/backup.txt");
Fs::deleteDirectory("/tmp/demo");

io

import tinox.core.io;

The io module provides I/O utilities: The Io class offers console output, File represents a file handle for opening, reading, writing, and closing, Paths enables decomposition and composition of file paths, and Buffer is used for efficient string accumulation.

Classes & Methods

Example

import tinox.core.io;

// Use path helper functions
let path: String = "/home/user/documents/report.txt";
Io::printLine("Filename  : " + Paths::getFileName(path));
Io::printLine("Extension : " + Paths::getExtension(path));
Io::printLine("Directory : " + Paths::getDirectory(path));

let newPath: String = Paths::join("/home/user/export", "output.csv");
Io::printLine("New path: " + newPath);

// Buffer for efficient concatenation
let buf: Buffer = Io::newBuffer();
buf.appendLine("Line 1");
buf.appendLine("Line 2");
buf.append("Number: ");
buf.appendInt(42);

if !buf.isEmpty()
{
    Io::printHeader("Buffer contents");
    Io::printLine(buf.toString());
}

// Check file handle
let file: File = File::new(path);
if File::exists(path)
{
    Io::printLine("File exists: " + file.getPath());
    file.close();
}

env

import tinox.core.env;

The env module provides access to environment variables of the running process as well as querying and changing the current working directory.

Classes & Methods

Example

import tinox.core.env;

// Read environment variable
let home: String = Env::getVar("HOME");
print("Home directory: " + home + "\n");

// Set and read new variable
Env::setVar("APP_MODE", "production");
let mode: String = Env::getVar("APP_MODE");
print("Mode: " + mode + "\n");

// Get and change working directory
let cwd: String = Env::currentDir();
print("Current directory: " + cwd + "\n");

Env::setCurrentDir("/tmp");
print("New directory: " + Env::currentDir() + "\n");

// Remove variable again
Env::removeVar("APP_MODE");
print("APP_MODE removed.\n");

process

import tinox.core.process;

The process module provides control functions for the running OS process: exiting with an exit code, sleeping, querying the process ID and command-line arguments, and accessing environment variables.

Classes & Methods

Example

import tinox.core.process;

// Print PID and arguments
let pid: Int64 = Process::pid();
print("Process ID: " + pid.toString() + "\n");

let args: List<String> = Process::args();
print("Argument count: " + args.len().toString() + "\n");

var i: Int64 = 0;
while i < args.len()
{
    print("  arg[" + i.toString() + "] = " + args[i] + "\n");
    i = i + 1;
}

// Set and read environment variable
Process::setEnv("TINOX_LOG", "debug");
let logLevel: String = Process::env("TINOX_LOG");
print("Log level: " + logLevel + "\n");

// Brief pause, then clean exit
Process::sleep(500);
print("Program end.\n");
Process::exit(0);

debug

import tinox.core.debug;

The debug module provides tools for runtime diagnostics: assertions, controlled program abort, stack trace output, memory usage query, and manual garbage collection.

Classes & Methods

Example

import tinox.core.debug;

// Measure memory usage before work
let before: Int64 = Debug::memoryUsage();
print("Memory before: " + before.toString() + " bytes\n");

// Assertion – fails if condition not met
let value: Int64 = 42;
Debug::assert(value > 0, "Value must be positive");
Debug::assert(value < 100, "Value must not exceed 100");

// Print stack trace for diagnostic purposes
Debug::printStackTrace();

// Force garbage collection and measure memory again
Debug::gcCollect();
let after: Int64 = Debug::memoryUsage();
print("Memory after: " + after.toString() + " bytes\n");

// Intentional abort on unexpected state
let error: Bool = false;
if error
{
    Debug::panic("Unexpected system state");
}

print("All checks passed.\n");

zip

import tinox.core.zip;

The zip module enables creating, opening, and editing ZIP archives. Files can be added, extracted, and removed. Entries are described via ZipEntry objects with name and size; the archive itself is represented by ZipArchive.

Classes & Methods

Example

import tinox.core.zip;

// Create new archive and add files
let archive: ZipArchive = Zip::create("/tmp/package.zip");
Zip::addFile(archive, "README.txt",  "This is a Tinox demo.\n");
Zip::addFile(archive, "data.csv",    "name,value\nalpha,1\nbeta,2\n");
Zip::addFile(archive, "config.json", "{\"version\": 1}\n");

// List entries
let entries: List<ZipEntry> = archive.entries;
var i: Int64 = 0;
while i < entries.len()
{
    let e: ZipEntry = entries[i];
    print(e.name + "  (" + e.size.toString() + " bytes)\n");
    i = i + 1;
}

// Extract content of a file
let content: String = Zip::extractFile(archive, "README.txt");
print("README: " + content);

// Remove entry
Zip::removeFile(archive, "config.json");
print("Entries after deletion: " + archive.entries.len().toString() + "\n");

Zip::close(archive);

compress

import tinox.core.compress;

The compress module provides general-purpose byte compression for arbitrary payloads (log shipping, HTTP response bodies, message-queue payload compression, ...) — unlike zip's Zip, which is STORED-only (no compression). Two formats are supported: gzip (RFC 1952 — magic bytes, header, deflate stream, then a CRC32 + size trailer that decompression verifies automatically; the format most external tools/HTTP Content-Encoding: gzip expect) and raw DEFLATE (RFC 1951, no header/trailer — smallest possible framing, the same on-wire format the websocket module's permessage-deflate already uses). Prefer gzip/gunzip unless framing size specifically matters and both ends already agree out-of-band on the format.

Decompression failure (truncated/malformed input, a CRC32/trailer mismatch, or a payload exceeding a 16MB decompression-bomb cap) is reported via lastGunzipOk()/lastInflateOk() rather than a silent empty-but-"successful" result — check it immediately after calling gunzip()/inflateRaw().

Classes & Methods

Example

import tinox.core.compress;

let msg: String = "hello, tinox compress module!";
var bytes: List<Int64> = [];
var i: Int64 = 0;
while i < msg.len()
{
    bytes.push(msg.charCodeAt(i));
    i = i + 1;
}

// gzip round trip
let packed: List<Int64> = Compress::gzip(bytes);
let restored: List<Int64> = Compress::gunzip(packed);
if !Compress::lastGunzipOk()
{
    throw "corrupt gzip stream";
}
print("compressed " + bytes.len().toString() + " bytes down to " + packed.len().toString() + "\n");

asm

import tinox.core.asm;

The asm module provides a simple bytecode assembler. Via the Assembler class, opcodes and 64-bit integer values are written into a byte buffer, labels are set and resolved, and the finished bytecode is exported as a byte string. The Ops class defines all available opcodes as integer constants.

Classes & Methods

Example

import tinox.core.asm;

// Create assembler
let a: Assembler = Assembler::new();

// Simple program: push 7, push 3, add, halt
Assembler::emit(a, Ops::Push());
Assembler::emitInt(a, 7);

Assembler::emit(a, Ops::Push());
Assembler::emitInt(a, 3);

Assembler::emitLabel(a, "add_start");
Assembler::emit(a, Ops::Add());

// Conditional jump back to loop (demo)
Assembler::emit(a, Ops::Jz());
Assembler::emitInt(a, 0);

Assembler::emit(a, Ops::Halt());

// Resolve labels
let code: List<Int64> = Assembler::resolveLabels(a);
print("Bytecode length: " + code.len().toString() + " bytes\n");

// Export as byte string
let bytes: String = Assembler::toBytes(a);
print("Raw data length: " + bytes.len().toString() + "\n");

bitmap

import tinox.core.bitmap;

The bitmap module provides a simple 2D pixel graphics library. Bitmaps are managed as grids of 32-bit color values (ARGB/RGB as Int64). Supported operations include creating, reading and writing pixels, filling rectangles, and drawing lines and circles (Bresenham algorithms).

Classes & Methods

Example

import tinox.core.bitmap;

// Colors as ARGB hex values
let white: Int64  = 0xFFFFFFFF;
let black: Int64  = 0xFF000000;
let red: Int64    = 0xFFFF0000;
let blue: Int64   = 0xFF0000FF;

// Create 200×200 pixel white bitmap
let img: Bitmap = Bitmap::create(200, 200, white);

// Draw black border (four lines)
Bitmap::drawLine(img,   0,   0, 199,   0, black);
Bitmap::drawLine(img, 199,   0, 199, 199, black);
Bitmap::drawLine(img, 199, 199,   0, 199, black);
Bitmap::drawLine(img,   0, 199,   0,   0, black);

// Red filled rectangle in the center
Bitmap::fillRect(img, 50, 50, 100, 100, red);

// Blue circle over the rectangle
Bitmap::drawCircle(img, 100, 100, 40, blue);

// Read and print single pixel
let px: Int64 = Bitmap::getPixel(img, 100, 100);
print("Pixel (100,100): " + px.toString() + "\n");

// Overwrite single pixel
Bitmap::setPixel(img, 100, 100, black);
print("Pixel after overwrite: " + Bitmap::getPixel(img, 100, 100).toString() + "\n");

tpl

import tinox.core.tpl;

The tpl module provides a simple Mustache-style template engine. Templates use {{key}} placeholders that are replaced with data values. In addition to direct rendering, templates can be pre-compiled (compile) and then efficiently executed repeatedly (execute). A loop function enables rendering a template for multiple data records.

Classes & Methods

Example

import tinox.core.tpl;

// Simple direct rendering
let template: String = "Hello, {{name}}! You have {{points}} points.";
let data: Map<String, JsonValue> = Map::new();
data["name"]   = JsonValue::fromString("Maria");
data["points"] = JsonValue::fromInt(1340);

let output: String = Template::render(template, data);
print(output + "\n");
// Output: Hello, Maria! You have 1340 points.

// Template loop over multiple records
let rowTemplate: String = "- {{title}} ({{year}})\n";
let movies: List<Map<String, JsonValue>> = [];

let movie1: Map<String, JsonValue> = Map::new();
movie1["title"] = JsonValue::fromString("Inception");
movie1["year"]  = JsonValue::fromInt(2010);
movies.push(movie1);

let movie2: Map<String, JsonValue> = Map::new();
movie2["title"] = JsonValue::fromString("Dune");
movie2["year"]  = JsonValue::fromInt(2021);
movies.push(movie2);

let list: String = Template::renderLoop(rowTemplate, movies, "movie");
print(list);

// Pre-compiled template for reuse
let compiled: CompiledTemplate = Template::compile("User: {{login}} | Role: {{role}}");

let admin: Map<String, JsonValue> = Map::new();
admin["login"] = JsonValue::fromString("admin");
admin["role"]  = JsonValue::fromString("Administrator");
print(Template::execute(compiled, admin) + "\n");

crypto

import tinox.core.crypto;

The crypto module provides basic cryptographic functions: hashing (MD5, SHA-256), HMAC signatures, symmetric AES encryption, secure key generation, and password-based key derivation via PBKDF2.

Classes & Methods

Example

import tinox.core.crypto;

// Simple SHA-256 hash
let digest: String = Crypto::sha256("Hello World");
println("SHA-256: " + digest);

// Verify HMAC signature
let secret: String = "mySecret";
let sig: String = Crypto::hmacSha256("payload", secret);
println("HMAC: " + sig);

// Generate random AES key and encrypt data
let key: String = Crypto::generateKey(32);
let cipher: String = Crypto::aesEncrypt("Secret message", key);
let plain: String  = Crypto::aesDecrypt(cipher, key);
println("Decrypted: " + plain);

// Password hashing via PBKDF2
let salt: String    = Crypto::generateKey(16);
let derived: String = Crypto::pbkdf2("password123", salt, 10000, 32);
println("Derived key: " + derived);

hash

import tinox.core.hash;

The hash module implements fast, non-cryptographic hash functions for strings and integers, as well as a combine function to fold multiple hashes into a single value. Typical use cases include hash maps, checksums, and fast data comparisons.

Classes & Methods

Example

import tinox.core.hash;

// Compute string hash
let h1: Int64 = Hash::hashString("Tinox");
println("String hash: " + h1.toString());

// Compute integer hash
let h2: Int64 = Hash::hashInt(42);
println("Int hash: " + h2.toString());

// Hash composite key (e.g. (name, id))
let nameHash: Int64 = Hash::hashString("Alice");
let idHash: Int64   = Hash::hashInt(1001);
let combined: Int64 = Hash::combine(nameHash, idHash);
println("Combined hash: " + combined.toString());

// Simple bucket assignment
let buckets: Int64 = 16;
let bucket: Int64  = combined % buckets;
println("Bucket index: " + bucket.toString());

validation

import tinox.core.validation;

The validation module provides helper functions for input validation. It allows checking strings against common formats (email, URL, phone number), enforcing length rules, and applying arbitrary regular expressions.

Classes & Methods

Example

import tinox.core.validation;

let email: String = "user@example.com";
if Validation::isEmail(email)
{
    println("Valid email address.");
}

let url: String = "https://tinox.io/api";
if Validation::isUrl(url) == false
{
    println("Invalid URL.");
}

// Check password rules
let password: String = "Secret42!";
let minOk: Bool = Validation::minLength(password, 8);
let maxOk: Bool = Validation::maxLength(password, 64);
println("Length OK: " + minOk.toString());

// Check numeric input
let age: String = "27";
if Validation::isNumeric(age)
{
    let n: Int64 = (Int64)age;
    println("Age in range: " + Validation::isInRange(n, 0, 120).toString());
}

// Custom pattern
let zip: String = "80331";
println("ZIP format: " + Validation::matchesPattern(zip, "^[0-9]{5}$").toString());

uuid

import tinox.core.uuid;

The uuid module enables generating and validating UUIDs (Universally Unique Identifiers) in the format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx. It provides conversion functions between string representation and internal Uuid objects.

Classes & Methods

Example

import tinox.core.uuid;

// Generate new UUID
let id: String = Uuid::generate();
println("New UUID: " + id);

// Validate a UUID
let input: String = "123e4567-e89b-12d3-a456-426614174000";
if Uuid::isValid(input)
{
    println("Valid UUID.");
    let obj: Uuid = Uuid::fromString(input);
    println("UUID object: " + obj.toString());
}
else
{
    println("Invalid UUID input.");
}

// Typical use as record ID
let recordId: String = Uuid::generate();
println("New record with ID: " + recordId);

semaphore

import tinox.core.semaphore;

The semaphore module provides synchronization primitives for concurrent programs: a counting Semaphore to limit simultaneous accesses, an exclusive Mutex, and an RWLock for separate read and write locks.

Classes & Methods

Example

import tinox.core.semaphore;

// Semaphore: maximum 3 simultaneous connections
let sem: Semaphore = Semaphore::new(3);

if Semaphore::tryAcquire(sem)
{
    println("Connection acquired.");
    // ... work ...
    Semaphore::release(sem);
}

// Mutex: protect critical section
let mtx: Mutex = Mutex::new();
Mutex::lock(mtx);
println("Critical section");
Mutex::unlock(mtx);

// RWLock: multiple readers, exclusive writer
let rw: RWLock = RWLock::new();
RWLock::readLock(rw);
println("Reading data ...");
RWLock::readUnlock(rw);

RWLock::writeLock(rw);
println("Writing data ...");
RWLock::writeUnlock(rw);

pool

import tinox.core.pool;

The pool module provides a generic object pool. Expensive objects (e.g. database connections, network sockets) are kept in the pool and reused instead of being created anew each time. The maximum pool size is configurable.

Classes & Methods

Example

import tinox.core.pool;

// Pool for database connections (maximum 5)
let dbPool: Pool<DbConnection> = Pool::new(5);

// Acquire connection
let conn: DbConnection = Pool::acquire(dbPool);
let result: List<Row> = conn.query("SELECT * FROM users");
println("Rows: " + result.len().toString());

// Release connection
Pool::release(dbPool, conn);

// Second connection – reused from pool
let conn2: DbConnection = Pool::acquire(dbPool);
conn2.execute("UPDATE users SET active = 1 WHERE id = 42");
Pool::release(dbPool, conn2);

// Clear pool (e.g. on shutdown)
Pool::clear(dbPool);
println("Pool cleared.");

ratelimit

import tinox.core.ratelimit;

The ratelimit module implements two request limiting strategies: RateLimiter uses a sliding-window approach (fixed time window), while TokenBucket uses the token bucket approach with a configurable refill rate.

Classes & Methods

Example

import tinox.core.ratelimit;

// Sliding window: 100 requests per minute
let limiter: RateLimiter = RateLimiter::new(100, 60000);

var i: Int64 = 0;
while i < 5
{
    if RateLimiter::allow(limiter)
    {
        println("Request " + i.toString() + " allowed. Remaining: "
                + RateLimiter::remaining(limiter).toString());
    }
    i = i + 1;
}

// Token bucket: capacity 10, 2 tokens/second
let bucket: TokenBucket = TokenBucket::new(10, 2.0);

if TokenBucket::allow(bucket)
{
    println("Request via token bucket allowed.");
}
else
{
    println("Token bucket empty – request rejected.");
}

cron

import tinox.core.cron;

The cron module enables scheduling recurring tasks via cron expressions in Unix format (5 fields: minute, hour, day, month, weekday). The CronScheduler manages multiple jobs and executes them on tick calls when the condition is met.

Classes & Methods

Example

import tinox.core.cron;

let scheduler: CronScheduler = CronScheduler::new();

// Execute every minute
CronScheduler::addJob(scheduler, "* * * * *", () => {
    println("Minutely job running.");
});

// Execute daily at 08:30
CronScheduler::addJob(scheduler, "30 8 * * *", () => {
    println("Daily morning report is being generated.");
});

CronScheduler::start(scheduler);

// Main loop (call tick e.g. every 60 s)
var tick: Int64 = 0;
while tick < 3
{
    CronScheduler::tick(scheduler);
    tick = tick + 1;
}

CronScheduler::stop(scheduler);
println("Scheduler stopped.");

events

import tinox.core.events;

The events module implements the observer pattern via an EventEmitter. Listeners can be registered for named events, subscribed once, or removed again. When an event is emitted, all registered handlers are called with a JsonValue payload.

Classes & Methods

Example

import tinox.core.events;

let emitter: EventEmitter = EventEmitter::new();

// Permanent listener
EventEmitter::on(emitter, "order", (data: JsonValue) => {
    println("New order: " + data.toString());
});

// One-time listener
EventEmitter::once(emitter, "start", (data: JsonValue) => {
    println("Application started.");
});

println("Listener count for 'order': "
        + EventEmitter::listenerCount(emitter, "order").toString());

// Emit events
EventEmitter::emit(emitter, "start", Json::null());
EventEmitter::emit(emitter, "order", Json::parse("{\"id\": 42}"));

// Remove all listeners
EventEmitter::removeAllListeners(emitter, "order");
println("Listeners after removal: "
        + EventEmitter::listenerCount(emitter, "order").toString());

time

import tinox.core.time;

The time module provides utilities for time operations: The Time class is the entry-point factory, Duration represents time spans, Timer measures a defined start-stop interval, and Stopwatch is the counterpart with an additional isRunning() query.

Classes & Methods

Example

import tinox.core.time;

// Current time
let now: Int64 = Time::now();
println("Now (ms): " + now.toString());

// Timer for an operation
let timer: Timer = Time::newTimer();
timer.start();
// ... work ...
timer.stop();
println("Duration: " + timer.elapsedSeconds().toString() + " s");

// Stopwatch
let sw: Stopwatch = Time::newStopwatch();
sw.start();
println("Running: " + sw.isRunning().toString());
sw.stop();
println("Elapsed ms: " + sw.elapsed().toString());

// Combine durations
let d1: Duration = Time::newDuration(3600);    // 1 hour
let d2: Duration = Time::durationFromMinutes(30);
let total: Duration = d1.add(d2);
println("Total in minutes: " + total.getMinutes().toString());

cache

import tinox.core.cache;

The cache module provides a generic LRU cache (Least Recently Used). When the maximum size is reached, the least recently used entry is automatically evicted. The LruCache class is a slim wrapper around the internal Cache class.

Classes & Methods