Using Zig compto to Generate a Compile-Time Lookup Table

Desired Outcome

Create a lookup table (e.g., sine values) that is fully computed during compilation so that the resulting binary contains only the constant data, with no runtime cost for the table generation.

Prerequisites

• Zig compiler version 0.12.0 or later (the compto feature is stable in recent releases).
• A project set up with zig build init or a simple main.zig file.
• Basic familiarity with Zig syntax, especially loops and arrays.

Procedure

1. Open main.zig (or create it) and add a compto block that fills an array with the desired values. The block runs at compile time, must be deterministic, and cannot perform I/O or mutate global state.
2. Example: a 256‑entry sine table.

const std = @import("std");
const PI = std.math.PI;

comptime {
    // The table is a constant array of 256 f32 values.
    const sin_table: [256]f32 = {
        var i: usize = 0;
        while (i < 256) : (i += 1) {
            // Compute sin(2π * i / 256) at compile time.
            @sin(f32(i) * 2.0 * PI / 256.0)
        }
    };
    // Export the table so other code can use it.
    pub const sin_table = sin_table;
}

pub fn main() void {
    // Use the table at runtime – no computation happens here.
    std.debug.print("sin(π/2) ≈ {f}\n", .[sin_table[64]]);
}

3. Build the program in a release mode to see the zero‑cost effect.

zig build-exe main.zig -Drelease-fast

Expected Checks

• Compile succeeds without warnings about side effects in the compto block.
• Run the executable; it should print a value close to 1.0 (the sine of π/2).
• To verify that no runtime computation occurs, inspect the generated assembly:
• zig build-exe main.zig -Drelease-fast -femit-asm=main.asm
• Search main.asm for the table data; you should see a sequence of floating‑point constants, not a loop or call to sin.
• Optionally, add @compileLog(@TypeOf(sin_table)); inside the compto block to confirm the type during compilation.

Recovery / Rollback

Since the compto block only produces compile‑time constants and does not modify any files or system state, no rollback is required. If the build fails due to a non‑deterministic operation (e.g., accidental I/O), simply remove or correct the offending code and rebuild.