The Zig Cheatsheet

?T is a value or null — test it, default it, or capture it; there is no truthiness.

?T holds a value of T or null. Test with o == null, default with orelse, unwrap-assert with .?, or capture the payload with if (o) |v|.

Create, test, unwrap

const maybe: ?i32 = null;
const n: ?i32 = 42;

if (n) |v| {
    std.debug.print("got {d}\n", .{v});  // payload capture
} else {
    std.debug.print("nothing\n", .{});
}

const a = maybe orelse 0;        // 0 — fallback when null
const b = n.?;                   // 42 — panics if null
std.debug.print("{d} {d}\n", .{ a, b });

Operation	Value present	`null`
`o orelse d`	yields `o`	yields `d`
`o.?`	yields `o`	panic: attempt to use null value
`if (o) \|v\| a else b`	`a`, with `v` bound	`b`
`while (o) \|v\| { ... }`	body per value	loop ends

#045

While-Unwrap & Iterators

while (iter.next()) |item| is the idiomatic iterator loop; else fires when the loop ends without break.

An iterator is any type with fn next() ?T — each call yields the next value or null. The while-unwrap loop consumes it: the body runs per value, the loop ends when null arrives.

Custom iterator over ?u32

const Counter = struct {
    remaining: u32 = 3,
    fn next(self: *Counter) ?u32 {
        if (self.remaining == 0) return null;
        self.remaining -= 1;
        return self.remaining;        // yields 2, 1, 0
    }
};
var it = Counter{};
while (it.next()) |item| {            // ?u32 unwrapped per pass
    std.debug.print("{d} ", .{item});
} else {
    std.debug.print("ended, no break\n", .{}); // runs: no break used
}

#046

Optional Pointers

?*T costs nothing extra — null hides in the pointer's spare bit pattern; ?u32 pays for a tag.

?*T occupies exactly the same bytes as *T: address 0 is never a valid pointer, so it encodes null for free. Payloads without a spare bit pattern (?u32, ?bool) need a hidden tag byte. This is why linked-list next fields, tree children, and find-style APIs returning ?usize all use optional pointers.

zig

const Entry = struct {
    id: u32,
    next: ?*Entry = null,       // linked list: null is free
};

const Config = struct {
    home: ?[]const u8 = null,   // optional slice field
    fallback: ?*const Config = null,
};

fn findIndex(hay: []const u8, needle: u8) ?usize {
    for (hay, 0..) |c, i| {
        if (c == needle) return i;   // find-style API
    }
    return null;
}

Type	Size	Why
`?*T`	== `@sizeOf(*T)`	`0` is reserved — `null` is free
`?*const T`	== `@sizeOf(*const T)`	same trick
`?u32`	> `@sizeOf(u32)`	extra tag, padded to alignment
`?bool`	> `@sizeOf(bool)`	no spare bit pattern

#047

Patterns & Gotchas

orelse chains, nested optionals, and why catch is not orelse.

zig

// orelse chain: first non-null wins
const home = env_home orelse env_user orelse "/tmp";

// capture payload BY POINTER: mutate in place, no copy
if (map.getPtr(key)) |ptr| ptr.count += 1;

// nested optional ??T: legal but rare — unwrap twice
const deep: ??u32 = n;
if (deep) |inner_opt| {
    if (inner_opt) |v| std.debug.print("{d}\n", .{v});
}

null has its own singleton type — @TypeOf(null); optionals are not booleans
a orelse b orelse c short-circuits to the first non-null
nested ??T is allowed but almost always a design smell — prefer ?T or an error union
catch belongs to error unions, orelse to optionals — the two do not interchange

x.? panics with attempt to use null value — and that safety check only exists in Debug and ReleaseSafe. In ReleaseFast it is compiled out: undefined behavior. Prefer orelse or if-capture unless the invariant is locally provable.

Section 9 of 21: Error Handling

6 entries · 09/21

Errors are ordinary values: E!T return types, try/catch, errdefer — no exceptions, no unwinding.

#048

Error Sets

error{...} defines a set of error values — checked at compile time, returned, never thrown.

An error set — error{FileNotFound, OutOfMemory} — is a distinct set of error values, not a class hierarchy. Values coerce upward into any superset for free; anyerror accepts every error that exists.

