Language: Zig · Versions: Zig 0.13.0
The problem
I'm building a lookup table at comptime inside a function using a comptime var buffer and returning a slice []const u8. In Zig 0.13, returning a slice pointing to a comptime var array fails to compile (compile error: runtime value contains reference to comptime var) unless the comptime var is first copied into a const fixed-size array (const final = buf; return &final;) so Zig promotes it to static read-only data!
Minimal example
const std = @import("std");
fn buildTable(comptime n: usize) []const u8 {
comptime {
var buf: [n]u8 = undefined;
for (0..n) |i| {
buf[i] = @intCast(i * 2);
}
// Fails in Zig 0.13: `runtime value contains reference to comptime var`
return &buf;
}
}
pub fn main() void {
const tbl = buildTable(4);
std.debug.print("{any}\n", .{tbl});
}
Expected
buildTable(4) returns a static []const u8 slice { 0, 2, 4, 6 } usable at runtime with zero runtime initialization cost.
What happens instead
Zig rejects return &buf; with error: runtime value contains reference to comptime var because buf is mutable at comptime, so taking its address yields a pointer to mutable comptime memory rather than an immutable static constant.
What is the cleanest idiom in Zig 0.13 to freeze a variable-length comptime-computed slice (whose length itself is only discovered during the comptime computation, not passed as comptime n: usize) into a runtime []const T?
The const final = buf; return &final; idiom you found is the right one. For a length that's only discovered during the comptime computation, copy the used prefix into a const array whose length is a comptime-known value, then return a pointer to that.
const std = @import("std");
fn buildTable() []const u8 {
comptime {
var buf: [256]u8 = undefined; // upper bound
var len: usize = 0;
var i: usize = 0;
while (i < 100) : (i += 1) {
if (i % 3 == 0) { // any comptime-only rule
buf[len] = @intCast(i);
len += 1;
}
}
// `len` is comptime-known here, so this slice has a comptime length
// and `.*` copies exactly `len` bytes into an immutable value.
const final: [len]u8 = buf[0..len].*;
return &final;
}
}
pub fn main() void {
const tbl = buildTable();
std.debug.print("{any}\n", .{tbl});
}
Why it works. &buf points at memory that is still a mutable comptime var. The compiler can't turn that into static read-only data, so it rejects it with the error you quoted. A const copy is a plain comptime-known value, so its address can be promoted to static rodata. Because final is [len]u8 and not the full 256-byte buffer, the binary contains only the bytes you need.
Alternatives
- return final[0..len] from a copy of the whole buf: this also compiles, but the full upper-bound array is embedded in the binary. It's fine for small tables.
- Two passes: const len = comptime count();, then var buf: [len]u8 = undefined;, fill it, const final = buf; return &final;. This is a good fit when counting is cheap and you don't want a magic upper bound.
What I checked. The const final = buf; return &final; pattern is the same one the standard library uses for comptime-built strings, for example in std.fmt.comptimePrint. I haven't compiled the snippet above under 0.13.0, and I'm reasoning from the language semantics. If buf[0..len].* is rejected in your build, fall back to the two-pass form. Also, @intCast into u8 is a comptime error if a value exceeds 255, so keep the table values in range.