API Service

https://github.com/zenc-lang/docs
Admin
This project appears to be a backend service or API developed using TypeScript, providing various...
Tokens:228,300
Snippets:2,041
Trust Score:7
License:MIT
Update:4 months ago
Show doc for...
Tokens:
Raw
### Example Build Configuration

Source: https://github.com/zenc-lang/docs/blob/main/raw/README.md

A comprehensive example of various build directives used before importing C headers and defining main function.

```zc
//> include: ./include
//> lib: ./libs
//> link: -lraylib -lm
//> cflags: -Ofast
//> pkg-config: gtk+-3.0

import "raylib.h" as raylib;

fn main() { ... }
```

--------------------------------

### Install Zen C from Source

Source: https://github.com/zenc-lang/docs/blob/main/rosetta/Hello_world_Newbie.md

Clone the Zen C repository, clean previous builds, compile, and install the compiler. This is the recommended method for building from source.

```zc
git clone https://github.com/zenc-lang/zenc.git
cd Zen-C
make clean # remove old build files
make
sudo make install
```

--------------------------------

### Server::start

Source: https://github.com/zenc-lang/docs/blob/main/std/net.md

Starts the HTTP server's listening loop.

```APIDOC
## Server::start

### Description
Starts the server listening loop.

### Method
`start`

### Parameters
None
```

--------------------------------

### Zen C Main Function with Dot Product Examples

Source: https://github.com/zenc-lang/docs/blob/main/rosetta/Dot_product.md

Demonstrates the usage of the `dot_product` function with two different sets of vectors. It prints the input vectors and their calculated dot products to the console. This example showcases how to call the function and interpret its results.

```zc
fn main() {
    let a: [double] = [1.0, 3.0, -5.0];
    let b: [double] = [4.0, -2.0, -1.0];

    let result = dot_product(a, b);

    println "Vector A: [1, 3, -5]";
    println "Vector B: [4, -2, -1]";
    println "A . B  = {result}";

    let a2: [double] = [1.0, 2.0, 3.0, 4.0];
    let b2: [double] = [0.5, 0.5, 0.5, 0.5];
    
    println "";
    println "Vector A2: [1, 2, 3, 4]";
    println "Vector B2: [0.5, 0.5, 0.5, 0.5]";
    println "A2 . B2 = {dot_product(a2, b2)}";    
}
```

--------------------------------

### HTTP Server Start

Source: https://github.com/zenc-lang/docs/blob/main/std/net.md

Starts the main listening loop for an HTTP server, enabling it to accept and process incoming connections.

```zc
start(self)
```

--------------------------------

### Vector Initialization and Operations Example in Zen C

Source: https://github.com/zenc-lang/docs/blob/main/rosetta/Vector.md

Demonstrates the usage of the Vector struct in Zen C, showcasing different initialization methods and arithmetic operations. This example is useful for understanding how to create and manipulate vectors within a Zen C program.

```zc
fn main() {
    // Initialization
    let v1 = Vector::new(3.0, 4.0);
    println "v1 (new): {v1}";

    let v2 = Vector::from_points(0.0, 0.0, -1.0, 2.0);
    println "v2 (from_points): {v2}";

    println "v_polar (from_polar): {Vector::from_polar(Math::PI() / 4.0, 5.0)}";

    println "";

    // Operations
    println "v1 + v2: {v1 + v2}";
    println "v1 - v2: {v1 - v2}";
    println "v1 * 2.5: {v1 * 2.5}";
    println "v1 / 2.0: {v1 / 2.0}";
}
```

--------------------------------

### Start Zen C LSP Server

Source: https://github.com/zenc-lang/docs/blob/main/LSP.md

Starts the Zen C Language Server using the 'zc' compiler key. This command communicates over standard input/output (stdio).

```bash
zc lsp
```

--------------------------------

### Example Build Directives Configuration

Source: https://github.com/zenc-lang/docs/blob/main/reference/12-advanced.es.md

Demonstrates a comprehensive set of build directives including include paths, library linking, compiler flags, and package configuration.

```zc
//> include: ./include
//> lib: ./libs
//> link: -lraylib -lm
//> cflags: -Ofast
//> pkg-config: gtk+-3.0

import "raylib.h"

fn main() { ... }
```

--------------------------------

### Line-by-line processing example

Source: https://github.com/zenc-lang/docs/blob/main/rosetta/Input_loop.md

Demonstrates line-by-line processing of standard input using the Zen C input loop implementation with the '-l' flag. Input is piped to the compiled program.

```shell
$ printf "First line\nSecond line\n" | ./read_stream -l
Line: [First line]
Line: [Second line]
```

--------------------------------

### Complete Function Definition Example in Zen C

Source: https://github.com/zenc-lang/docs/blob/main/rosetta/Function_definition.md

Demonstrates standard functions with default arguments, inline hints, and generic functions, along with a main function to showcase their usage.

```zc
// Standard function with a default argument
fn increment(val: int, amount: int = 1) -> int {
    return val + amount;
}

// Inline function attribute hint
@inline
fn multiply(a: float, b: float) -> float {
    return a * b;
}

// Generic function
fn multiply_generic<T>(a: T, b: T) -> T {
    return a * b;
}

fn main() {
    // Default argument evaluated
    let res1 = increment(10);
    println "10 + default = {res1}";

    // Inline execution
    let res2 = multiply(5.0, 4.0);
    println "5.0 * 4.0 = {res2}";

    // Generic execution with f32 (float)
    let res3 = multiply_generic<f32>(2.5, 2.0);
    println "2.5 * 2.0 = {res3}";
    
    // Generic execution with int
    let res4 = multiply_generic<int>(10, 3);
    println "10 * 3 = {res4}";
}
```

--------------------------------