zig

const OpenError = error{ FileNotFound, AccessDenied };

// combine sets: merged superset, coercion is automatic
const IoError = OpenError || error{ EndOfStream };

// anyerror: the global set — erases the concrete set
var last: anyerror = error.OutOfMemory;

fn open() OpenError!void {
    return error.FileNotFound;   // must be in the return set
}

Form	Meaning
`error{A, B}`	set literal; values are `error.A`, `error.B`
`E1 \|\| E2`	merged superset (coercion target)
`anyerror`	the global set of all errors
`E!T`	error union: an `E` value or a `T` payload

Error sets are not exceptions. They are return values: an error must be handled at the call site or propagated explicitly, and nothing ever unwinds.

#049

Error Unions & Inferred Sets

E!T is error or value; !T lets the compiler infer the set; try/catch unwrap it.

E!T is a union: an error value or a payload. !T (no set named) means inferred — the compiler collects every error the body can return, and inferred sets compose across call chains. Bind one explicitly as IoError!u32 when you want a stable contract.

zig

fn parse(s: []const u8) !u32 {            // ! = inferred error set
    if (s.len == 0) return error.Empty;   // raise: return an error
    return try std.fmt.parseInt(u32, s, 10);
}

const v = parse("42") catch 0;            // fallback value
const w = parse("42") catch unreachable;  // asserts no error
const x = parse("nope") catch |e| blk: {  // labeled catch
    std.debug.print("failed: {s}\n", .{@errorName(e)});
    break :blk 0;
};

try

const v = try parse(s);

catch |e| return e

const v = parse(s) catch |e| return e;

try f() is exactly this sugar: unwrap, or return the error from the enclosing function.

Form	On error	On success
`try f();`	returns the error from this fn	yields the value
`f() catch 0;`	yields `0`	yields the value
`f() catch unreachable;`	panics	yields the value
`f() catch \|e\| handler;`	runs handler, `e` in scope	yields the value

#050

Handling Payloads

Unwrap error unions with if/while payload capture; switch on the error value itself.

zig

const r: ReadError!u32 = read();

if (r) |v| {                          // success: v is the payload
    std.debug.print("ok {d}\n", .{v});
} else |e| {                          // error: e is the error value
    switch (e) {                      // switch on the error set
        error.FileNotFound => create(),
        else => return e,             // propagate the rest
    }
}

while (tryConnect()) |conn| {         // body runs on each success
    serve(conn);
} else |e| return e;                  // runs on the final error

There is no switch on an error union — unwrap with if (r) |v| ... else |e| ... first, then switch the bare error value. A switch (e) over a set must be exhaustive or end in else.

@errorName(e) returns the name as []const u8 — the builtin is @errorName, there is no std.error module
if (r) |v| { ... } else |e| { ... } — success and error branches in one statement
while (attempt()) |v| { ... } else |e| { ... } — retry loops for free

#051

errdefer

errdefer runs cleanup only when an error return passes through its scope.

errdefer arms when execution passes it and fires only when an error return leaves the scope — never on success. Arming it before the resource's own try is pointless: that try already bailed out of the function.

Resource cleanup ordering (LIFO)

const conn = try connect(gpa);   // acquire
errdefer conn.close();           // undo ONLY if we return an error

const buf = try gpa.alloc(u8, 64);
errdefer gpa.free(buf);          // LIFO: freed before conn closes

errdefer |e| std.log.warn("failed: {s}", .{@errorName(e)});

try conn.handshake();            // any failure here or below:
return conn.read();              // log, free buf, close conn, propagate

Form	Fires
`defer f();`	every scope exit
`errdefer f();`	scope exit via error return only
`errdefer \|e\| f(e);`	same, with the error value bound
success return after arming	nothing — the errdefer is skipped

#052

Panics & Unreachable

@panic aborts with no unwinding; unreachable is a contract the optimizer relies on.

zig

std.debug.assert(x > 0);           // "assertion failed" in safe modes

if (buf.len > max_len) @panic("buffer overrun by design");

fn step(s: Phase) void {
    switch (s) {
        .start, .running => advance(s),
        .done => unreachable,       // invariant: never called when done
    }
}

