fixed

import fixed from "fixed";

@tape {
    fixed.gen_fixed_vec(u8, 256);          // FixedVec_u8_256
    fixed.gen_ring(i64, 16);               // Ring_i64_16
    fixed.gen_fixed_map(u32, i64, 64);     // FixedMap_u32_i64_64
}

var line: FixedVec_u8_256 = fixed_vec_u8_256_new();
if (!line.push(65)) { /* full */ }

var events: Ring_i64_16 = ring_i64_16_new();
events.push_back(7);
let next: ?i64 = events.pop_front();      // 7

var ports: FixedMap_u32_i64_64 = fixed_map_u32_i64_64_new();
ports.set(80 as u32, 3);
let fd: ?i64 = ports.get(80 as u32);      // 3

fixed has containers whose elements live inside the container value itself: a FixedVec_u8_256 is 256 bytes and a length, nothing more. They never allocate, so they work in every profile, t0 included: in a kernel, a network stack, a freestanding program, or wherever you want a container that lives in a global, on the stack or in an arena block.

The capacity is part of the type, chosen when you generate it (gen_fixed_vec(T, N) gives FixedVec_T_N). When a container is full, adding returns false and changes nothing; taking from an empty one returns null. An index outside 0..len() stops the program with a trap, as an array’s does.

Elements are plain values, copied by assignment: numbers, bool, enums, pointers, views ([]const u8, and string in t0, which is a view there), and structs of those. Assigning a container copies all of it. A t1 string (owned) is refused when you generate: these containers never free what they hold. For growable, owning containers use collections.

The module is @profile(t0) and pure. It’s all generators: call them in a @tape block, and the types land in your module.

FixedVec

FixedVec_T_N holds up to N elements in order.

Ring

Ring_T_N is a queue of up to N elements you can push to and pop from at both ends, in a circular buffer (any N, not only powers of two).

@tape { fixed.gen_ring(u8, 64); }

var rx: Ring_u8_64 = ring_u8_64_new();
fn on_byte(b: u8) {
    if (!rx.push_back(b)) { /* overrun: drop the byte */ }
}

FixedMap

FixedMap_K_V_N maps up to N keys to values, in N slots (N must be a power of two). Keys are integers, bool, enums, pointers or text ([]const u8, and t0’s string): text is compared by content and hashed with FNV-1a, and stored as the view, so the bytes must outlive the map.

A map that is nearly full gets slower (a lookup walks past more slots): give it room, twice the keys you expect is a good size. For other keys, gen_fixed_map_by(K, V, N, hash_fn, eq_fn) takes your hash fn(*const K) -> u64 and equality fn(*const K, *const K) -> bool; keys that are equal must hash the same.

Removing a key moves the entries after it, so a pointer from get_ptr is valid only until the next remove.

FixedPool

FixedPool_T_N is collections’ Pool in N inline slots: values reached by handles (FixedHandle_T_N, an index and a generation), so a removed value’s old handles find nothing.

pub struct Enemy { x: i64; hp: i64; }

@tape { fixed.gen_fixed_pool(Enemy, 64); }    // FixedPool_Enemy_64, FixedHandle_Enemy_64

var enemies: FixedPool_Enemy_64 = fixed_pool_Enemy_64_new();
let h: ?FixedHandle_Enemy_64 = enemies.insert(Enemy { x: 0, hp: 3 });
if (h == null) { /* all 64 slots taken */ }
let orc: FixedHandle_Enemy_64 = h!;
enemies.remove(orc);
let gone: ?Enemy = enemies.get(orc);          // null: the handle is stale

The rules are Pool’s: freed slots are reused (last freed first) with a new generation, a slot whose generation would wrap is retired, iteration skips free slots. The slots never move, so a get_ptr pointer stays valid until that value is removed.

FixedSparseSet

FixedSparseSet_T_N is collections’ SparseSet for ids 0 to N - 1: values keyed by id, packed together. Pair it with a FixedPool of the same N and key it by the handle’s index.

@tape {
    fixed.gen_fixed_pool(Enemy, 64);
    fixed.gen_fixed_sparse_set(i64, 64);        // FixedSparseSet_i64_64
}

var burning: FixedSparseSet_i64_64 = fixed_sparse_set_i64_64_new();
burning.set(orc.index, 5);                    // 5 ticks of fire for this enemy

List

List_T is a doubly linked list of nodes you own: it allocates nothing. A node type has a field link: fixed.Link, which the list uses to chain the nodes. A node is in at most one list at a time (per Link field), and must not move while it’s in one.

pub struct Task {
    id: i64;
    link: fixed.Link;
}

@tape { fixed.gen_list(Task); }

var ready: List_Task = list_Task_new();
var a: Task = Task { id: 1, link: fixed.Link { prev: null, next: null } };
var b: Task = Task { id: 2, link: fixed.Link { prev: null, next: null } };
ready.push_back(&a);
ready.push_back(&b);
ready.remove(&a);                       // unlinked in constant time
let first: ?*Task = ready.first();      // &b
for (t in ready.iter()) { /* t: *Task */ }

Generators

Three helpers are public for other generators (collections builds its maps’ key handling on them):

Names follow the $T naming: a []const u8 key is cslice_u8 (FixedMap_cslice_u8_i64_16), and so is a string key in t0, where string is that view.

Last modified: 2026-10-31 22:31:06 UTC