### Basic BigFloat Usage Example

Source: https://github.com/zenc-lang/docs/blob/main/std/bigfloat.md

Demonstrates creating, scaling, adding, and converting BigFloat values to a string. Memory is automatically managed.

```zc
import "std/bigfloat.zc"

fn main() {
    let a = BigFloat::from_int(123);
    a.scale = 2; // Represents 1.23
    
    let b = BigFloat::from_int(4567);
    b.scale = 3; // Represents 4.567
    
    let sum = a.add(b);
    
    let s = sum.to_string();
    println "Sum: {s}"; // Sum: 5.797
    free(s);
} // a, b, and sum are freed automatically here
```

--------------------------------

### Start Zen C REPL

Source: https://github.com/zenc-lang/docs/blob/main/reference/15-unit-testing-framework.md

Open the Read-Eval-Print Loop (REPL) for interactive Zen C code experimentation.

```bash
zc repl
```

--------------------------------

### Word-by-word processing example

Source: https://github.com/zenc-lang/docs/blob/main/rosetta/Input_loop.md

Demonstrates the default word-by-word processing of standard input using the Zen C input loop implementation. Input is piped to the compiled program.

```shell
$ echo "hello world from Zen C" | ./read_stream
Word: [hello]
Word: [world]
Word: [from]
Word: [Zen]
Word: [C]
```

--------------------------------

### Try Operator (?) Example

Source: https://github.com/zenc-lang/docs/blob/main/reference/06-operators.md

Demonstrates the try operator for short-circuiting function execution on error results.

```zc
import "std/result.zc"

fn try_work() -> Result<int> {
    let inner = may_fail();
    let val = inner?;  // returns Err early if inner is Err
    return Result<int>::Ok(val * 2);
}
```

--------------------------------

### Main function with example datasets

Source: https://github.com/zenc-lang/docs/blob/main/rosetta/Fivenum.md

Demonstrates the usage of the fivenum function with three different datasets. The output shows the five-number summary for each dataset.

```zc
fn main() {
    let x1 = [36.0, 40.0, 7.0, 39.0, 41.0, 15.0];
    let x2 = [15.0, 6.0, 42.0, 41.0, 7.0, 36.0, 49.0, 40.0, 39.0, 47.0, 43.0];
    let x3 = [
        0.14082834,  0.09748790,  1.73131507,  0.87636009, -1.95059594,
        0.73438555, -0.03035726,  1.46675970, -0.74621349, -0.72588772,
        0.63905160,  0.61501527, -0.98983780, -1.00447874, -0.62759469,
        0.66206163,  1.04312009, -0.10305385,  0.75775634,  0.32566578
    ];
    let xs: f64*[3] = [x1, x2, x3];
    let sizes = [6, 11, 20];
    for i in 0..3 { fivenum(xs[i], sizes[i]) };
}
```

--------------------------------

### Zen C Hello World Program

Source: https://github.com/zenc-lang/docs/blob/main/rosetta/Hello_world_Text.md

A basic Zen C program that prints 'Hello world!' to the console. This is a fundamental example for beginners.

```zc
fn main() {
    println "Hello world!";
}
```

--------------------------------

### Objective-C in Zen C

Source: https://github.com/zenc-lang/docs/blob/main/raw/README.md

Example demonstrating how to use Objective-C syntax within Zen C using raw blocks and include directives for headers.

```zc
//> macos: framework: Foundation
//> linux: cflags: -fconstant-string-class=NSConstantString -D_NATIVE_OBJC_EXCEPTIONS
//> linux: link: -lgnustep-base -lobjc

include <Foundation/Foundation.h>

fn main() {
    raw {
        NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
        NSLog(@"Hello from Objective-C!");
        [pool drain];
    }
    println "Zen C works too!";
}
```

--------------------------------

### Pipeline Operator (|>) Example

Source: https://github.com/zenc-lang/docs/blob/main/reference/06-operators.md

Illustrates the use of the pipeline operator for chaining function calls.

```zc
fn double(x: int) -> int { return x * 2; }
fn add(a: int, b: int) -> int { return a + b; }

let res = 5 |> double |> add(10);
// Equivalent to: add(double(5), 10) → 20
```

--------------------------------

### Memory Mapping and Unmapping Example

Source: https://github.com/zenc-lang/docs/blob/main/std/mman.md

Demonstrates how to map anonymous memory, use it, and then unmap it. Ensure to check the return value of mmap for errors.

```zc
import "std/sys/mman.zc"
import "std/io.zc"

fn main() {
    let size: usize = 4096;
    let prot = Z_PROT_READ | Z_PROT_WRITE;
    let flags = Z_MAP_PRIVATE | Z_MAP_ANONYMOUS;
    
    let addr = Memory::mmap(size, prot, flags);
    if ((isize)addr == Z_MAP_FAILED) {
        println "Mapping failed";
        return;
    }
    
    // Use memory... 
    
    Memory::munmap(addr, size);
}
```

--------------------------------

### Zen C Unit Test Example

Source: https://github.com/zenc-lang/docs/blob/main/raw/README.md

Demonstrates how to write a unit test in Zen C using the 'test' keyword and the 'assert' function. Tests do not require a main function.

```zc
test "unittest1" {
    "This is an unittest";

    let a = 3;
    assert(a > 0, "a should be a positive integer");

    "unittest1 passed.";
}
```

--------------------------------

### Server Console Output

Source: https://github.com/zenc-lang/docs/blob/main/rosetta/Hello_world_Web_server.md

This shows the expected output in the server's console when the Zen C web server starts.

```text
Serving 'Goodbye, World!' at http://localhost:8080/
Server listening on port 8080
```

--------------------------------

### Arena Storage Pool Example in Zen C