@panic("msg") prints message + trace and aborts — no unwinding: defers do not run
unreachable — reached unreachable code panic in Debug/ReleaseSafe; undefined behavior in ReleaseFast
std.debug.assert(cond) — panics in Debug/ReleaseSafe, compiled out in ReleaseFast/ReleaseSmall
error return traces print in safe builds — every try the error crossed, like a reverse stack trace
gate debug-only code with builtin.mode == .Debug (const builtin = @import("builtin");)

No exceptions, no catch-alls. An error is handled where it occurs or returned explicitly — and error unions cannot cross extern/export boundaries: convert to C-style return codes at the FFI seam.

#053

Error Style Guide

ziglings 009–017, 030–031, 062–063, 098, 103–104, 111

Errors carry no payload — keep sets small, add context where it exists, try liberally.

Error values carry no payload or message. The idiomatic response: small per-module sets, context added at the call site that has it, and errdefer for cleanup.

no payloads, no wrapper types — attach context by logging where you have it, plus errdefer
keep error sets small and per-module; error{OutOfMemory} is ubiquitous and coerces everywhere
try liberally; handle at the call site that actually has context to recover
don't use optionals for failures — ?T means *absent*, E!T means *went wrong*
returning an error from main prints the error trace and exits nonzero

zig

fn load(gpa: Allocator, path: []const u8) !Config {
    const file = try openConfig(path);   // low-level error, no context
    defer file.close();

    return parseConfig(gpa, file) catch |e| {
        std.log.err("config {s}: {s}", .{ path, @errorName(e) }); // context here
        return e;                        // propagate the original error
    };
}

Section 10 of 21: Control Flow

6 entries · 10/21

Conditions must be real bool; if, loops, and switch are expressions — plus labeled blocks for structured jumps.

#054

if / else if / else

Conditions must be genuine bool; if is an expression — that's why there is no ternary.

No truthiness: if (ptr) and if (n) are compile errors — compare explicitly. As an expression, every branch must yield the same type, which is exactly what the ternary would do.

zig

const x: i32 = 7;

// statement form: condition must be bool
if (x > 5) std.debug.print("big\n", .{});

// expression form: replaces the ternary
const parity: []const u8 = if (x % 2 == 0) "even" else "odd";

// payload sugar (see Optionals / Error Handling)
if (maybe) |v| use(v);                     // optional
if (result) |v| use(v) else |e| fail(e);   // error union

braces are optional for a single statement; zig fmt keeps whatever you wrote
when used as an expression, all branches must yield one common type
if (o) |v| unwraps an optional; if (r) |v| ... else |e| unwraps an error union

#055

while

ziglings 009–017, 030–031, 062–063, 098, 103–104, 111

while with a continue-expression, labeled break, and an else clause — no do-while.

while (cond) { } repeats until the condition is false. The continue-expression : (i += 1) runs after every pass — including after continue — making it the safest place for increments.

zig

var i: u32 = 0;
while (i < 5) : (i += 1) {    // continue-expr runs after each pass
    if (i == 3) continue;
    if (i == 4) break;
}

// no do-while: use while (true) + break
while (true) {
    if (ready()) break;
}

// else: runs when the condition ends the loop WITHOUT a break
while (poll()) |v| {          // optional / error-union unwrap
    if (v == 0) break;
} else flush();               // poll() ran dry

break/continue can target a label: break :outer, continue :outer
else after while: fires when the loop ended without break (also else |e| for error unions)
no do-while — write while (true) plus a break

#056

for & Ranges

ziglings 009–017, 030–031, 062–063, 098, 103–104, 111

for walks exclusive ranges and slices, zipping sequences with an optional index.

for (0..n) |i| iterates the exclusive range 0..n. Sequences zip by position — for (xs, ys, 0..) |x, y, i| — and all lengths must match (runtime check in safe builds).

zig

for (0..3) |i| {                      // exclusive range: 0, 1, 2
    std.debug.print("{d} ", .{i});
}
const xs = [_]u8{ 10, 20, 30 };
const ys = [_]u8{ 1, 2, 3 };

for (xs, ys, 0..) |x, y, i| {         // zip: item, item, index
    std.debug.print("{d}+{d}@{d} ", .{ x, y, i });
}                                     // equal lengths, runtime-checked