Source: https://github.com/zenc-lang/docs/blob/main/rosetta/Arena_storage_pool.md

This snippet shows how to create an arena, allocate an array of integers, and duplicate a string into the arena. It also demonstrates how to check the used and free bytes within the arena.

```Zen C
import "std/arena.zc"

fn main() {
    // Create an arena with 100 bytes capacity.
    let a = Arena::new(100);

    // Allocate an array of 8 32-bit integers i.e. 32 bytes.
    let arr = a.alloc_n<int>(8);
    for i in 0..8 {
        arr[i] = i + 1;
        print "{arr[i]} ";
    }
    println "";

    // Duplicate a C string into the arena.
    let s = a.dup_str("Rosetta Code"); // uses 13 bytes including final '\0'
    println "{s}";

    println "Arena has used     : {a.bytes_used()} bytes";
    println "Capacity remaining : {a.bytes_free()} bytes";
}
```

--------------------------------

### Get Match as String

Source: https://github.com/zenc-lang/docs/blob/main/std/regex.md

Returns a pointer to the start of the matched text. Useful for accessing the matched substring.

```zc
as_string(self) -> char*
```

--------------------------------

### Zen C Pointers and References Example

Source: https://github.com/zenc-lang/docs/blob/main/rosetta/Pointers_and_references.md

Demonstrates stack, struct, heap, and null pointers in Zen C. Shows address-of, dereferencing, auto-dereferencing for structs, heap allocation/deallocation, and null pointer checks.

```zc
struct Data {
    id: int;
    active: bool;
}

fn increment(ptr: int*) {
    // Dereference to modify the value in the caller's scope
    *ptr = *ptr + 1;
}

fn main() {
    println "STACK POINTERS";
    let x = 42;
    let x_ptr = &x; // Take the address of a stack variable

    println "Value of x: {x}";
    println "Address of x: {(usize)x_ptr}";
    println "Value via x_ptr: {*x_ptr}";

    // Modifying via pointer
    *x_ptr = 100;
    println "New value of x: {x}";

    // Pass by reference
    increment(&x);
    println "Value after increment(ptr): {x}";

    println "\nSTRUCT POINTERS & AUTO-DEREF";
    let d = Data { id: 1, active: true };
    let d_ptr = &d;

    // Zen C supports auto-dereferencing for struct fields
    println "id via d_ptr.id: {d_ptr.id}";
    d_ptr.active = false;
    println "Active via d.active: {d.active}";

    // Manual dereferencing for clarity or specific cases
    println "id via (*d_ptr).id: {(*d_ptr).id}";

    println "\nHEAP POINTERS";
    // Allocate memory for an integer on the heap
    let h_ptr: int* = malloc(sizeof(int));
    
    if ((usize)h_ptr == 0) {
        println "Failed to allocate memory!";
        return 0;
    }

    *h_ptr = 500;
    println "Value on heap: {*h_ptr}";

    // Always free heap memory
    free(h_ptr);
    println "Heap memory freed.";

    println "\nNULL POINTERS";
    let null_ptr: int* = 0;
    if ((usize)null_ptr == 0) {
        println "null_ptr is indeed null (0).";
    }
}

```

--------------------------------

### Zen C Range Loop Example

Source: https://github.com/zenc-lang/docs/blob/main/rosetta/Loops_For.md

Demonstrates an inclusive range loop using the `for i in 1..=5` syntax. This is a concise way to iterate over a sequence.

```zc
fn main() {
    println "Using a Zen C range loop:";
    // Inclusive range loop
    for i in 1..=5 {
        println "Iteration: {i}";
    }

    println "\nUsing a C-style for loop (without parentheses):";
    // Traditional 3-part loop, parenthesis-free
    for let j = 1; j <= 5; j += 1 {
        println "Iteration: {j}";
    }

    println "\nUsing a C-style for loop (with parentheses):";
    // Traditional 3-part loop, exactly like C
    for (let k = 1; k <= 5; k += 1) {
        println "Iteration: {k}";
    }
}
```

--------------------------------

### Hex Encoding and Decoding Example

Source: https://github.com/zenc-lang/docs/blob/main/std/hex.md

Demonstrates how to encode raw bytes into a hexadecimal string and decode a hexadecimal string back into bytes using the Hex module.

```Zenscript
import "std/encoding/hex.zc"
import "std/io.zc"

fn main() {
    let data = "Hello";
    let encoded = Hex::encode((u8*)data, 5);
    println "Hex: {encoded}"; // 48656c6c6f
    
    let decoded_res = Hex::decode(encoded);
    if (decoded_res.is_ok()) {
        let bytes = decoded_res.unwrap();
        // Use bytes...
    }
}
```

--------------------------------

### Setting and Getting Environment Variables in Zeno

Source: https://github.com/zenc-lang/docs/blob/main/std/env.md

Demonstrates how to set an environment variable and retrieve it using both borrowed and owned string methods. Ensure the 'std/env.zc' module is imported.

```zc
import "std/env.zc"

fn main() {
    // Setting an environment variable
    Env::set("MY_APP_MODE", "development");

    // Retrieving (Borrowed)
    match Env::get("MY_APP_MODE") {
        Some(val) => println "Mode: {val}",
        None => println "Mode not set"
    }

    // Retrieving (Owned String for RAII)
    match Env::get_dup("HOME") {
        Some(home) => {
             println "Home: {home}";
             // home is freed automatically
        }
        None => println "HOME not found"
    }
}
```

--------------------------------

### Zen C Substring Extraction

Source: https://github.com/zenc-lang/docs/blob/main/rosetta/Substring.md

Extracts substrings from a UTF-8 encoded string using character index and length. It demonstrates getting substrings of a fixed length, from a starting index to the end, and excluding the last character. It also shows how to find a substring starting from a known character or a known substring.