for (xs) |x| {
    if (x == 20) continue;
    if (x == 30) break;
} else std.debug.print("no break\n", .{});

_ discards a slot: for (xs, 0..) |_, i| iterates indices only
no reverse ranges — index backwards by hand, or std.mem.reverse a copy first
mutate in place with for (slice) |*item| item.* += 1
else on for runs when the loop finished without break

#057

switch

ziglings 009–017, 030–031, 062–063, 098, 103–104, 111

Exhaustive by default; ranges with ...; prongs capture tagged-union payloads.

switch is exhaustive by default: cover every value or add else. It works as expression or statement, and captures |v| bind payloads — especially for tagged unions.

zig

const label = switch (n) {          // expression: prongs yield a value
    0 => "zero",
    1, 2, 3 => "small",             // value list
    4...8 => "medium",              // inclusive range
    else => "large",
};

fn area(s: Shape) f32 {             // union(enum): capture payloads
    return switch (s) {
        .circle => |r| r * r * 3.14159,
        .rect => |d| d[0] * d[1],
    };                              // exhaustive: no else needed
}

Prong	Matches
`1 => ...`	a single value
`1, 2 => ...`	a list of values
`1...5 => ...`	an inclusive range
`.circle => \|r\| ...`	payload capture on `union(enum)`
`else => ...`	everything unmatched

prongs are comma-separated — trailing comma when they span lines
switch works on ints, bools, enums, error sets, and union(enum)s — not strings or floats (use if/else + std.mem.eql)
0.16: prongs accept packed struct/union items (.{ .b = 3 }) and decl literals as values

#058

Labeled Blocks & Loops

ziglings 009–017, 030–031, 062–063, 098, 103–104, 111

Labels turn nested loops and blocks into structured goto — and blocks can yield values.

A label names a loop or block so break :label / continue :label can target it from any nesting depth. Labeled blocks double as multi-step expressions.

zig

outer: for (rows) |row| {
    for (row) |cell| {
        if (cell < 0) break :outer;     // exits BOTH loops
        if (cell == 0) continue :outer; // next outer iteration
    }
}

const idx = blk: {                      // labeled block yields a value
    for (names, 0..) |name, i| {
        if (std.mem.eql(u8, name, want)) break :blk i;
    }
    break :blk null;                    // not found
};

labels work on blocks, for, and while alike
continue :label restarts the labeled loop's next iteration
break :blk value makes a block an expression — replaces goto and early-multi-break acrobatics

#059

unreachable

ziglings 009–017, 030–031, 062–063, 098, 103–104, 111

Proves impossibility to the compiler — or costs you UB in optimized builds.

unreachable asserts a line can never execute. The compiler may optimize based on that promise. Safe modes verify it at runtime: panic reached unreachable code. ReleaseFast believes you: undefined behavior.

zig

fn drive(s: State) void {
    switch (s) {
        .parked, .driving => move(s),
        .scrapped => unreachable,   // invariant: can't happen here
    }
}

Never validate input with unreachable — hostile data hitting it in ReleaseFast is memory corruption, not a crash. Use @panic, try, or else => return error.X for anything reachable.

Section 11 of 21: Functions

6 entries · 11/21

Required return types, immutable params, no closures — functions are plain, predictable declarations.

#060

Declaring Functions

Return type required, params immutable, no defaults — and pub controls visibility.

The return type is REQUIRED — use void when there is nothing to return. Parameters are immutable bindings, and there are no default or named arguments.

zig

/// Adds two integers.
pub fn add(a: i32, b: i32) i32 {
    return a + b;
}

pub fn logHello(name: []const u8) void {  // void: no return value
    std.debug.print("hello {s}\n", .{name});
    // params are const: assigning to name is a compile error
}

pub exposes a decl to @importers of this file — private otherwise
parameters are const; to change one, copy into a local first
/// doc comments attach to decls and appear in autodoc
no overloading — use distinct names or comptime dispatch

#061

Multiple Return Values

No multi-return sugar — return a struct/tuple, an optional, an error union, or use out-params.

Zig has no multi-value return sugar — pick a shape: !T for failure, ?T for absence, a struct or anonymous tuple for several values, *T out-params for mutation.