```zc
import "std/string.zc"

fn main() {
    let s = String::from("αβγδεζηθ");
    let l = s.utf8_len();
    let n = 2;
    let m = 3;
    let kc = 'δ';  // known character
    let ks = String::from("δε");  // known string

    // for reference
    println "Index of characters:  01234567";
    println "Complete string:      {s}";

    // starting from n characters in and of m length
    let ss1 = s.utf8_substr(n, m);
    println "Start {n}, length {m}:    {ss1}";

    // starting from n characters in, up to the end of the string
    let ss2 = s.utf8_substr(n, l - n);
    println "Start {n}, to end:      {ss2}";

    // whole string minus last character
    let ss3 = s.utf8_substr(0, l - 1);
    println "All but last:         {ss3}";

    // starting from a known character within the string and of m length
    let dx = -1;
    for i, c in s {
        if c == kc {
            dx = i;
            break;
        }
    }
    if dx >= 0 {
        let ss4 = s.utf8_substr(dx, m);
        let kcs = String::from_rune(kc);
        println "Start '{kcs}', length {m}:  {ss4}";
    }

    // starting from a known substring within the string and of m length
    let sx = -1;
    let first  = ks.utf8_get(0);
    let second = ks.utf8_get(1);
    for i in 0..(s.utf8_len() - 1) {
        if s.utf8_get(i) == first && s.utf8_get(i + 1) == second {
            sx = i;
            break;
        }
    }
    if (sx >= 0) {
        let ss5 = s.utf8_substr(sx, m);
        println "Start '{ks}', length {m}: {ss5}";
    }
}

```

--------------------------------

### Zen C function to extract text between start and end strings

Source: https://github.com/zenc-lang/docs/blob/main/rosetta/Text_between.md

This function finds and returns the substring located between the first occurrence of the 'start' string and the first occurrence of the 'end' string after the 'start' string. It handles cases where start or end strings are empty, not found, or are special keywords like 'start' and 'end'.

```zc
import "std/string.zc"

fn text_between(str: string, start: string, end: string) -> String {
    if strlen(start) == 0 || strlen(end) == 0 {
        eprintln "Start and end must both be non-empty strings.";
    }
    if strlen(str) == 0 { return String::new(""); }
    let s: int;
    let t: int;
    if strcmp(start, "start") == 0 {
        s = 0;
        t = 0;
    } else {
        let u = strstr(str, start);
        if u {
            s = u - str;
            t = s + strlen(start);
        } else {
            return String::new("");
        }
    }
    let e: int;
    if strcmp(end, "end") == 0 {
        e = strlen(str);
    } else {
        let u = strstr(str + t, end);
        if u {
            e = u - str;
        } else {
            let ss = String::from(str);
            return ss.substring(t, ss.length() - t);
        }
    }
    let ss = String::from(str);
    return ss.substring(t, e - t);
}

fn main() {
    let texts = [
        "Hello Rosetta Code world",
        "Hello Rosetta Code world",
        "Hello Rosetta Code world",
        "</div><div style=\"chinese\">你好嗎</div>",
        "<text>Hello <span>Rosetta Code</span> world</text><table style=\"myTable\">",
        "<table style=\"myTable"><tr><td>hello world</td></tr></table>",
        "The quick brown fox jumps over the lazy other fox",
        "One fish two fish red fish blue fish",
        "FooBarBazFooBuxQuux"
    ];

    let starts = [
        "Hello ", "start", "Hello ", "<div style=\"chinese\">",
        "<text>", "<table>", "quick ", "fish ", "Foo"
    ];

    let ends = [
        " world", " world", "end", "</div>",
        "<table>",
        "</table>", " fox", " red", "Foo"
    ];

    for i, text in texts {
        println "Text   : \"{text}\"";
        println "Start  : \"{starts[i]}\"";
        println "End    : \"{ends[i]}\"";
        let b = text_between(text, starts[i], ends[i]);
        println "Result : \"{b}\"\n"; 
    }
}
```

--------------------------------

### Zen-C Slice Usage Example

Source: https://github.com/zenc-lang/docs/blob/main/std/slice.md

Demonstrates explicit slice creation from an array and iteration over a slice and an array. The std/slice.zc module is imported.

```zc
import "std/slice.zc"

fn main() {
    let arr: int[5] = [10, 20, 30, 40, 50];
    
    // Explicit slice creation
    let s = Slice<int>::from_array(arr, 5);
    
    // Direct iteration over the slice
    for val in s {
        println "{val}";
    }
    
    // Directly iterating over the array (auto-imports std/slice.zc)
    for val in arr {
        println "{val}";
    }
}
```

--------------------------------

### Vec Access: Get, Get Ref, Set

Source: https://github.com/zenc-lang/docs/blob/main/std/vec.md

Illustrates accessing elements by index using get() for a copy, get_ref() for a pointer, and set() to overwrite an element.

```zc
let item = v.get(0);
let item_ptr = v.get_ref(0);
v.set(0, 10);
```

--------------------------------

### Arena Usage Example

Source: https://github.com/zenc-lang/docs/blob/main/std/arena.md

Demonstrates creating an arena, performing allocations for structs and strings, and checking memory usage. Memory is automatically freed when the arena goes out of scope.

```zc
import "std/arena.zc"

struct Node {
    val: int;
}

fn main() {
    // Create arena with 1KB capacity
    let a = Arena::new(1024);
    
    // Fast allocations
    let n1 = a.alloc<Node>();
    let n2 = a.alloc<Node>();
    
    // Duplicate string into arena memory
    let s = a.dup_str("Hello World");
    
    println "Arena used: {a.bytes_used()} bytes";
    
    // Everything is freed automatically when 'a' goes out of scope
}
```