zig

fn divMod(a: u32, b: u32) struct { q: u32, r: u32 } {
    return .{ .q = a / b, .r = a % b };
}

const .{ .q = q, .r = r } = divMod(17, 5);   // 3 and 2 (0.14+)
std.debug.print("{d} {d}\n", .{ q, r });

// alternatives: ?T (absent), E!T (failure), *T (out-param)
fn indexOf(s: []const u8, c: u8) ?usize {
    for (s, 0..) |ch, i| if (ch == c) return i;
    return null;
}

tuple return type: struct { u32, u32 } — anonymous, destructured by position
destructuring since 0.14: const .{ .q = q, .r = r } = ...;
_ discards a destructured slot you don't need

#062

Passing Arguments

Pass-by-value with compiler-optimized lowering — pointers only for mutation or sharing.

Arguments pass by value; the compiler picks the cheap lowering, so don't contort signatures over sizes. Reach for pointers when you must mutate the caller's data or share it — and remember params are immutable, so *T is the only way to write back.

zig

fn byValue(p: Point) Point {         // copy — fine for small data
    return .{ .x = p.x * 2, .y = p.y * 2 };
}

fn scale(p: *Point, f: f32) void {   // mutate the caller's value
    p.x *= f;
    p.y *= f;
}

fn total(items: []const u32) u32 {   // read-only view, any length
    var sum: u32 = 0;
    for (items) |v| sum += v;
    return sum;
}

Situation	Signature
read-only, small data	pass `T` by value
read-only, big data	`[]const T` or `*const T`
mutate caller's data	`*T`
accept an array	param `[]const T` — `[N]T` coerces
optional argument	`?T` explicitly (no default args)

#063

export, extern & callconv

export publishes C-visible symbols, extern declares them, callconv pins the ABI.

The calling convention decides the ABI. export/extern bridge Zig to C and the linker; inline is a codegen hint that forces call-site expansion.

zig

export fn zig_callback(x: i32) i32 {   // C-visible symbol
    return x * 2;
}

extern "c" fn printf(fmt: [*:0]const u8, ...) c_int; // C variadic

fn cStyle(x: u32) callconv(.c) u32 {   // explicit C ABI (0.14+)
    return x + 1;
}

inline fn square(x: i32) i32 {         // body copied into callsites
    return x * x;
}

export fn f() emits the symbol for C/linkers; extern declares one defined elsewhere
extern "c" names the library; variadic ... requires the C calling convention
callconv(.c) on a normal fn pins the C ABI (lowercase since 0.14)
callconv(.naked) for asm-only stubs — no prologue or epilogue
inline fn forces inlining at each call site

#064

Function Pointers

*const fn (...) T types, &f spelling, no closures — context goes through a parameter.

A function pointer's type is *const fn (i32, i32) i32. Take a function's address with &f — the safest spelling — then call it like a function. There are no closures: pass captured state through an explicit context parameter.

zig

fn add(a: i32, b: i32) i32 { return a + b; }
fn sub(a: i32, b: i32) i32 { return a - b; }

const Op = *const fn (i32, i32) i32;

fn apply(f: Op, a: i32, b: i32) i32 {
    return f(a, b);
}

const f: Op = &add;                    // &fn is the canonical spelling
std.debug.print("{d} {d}\n", .{ apply(f, 3, 4), apply(&sub, 3, 4) });

used for callbacks, interrupt vectors, and hand-rolled vtables (see comptime & Generics for the zero-cost alternative)
capture state C-style: fn cb(ctx: *anyopaque, x: u32) void with the context as the first parameter
comptime fn parameters specialize per function: fn wrap(comptime f: fn () void)

#065

Recursion

Runtime recursion just works (until the stack); comptime recursion needs an eval-branch budget.

Runtime recursion is plain stack recursion — nothing special, nothing detected. Comptime recursion is bounded by the eval branch quota, raised with @setEvalBranchQuota.

zig

fn fib(n: u32) u64 {                  // runtime: plain stack recursion
    return if (n < 2) n else fib(n - 1) + fib(n - 2);
}