--------------------------------

### Sample Session Output

Source: https://github.com/zenc-lang/docs/blob/main/rosetta/Finite_state_machine.md

This shows a typical interactive session with the Zen C finite state machine implementation, illustrating user inputs and the corresponding program outputs for different state transitions.

```text
Please enter your option when prompted
(any characters after the first will be ignored)

(D)ispense or (Q)uit : d
OK, put your money in the slot
(S)elect product or choose a (R)efund : s
(R)emove product : r

(D)ispense or (Q)uit : d
OK, put your money in the slot
(S)elect product or choose a (R)efund : r
OK, refunding your money

(D)ispense or (Q)uit : q
OK, quitting
```

--------------------------------

### Main Function with Test Cases

Source: https://github.com/zenc-lang/docs/blob/main/rosetta/Rep-string.md

Entry point of the program that initializes an array of strings and calls rep_string for each to demonstrate the functionality.

```Zen C
fn main() {
    println "The (longest) rep-strings are:\n";
    let strings: string[11] = [
        "1001110011",
        "1110111011",
        "0010010010",
        "1010101010",
        "1111111111",
        "0100101101",
        "0100100",
        "101",
        "11",
        "00",
        "1"
    ];
    for s in strings { rep_string(s); }
}
```

--------------------------------

### Compile with C Interop Warnings Enabled

Source: https://github.com/zenc-lang/docs/blob/main/reference/16-diagnostics.md

Example of compiling a Zen C application with C interop warnings enabled using the -Winterop flag.

```bash
# Compile with C interop warnings enabled
zc app.zc -Winterop
```

--------------------------------

### Spawning and Joining a Thread

Source: https://github.com/zenc-lang/docs/blob/main/std/thread.md

Demonstrates how to spawn a new thread with a closure and then explicitly wait for its completion using `join`. Ensure the thread is joined to manage resources properly.

```zc
import "std/thread.zc"

fn worker(id: int) {
    println "Hello from worker {id}";
}

fn main() {
    // Spawning with a closure
    let t = Thread::spawn(|| {
        worker(42);
    }).unwrap();
    
    // Explicitly waiting for completion
    t.join();
}
```

--------------------------------

### Generate Gapful Numbers in Zen C

Source: https://github.com/zenc-lang/docs/blob/main/rosetta/Gapful_numbers.md

This snippet generates and prints a specified number of gapful numbers starting from a given value. It includes locale setting for number formatting and iterates through different starting points and counts.

```zc
import "locale.h"

fn main() {
    setlocale(LC_NUMERIC, "en_US.UTF-8");
    let starts: u64[5] = [100, 1_000_000, 10_000_000, 1_000_000_000, 7123];
    let totals: int[5] = [30, 15, 15, 10, 25];
    for i in 0..5 {
        let count = 0;
        let j = starts[i];
        let pow: u64 = 100;
        loop {
            if j < pow * 10 { break; }
            pow *= 10;
        }
        println "First {totals[i]} gapful numbers starting at {starts[i]:'lu}";
        while totals[i] > count {    
            let fl = j / pow * 10 + (j % 10);
            if !(j % fl) {
                print "{j} ";
                count++;
            }
            if ++j >= 10 * pow { pow *= 10; }
        }
        println "\n";
    }
}
```

--------------------------------

### Zen C Object Method Call

Source: https://github.com/zenc-lang/docs/blob/main/rosetta/Call_an_object_method.md

This snippet shows how to define a struct, implement methods (both static and instance), and then call these methods from the main function. It requires no external setup.

```Zen C
struct MyStruct {}

impl MyStruct {
    fn static_method() {
        println "static method called";
    }

    fn method(self) {
        println "instance method called";
    }
}

fn main() {
    let mc = MyStruct{};
    mc.method();
    MyStruct::static_method();
}
```

--------------------------------

### Basic Queue Usage

Source: https://github.com/zenc-lang/docs/blob/main/std/queue.md

Demonstrates creating a new queue, pushing elements, and popping elements. Note that pop returns an Option<T>.

```zc
import "std/queue.zc"

fn main() {
    let q = Queue<int>::new();
    
    q.push(1);
    q.push(2);
    q.push(3);
    
    // Pop returns an Option<T>
    if (q.pop().is_some()) {
        println "Popped: {q.pop().unwrap()}"; // 1
    }
}
```

--------------------------------

### Zen C Program Name Example

Source: https://github.com/zenc-lang/docs/blob/main/rosetta/Program_name.md

This snippet shows how to define the main function in Zen C and access the program name from the command-line arguments.

```zc
fn main(argc: int, argv: char**) {
    println "My name is: {argv[0]}";
}
```

--------------------------------

### Basic Path Manipulation

Source: https://github.com/zenc-lang/docs/blob/main/std/path.md

Demonstrates creating a Path, joining another path segment, and extracting the file extension. Memory is automatically managed.

```Zenc
import "std/path.zc"

fn main() {
    let p = Path::new("/home/user");
    let full_path = p.join("docs/file.txt");
    
    println "Full path: {full_path.c_str()}";
    
    match full_path.extension() {
        Some(ext) => println "Extension: {ext}",
        None => println "No extension found"
    }
} // full_path and p are freed automatically here
```

--------------------------------

### Server::new

Source: https://github.com/zenc-lang/docs/blob/main/std/net.md

Creates a new HTTP server instance.

```APIDOC
## Server::new

### Description
Creates a new HTTP server.

### Method
`Server::new`

### Parameters
#### Path Parameters
- **port** (int) - Required - The port number to listen on.
- **handler** (fn(Request*, Response*)) - Required - The function to handle incoming requests.

### Response
#### Success Response
- **Server** - The newly created HTTP server instance.
```

--------------------------------

### fetch

Source: https://github.com/zenc-lang/docs/blob/main/std/net.md

Performs an HTTP GET request to the specified URL.

```APIDOC
## fetch

### Description
Performs a GET request.

### Method
`fetch`

### Parameters
#### Path Parameters
- **url** (String) - Required - The URL to fetch.

### Response
#### Success Response
- **Response** - The HTTP response object.
```

--------------------------------

### Get PI Constant

Source: https://github.com/zenc-lang/docs/blob/main/std/math.md

Retrieves the value of Archimedes' constant (PI).

```zc
let pi_value = Math::PI();
```

--------------------------------

### Generic Swap Example in Zen C

Source: https://github.com/zenc-lang/docs/blob/main/rosetta/Generic_swap.md

This snippet demonstrates swapping integer and string variables using the generic swap function. Ensure variables are of the same type before swapping.

```Zen C
import "std/mem.zc"

fn main() {
    let a = 1;
    let b = 2;
    println "Before: a = {a}, b = {b}";
    swap(&a, &b);
    println "After : a = {a}, b = {b}";
    println "";
    let s = "Rosetta";
    let t = "Code";
    println "Before: s = {s}, t = {t}";
    swap(&s, &t);
    println "After : s = {s}, t = {t}";
}
```

--------------------------------

### Get Character Iterator

Source: https://github.com/zenc-lang/docs/blob/main/std/string.md

Returns an iterator that yields `Option<rune>` for each character in the String.

```zc
chars(self) -> StringCharsIter

```

--------------------------------

### Zen-C SIMD Initialization and Operations

Source: https://github.com/zenc-lang/docs/blob/main/std/simd.md

Demonstrates initialization of f32x4 vectors, broadcasting a value to all lanes, performing element-wise addition, and accessing individual lanes.

```zc
import "std/simd.zc"

fn main() {
    // Initialization (Explicit lanes)
    let a = f32x4 { 1.0, 2.0, 3.0, 4.0 };
    
    // Broadcasting (Single value to all lanes)
    let b = f32x4 { v: 2.0 };
    
    // Element-wise addition
    let c = a + b;   // Result: { 3.0, 4.0, 5.0, 6.0 }
    
    // Lane Access
    let first = c[0];
}
```

--------------------------------

### Array Initialization, Access, and Iteration in Zen C

Source: https://github.com/zenc-lang/docs/blob/main/rosetta/Arrays.md

Demonstrates explicit initialization, zero-initialization using a compile-time constant, element access and mutation, and iterating over arrays using for-in loops in Zen C.

```Zen C
fn main() {
    def SIZE = 3;

    // Explicitly initialized array
    let ints: int[5] = [1, 2, 3, 4, 5];
    
    // Zero-initialized array using a compile-time constant for size
    let zeros: [int; SIZE];
    
    // Element access and mutation
    zeros[0] = 42;
    zeros[2] = 100;
    
    println "Iterating over ints array:";
    for val in ints {
        println "{val}";
    }
    
    println "\nIterating over zeros array:";
    for val in zeros {
        println "{val}";
    }
}
```

--------------------------------

### Get UTF-8 Length

Source: https://github.com/zenc-lang/docs/blob/main/std/string.md

Returns the number of Unicode code points (characters) in the String.

```zc
utf8_len(self) -> usize

```

--------------------------------

### Get String Length

Source: https://github.com/zenc-lang/docs/blob/main/std/string.md

Returns the number of characters in the String, excluding the null terminator.

```zc
length(self) -> usize

```

--------------------------------

### Main program to demonstrate Padovan sequences

Source: https://github.com/zenc-lang/docs/blob/main/rosetta/Padovan_n-step_number_sequences.md

The main function sets up an array of size 15 and then iterates through 'n' values from 2 to 8. For each 'n', it calculates and prints the first 15 terms of the corresponding Padovan n-step sequence.

```zc
fn main() {
    let t: const usize = 15;
    let p: int[t];
    println "First {t} terms of the Padovan n-step number sequences:";
    for n in 2..=8 {
        for i in 0..t { p[i] = 0; }
        padovan_n(n, t, p);
        print "{n}: ";
        for i in 0..t { print "{p[i]:3d} "; }
        println "";
    }
}
```

--------------------------------

### Get Match End Index

Source: https://github.com/zenc-lang/docs/blob/main/std/regex.md

Returns the index immediately after the last character of the match.

```zc
end(self) -> int
```

--------------------------------

### Basic Input/Output Operations

Source: https://github.com/zenc-lang/docs/blob/main/std/io.md

Demonstrates basic printing to stdout and reading a line of input from stdin. Requires importing the 'std/io.zc' module.

```zc
import "std/io.zc"

fn main() {
    // Basic printing
    println("Hello, %s!", "Zen-C");
    
    // Reading a line of input
    print("Enter your name: ");
    autofree let name = readln();
    
    if name != NULL {
        println("Greeting, %s", name);
    }
}
```

--------------------------------

### Zen C GTK Click Counter Application

Source: https://github.com/zenc-lang/docs/blob/main/rosetta/Simple_windowed_application.md

This snippet demonstrates how to create a simple GTK window with a label and a button. It initializes GTK, sets up the window and widgets, and connects signals for button clicks and window destruction. This is suitable for basic GUI applications.