fn Fib(comptime n: u32) u64 {         // comptime: quota-bounded
    return if (n < 2) n else Fib(n - 1) + Fib(n - 2);
}

comptime {
    @setEvalBranchQuota(1_000_000);   // default quota is only 1000
    _ = Fib(25);                      // evaluated during compilation
}

infinite runtime recursion dies with a stack overflow — not detected, no tail-call guarantee
recursive generic instantiation can explode compile times — memoize or flatten
@setEvalBranchQuota raises the comptime step budget for the current evaluation

Section 12 of 21: defer & Cleanup

4 entries · 12/21

Scope-exit cleanup: defer, errdefer, and the acquire/release discipline that replaces RAII.

#066

defer

Runs at the END OF SCOPE — the block, not the function — always, in LIFO order.

defer schedules a statement for the end of its enclosing block — not the function. Sibling defers run LIFO (last registered, first run) on every exit path: return, error return, break.

Mutex + heap example

fn demo(gpa: Allocator) !void {
    const data = try gpa.alloc(u8, 128);
    defer gpa.free(data);           // paired right at acquisition

    lock.lock();
    defer lock.unlock();            // LIFO: runs BEFORE free

    // ... work — early returns, errors, breaks: all safe
}

Defers do not run on panic or abort — the process dies on the spot. One more reason panics are for bugs and errors are for expectations.

#067

errdefer

Same LIFO machinery, but only on the failure path — combine for commit/rollback.

errdefer fires only when an error return passes through its scope — never on success. The classic combo: errdefer rollback right after acquiring, commit as the last step. Two lines make a transaction.

zig

const conn = try connect(gpa);
errdefer conn.close();          // only on error return
try conn.handshake();           // bail? -> closed for you

try tx.begin();
errdefer tx.rollback();         // failure path
try tx.write(records);
tx.commit();                    // success path — keep it last

Exit path	`defer`	`errdefer`
success `return`	runs	skipped
error `return` / failed `try`	runs	runs
leave the scope via `break`	runs	skipped
panic / abort	skipped	skipped

#068

Scope Rules & Gotchas

defer is block-scoped: in a loop body it fires every iteration — or holds resources the whole loop.

defer binds to the nearest enclosing block. In a loop body that is one iteration; inside an if block, that block; at function top, the function.

zig

fn scan(gpa: Allocator, paths: []const []const u8) !void {
    for (paths) |path| {
        const f = try open(path);            // acquire per iteration
        defer f.close();                     // released per iteration

        const buf = try gpa.alloc(u8, 1024); // also per iteration
        defer gpa.free(buf);                 // LIFO in this body:
        try process(f, buf);                 // free buf, then close f
    }
}

defer reads variables at RUN time, not at registration — defer log(i) sees i as it is when the scope exits
want the value as it was at defer-time? snapshot first: const j = i; defer use(j);
leaving the scope via break still runs defers — only panic/abort skips them

A defer outside a loop body holds the resource for the whole loop. If each iteration should own the resource, move the acquire/defer pair into the body.

#069

Common Cleanup Table

acquire → defer release, immediately, before any try in between.

The discipline that makes defer work: every acquire is IMMEDIATELY followed by its release deferral — before any try, return, or second acquire can slip between them.

Acquire	Release	Notes
`gpa.alloc(u8, n)`	`gpa.free(mem)`	same allocator, same scope
open a file	`f.close()`	whatever opened it closes it
`lock.lock()`	`lock.unlock()`	`std.Thread.Mutex`
acquire a refcount	release it	balance every +1 with a -1
`tx.begin()`	`tx.commit()`	`errdefer tx.rollback()`
suspend	resume	keep the pair visually adjacent

zig

const mem = try gpa.alloc(u8, size);
defer gpa.free(mem);             // <- no try between these two lines

const out = try dest.begin();    // next resource
defer out.finish();              // paired before any risk

Section 13 of 21: comptime & Generics

7 entries · 13/21

Run arbitrary code at compile time — generics are just functions on type, with no macro preprocessor in sight.

#070

comptime Fundamentals

comptime marks code the compiler executes at build time — params, vars, and blocks.

comptime marks code the compiler runs at build time: parameters, variables, whole blocks. All generics, type values, and default values are comptime — this one mechanism replaces C macros, templates, and pre-build codegen.