```Zen C
//> pkg-config: gtk+-3.0

import "gtk/gtk.h" as gtk;

let counter = 0;
let label: gtk::GtkWidget*;

fn on_button_clicked(_: gtk::GtkWidget*, __: gtk::gpointer) {
    counter += 1;
    
    let text = "Button clicked {counter} times";
    if counter == 1 {
        text = "Button clicked 1 time";
    }
    
    gtk::gtk_label_set_text((gtk::GtkLabel*)label, text);
}

fn main(argc: int, argv: char**) {
    // Initialize GTK
    gtk::gtk_init(&argc, &argv);

    // Create the main window
    let window = gtk::gtk_window_new(gtk::GTK_WINDOW_TOPLEVEL);
    gtk::gtk_window_set_title((gtk::GtkWindow*)window, "Click Counter");
    gtk::gtk_window_set_default_size((gtk::GtkWindow*)window, 300, 200);
    gtk::gtk_container_set_border_width((gtk::GtkContainer*)window, 10);

    // Connect the destroy signal to quit the application
    gtk::g_signal_connect_data(window, "destroy", (gtk::GCallback)gtk::gtk_main_quit, 0, 0, 0);

    // Create a vertical box container
    let vbox = gtk::gtk_box_new(gtk::GTK_ORIENTATION_VERTICAL, 10);
    gtk::gtk_container_add((gtk::GtkContainer*)window, vbox);
    
    // Create and add the label
    label = gtk::gtk_label_new("There have been no clicks yet");
    gtk::gtk_box_pack_start((gtk::GtkBox*)vbox, label, true, true, 0);

    // Create and add the button
    let button = gtk::gtk_button_new_with_label("click me");
    gtk::gtk_box_pack_start((gtk::GtkBox*)vbox, button, true, true, 0);

    // Connect the button click signal
    gtk::g_signal_connect_data(button, "clicked", (gtk::GCallback)on_button_clicked, 0, 0, 0);
    
    // Show all widgets and start the GTK main loop
    gtk::gtk_widget_show_all(window);
    gtk::gtk_main();
}

```

--------------------------------

### Multi-Index Operator Overloading (get)

Source: https://github.com/zenc-lang/docs/blob/main/reference/06-operators.md

Shows how to overload the multi-index access operator for a struct.

```zc
struct Matrix {
    data: int[9];
}

impl Matrix {
    fn get(self, row: int, col: int) -> int {
        return self.data[row * 3 + col];
    }
}

let m = Matrix{data: [1,0,0, 0,1,0, 0,0,1]};
let val = m[1, 2]; // Calls Matrix.get(m, 1, 2)
```

--------------------------------

### Main Function for FFT Demonstration in Zen C

Source: https://github.com/zenc-lang/docs/blob/main/rosetta/Fast_Fourier_transform.md

This main function demonstrates the FFT implementation. It creates a sample signal, pads it to a power of two, prints the input signal, computes the FFT, and then prints the FFT output. It utilizes complex number formatting and magnitude calculations.

```Zen C
fn main() {
    println "=> Fast Fourier Transform (FFT)";
    
    let signal = Vec<Complex>::with_capacity(8);
    for _i in 0..4 {
        signal.push(Complex::new(1.0, 0.0));
    }
    for _i in 4..8 {
        signal.push(Complex::new(0.0, 0.0));
    }

    pad_to_power_of_2(&signal);

    println "Input Signal (len: {signal.len}):";
    let i = 0;
    for val in signal {
        let mag = val.magnitude();
        let s = val.to_string();
        let s_ptr = s.c_str();
        println "\tx[{i}] = {s_ptr}  (Magnitude: {mag})";
        i += 1;
    }
    
    let fft_output = fft_recursive(signal);
    
    println "\nFFT Output:";
    let k = 0;
    for X in fft_output {
        let mag = X.magnitude();
        let s = X.to_string();
        let s_ptr = s.c_str();
        println "\tX[{k}] = {s_ptr}  (Magnitude: {mag})";
        k += 1;
    }
}
```

--------------------------------

### Check if String Starts With Prefix

Source: https://github.com/zenc-lang/docs/blob/main/std/string.md

Determines if the String begins with a specified C string prefix.

```zc
starts_with(self, prefix: char*) -> bool

```

--------------------------------

### Get All Runes as Vector

Source: https://github.com/zenc-lang/docs/blob/main/std/string.md

Returns a vector containing all Unicode code points (runes) from the String.

```zc
runes(self) -> Vec<rune>

```

--------------------------------

### Create and Use a Stack

Source: https://github.com/zenc-lang/docs/blob/main/std/stack.md

Demonstrates creating a new stack, pushing elements, and popping the top element. The stack is automatically freed when it goes out of scope.

```zc
import "std/stack.zc"

fn main() {
    let s = Stack<int>::new();
    s.push(10);
    s.push(20);
    
    let top = s.pop(); // Some(20)
} // s is freed automatically here
```

--------------------------------

### Get C String Pointer

Source: https://github.com/zenc-lang/docs/blob/main/std/string.md

Returns a pointer to the null-terminated C-style string representation of the String.

```zc
c_str(self) -> char*

```

--------------------------------

### Basic Math Usage

Source: https://github.com/zenc-lang/docs/blob/main/std/math.md

Demonstrates importing the math module and using PI and pow to calculate the area of a circle.

```zc
import "std/math.zc"

fn main() {
    let radius = 5.0;
    let area = Math::PI() * Math::pow(radius, 2.0);
    println "Area of circle: {area}";
}
```

--------------------------------

### Get File Metadata

Source: https://github.com/zenc-lang/docs/blob/main/std/stat.md

Retrieves and prints the size and mode of a file. Checks if the file is a directory.

```Zsh
import "std/sys/stat.zc"
import "std/io.zc"

fn main() {
    let res = FileStat::stat("myfile.txt");
    if (res.is_some()) {
        let st = res.unwrap();
        println "Size: {st.size} bytes";
        println "Permissions: {st.mode}";
        
        if (FileStat::is_dir(st.mode)) {
            println "It is a directory.";
        }
    }
}
```

--------------------------------

### Slice<T>::at

Source: https://github.com/zenc-lang/docs/blob/main/std/slice.md

Alias for `get`. Safely retrieves the element at the specified index, returning `Some(T)` or `None`.

```APIDOC
## Slice<T>::at

### Description
Alias for `get`.

### Signature
`at(self, idx: usize) -> Option<T>`
```

--------------------------------

### Basic Usage of std/iter

Source: https://github.com/zenc-lang/docs/blob/main/std/iter.md

Demonstrates how to import and use the std/iter module with a custom collection in a 'for-in' loop.

```zc
import "std/iter.zc"

fn main() {
    // Assuming my_collection implements Iterable<T>
    for item in my_collection {
        // ...
    }
}
```

--------------------------------

### Get Euler's Number Constant

Source: https://github.com/zenc-lang/docs/blob/main/std/math.md

Retrieves the value of Euler's number (e).

```zc
let e_value = Math::E();
```

--------------------------------

### Get Rune at UTF-8 Index

Source: https://github.com/zenc-lang/docs/blob/main/std/string.md

Returns the Unicode code point at a specified character index as a `rune`.

```zc
utf8_get(self, idx: usize) -> rune

```

--------------------------------

### Once Methods

Source: https://github.com/zenc-lang/docs/blob/main/std/sync.es.md

Proporciona un método para garantizar que una pieza de código de inicialización se ejecute exactamente una vez, incluso en entornos concurrentes.

```APIDOC
## Once::new

### Description
Crea una nueva instancia de `Once`.

### Method
`Once::new() -> Once`

### Parameters
None

### Response
#### Success Response
- **Once** (Once) - Una nueva instancia de Once.

## Once::call

### Description
Ejecuta la función proporcionada exactamente una vez. Si `call` se invoca múltiples veces, solo la primera invocación ejecutará la función. Las invocaciones posteriores no harán nada.

### Method
`call(self, func: fn())`

### Parameters
- **self** (Once) - La instancia de Once.
- **func** (fn()) - La función a ejecutar una sola vez.

### Response
None
```

--------------------------------

### Getting Boolean Value from JSON

Source: https://github.com/zenc-lang/docs/blob/main/std/json.md

Safely retrieves the boolean value if the JsonValue is a boolean. Returns an Option.

```zc
as_bool(self) -> Option<bool>
```

--------------------------------

### Getting Integer Value from JSON

Source: https://github.com/zenc-lang/docs/blob/main/std/json.md

Safely retrieves the integer value if the JsonValue is a number. Returns an Option.

```zc
as_int(self) -> Option<int>
```

--------------------------------

### Function Signatures for Resource Handling

Source: https://github.com/zenc-lang/docs/blob/main/reference/08-memory-management.md

Demonstrates how function signatures handle resource ownership. Resources are moved into functions by default, while references allow borrowing.

```zc
fn process(r: Resource) { ... } // 'r' is moved into function
fn peek(r: Resource*) { ... }   // 'r' is borrowed (reference)
```

--------------------------------

### Getting String Value from JSON

Source: https://github.com/zenc-lang/docs/blob/main/std/json.md

Safely retrieves the string pointer if the JsonValue is a string. Returns an Option.

```zc
as_string(self) -> Option<char*>
```

--------------------------------

### Basic Memory Allocation and Box Usage

Source: https://github.com/zenc-lang/docs/blob/main/std/mem.md

Demonstrates manual memory allocation using alloc and free, as well as the automatic memory cleanup provided by the Box<T> smart pointer (RAII).

```zc
import "std/mem.zc"

fn main() {
    // Manual allocation
    let ptr = alloc<int>();
    *ptr = 42;
    free(ptr);
    
    // Automatic cleanup with Box (RAII)
    {
        let b = Box<int>::new();
        *b.get() = 100;
        // memory is freed automatically here
    }
}
```

--------------------------------

### Get Character at UTF-8 Index

Source: https://github.com/zenc-lang/docs/blob/main/std/string.md

Returns the Unicode code point at a specified character index as a new String.

```zc
utf8_at(self, idx: usize) -> String

```

--------------------------------

### Getting Float Value from JSON

Source: https://github.com/zenc-lang/docs/blob/main/std/json.md

Safely retrieves the double-precision floating-point value if the JsonValue is a number. Returns an Option.

```zc
as_float(self) -> Option<double>
```

--------------------------------

### Null Assignment Operator (??=) Example

Source: https://github.com/zenc-lang/docs/blob/main/reference/06-operators.md

Shows how to use the null assignment operator to assign a value only if the pointer is NULL.

```zc
let p: int* = NULL;
p ??= &42;
assert(*p == 42);
```

--------------------------------

### Build, Serialize, and Parse JSON

Source: https://github.com/zenc-lang/docs/blob/main/std/json.es.md

Demonstrates creating a JSON object, serializing it to a string, and then parsing a JSON string. Memory is managed automatically.

```zc
import "std/json.zc"

fn main() {
    // Construyendo JSON
    let obj = JsonValue::object();
    obj.set("nombre", JsonValue::string("Alicia"));
    obj.set("edad", JsonValue::number(30.0));
    obj.set("activo", JsonValue::bool(true));
    
    // Serialización
    let json_str = obj.to_string();
    println "Serializado: {json_str}";
    
    // Análisis
    let entrada = "{\"puntuación\": 100}";
    match JsonValue::parse(entrada) {
        Ok(parsed) => {
            println "Puntuación: {parsed.get(\"puntuación\").unwrap().as_int().unwrap()}";
            // parsed se libera automáticamente cuando termina este bloque
        }
        Err(e) => println "Error: {e}"
    }
} // obj se libera automáticamente aquí
```
Tokens:
Raw