zig

fn repeat(comptime n: u32, msg: []const u8) void {
    comptime var i: u32 = 0;              // comptime variable
    inline while (i < n) : (i += 1) {     // unrolled at compile time
        std.debug.print("{s} ", .{msg});
    }
}

const big = 1_000_000_000_000;   // comptime_int: unbounded, exact
const small: u8 = 200;           // coerced to u8 at compile time

comptime_int / comptime_float: unbounded, exact literal types — they coerce into concrete types on use
if (comptime cond) evaluates now and prunes the untaken branch from the binary
a comptime parameter creates a distinct instantiation per value

#071

Generic Functions

type is a comptime value — take it as a parameter and the fn gets monomorphized per call.

A type parameter makes the function generic — T is just a comptime value. Every distinct T produces a fresh monomorphized copy of the body; there is no runtime polymorphism involved.

zig

fn max(comptime T: type, a: T, b: T) T {
    return if (a > b) a else b;
}

const a = max(i32, 3, 9);        // explicit type argument
const b = max(u8, 1, 2);         // each T = a fresh instantiation

fn sum(items: anytype) i64 {     // anytype: inferred param type
    var total: i64 = 0;
    for (items) |x| total += x;
    return total;
}

anytype: infer the parameter type from the call site
@hasDecl(T, "name") / @hasField(T, "name") — duck-type checks on capabilities
constraints are implicit — misuse fails where used; add @compileError for clear messages

#072

Generic Types (type-returning fns)

A function returning type is a generic type; @This() names the struct from inside.

Generic types are functions that return type. The struct declared inside is a fresh type for every T; identical arguments always yield the identical type.

Canonical generic container

fn List(comptime T: type) type {
    return struct {
        items: []T,
        len: usize = 0,

        const Self = @This();    // name this struct from inside

        fn push(self: *Self, item: T) void {
            self.items[self.len] = item;
            self.len += 1;
        }
    };
}

const IntList = List(i32);       // fresh type, monomorphized

@This() — the innermost type's own name, for Self-style aliases and methods
methods close over the generic parameter — no extra plumbing
instantiate like any decl: const IntList = List(i32);

#073

inline for / inline while

Unroll loops at comptime — one stamped-out copy per iteration.

inline for / inline while force unrolling: the body is stamped out once per iteration at compile time. Required whenever each iteration must generate distinct code from comptime values.

zig

const Point = struct { x: u32 = 0, y: u32 = 0 };

fn zeroAll(p: *Point) void {
    inline for (@typeInfo(Point).@"struct".fields) |field| {
        @field(p, field.name) = 0;    // x, then y — unrolled
    }
}

field.name is a comptime string, and @field(obj, name) needs a comptime-known name — a runtime loop can't supply either
plain loops stay runtime loops when nothing per-iteration is comptime — inline loops bloat binaries
inline while unrolls the same way

#074

Type-Creating Builtins (0.16)

since 0.16ziglings 064–075, 084

@Type is gone in 0.16 — construct types with focused builtins instead.

@Type was removed in 0.16 — constructing types now goes through focused builtins, one per kind. Reach for them only when the type cannot be spelled directly.

Builtin	Builds	Sketch
`@Int`	integer type	`@Int(signedness, bits)`
`@Float`	float type	`@Float(bits)`
`@Pointer`	pointer type	size / child / alignment args
`@Array`	array type	`@Array(len, child)`
`@Vector`	SIMD vector	`@Vector(len, child)`
`@Tuple`	tuple type	`@Tuple(&.{ u8, u16 })`
`@Struct`	struct type	fields arg — see docs
`@Union`	union type	see docs
`@Enum`	enum type	see docs
`@Opaque`	opaque type	see docs
`@Optional`	optional type	`@Optional(u32)` → `?u32`
`@ErrorUnion`	error union	set + payload args
`@ErrorSet`	error set	names arg — see docs
`@Fn`	function type	see docs
`@EnumLiteral`	enum literal type	the type of `.tag`

These shipped with @Type's removal in 0.16 and signatures are still settling — check the std docs for your exact version. For most code, spelling types directly (?u32, [4]u8, *T) beats constructing them.

#075

Metaprogramming Toolkit