Comptime & Reflection

const std = @import("std");

fn stdout() *std.Io.Writer {
    // Buffered stdout writer per Zig 0.15.2 (Writergate)
    // We keep the buffer static so it survives for main's duration.
    const g = struct {
        var buf: [1024]u8 = undefined;
        var w = std.fs.File.stdout().writer(&buf);
    };
    return &g.w.interface;
}

// Compute a tiny lookup table at compile time; print at runtime.
fn squaresTable(comptime N: usize) [N]u64 {
    var out: [N]u64 = undefined;
    comptime var i: usize = 0;
    inline while (i < N) : (i += 1) {
        out[i] = @as(u64, i) * @as(u64, i);
    }
    return out;
}

pub fn main() !void {
    const out = stdout();

    // Basic comptime evaluation
    const a = comptime 2 + 3; // evaluated at compile time
    try out.print("a (comptime 2+3) = {}\n", .{a});

    // @inComptime reports whether we are currently executing at compile-time
    const during_runtime = @inComptime();
    try out.print("@inComptime() during runtime: {}\n", .{during_runtime});

    // Generate a squares table at compile time
    const table = squaresTable(8);
    try out.print("squares[0..8): ", .{});
    var i: usize = 0;
    while (i < table.len) : (i += 1) {
        if (i != 0) try out.print(",", .{});
        try out.print("{}", .{table[i]});
    }
    try out.print("\n", .{});

    try out.flush();
}

const std = @import("std");

fn stdout() *std.Io.Writer {
    const g = struct {
        var buf: [2048]u8 = undefined;
        var w = std.fs.File.stdout().writer(&buf);
    };
    return &g.w.interface;
}

const Person = struct {
    id: u32,
    name: []const u8,
    active: bool = true,
};

pub fn main() !void {
    const out = stdout();

    // Reflect over Person using @TypeOf and @typeInfo
    const T = Person;
    try out.print("type name: {s}\n", .{@typeName(T)});

    const info = @typeInfo(T);
    switch (info) {
        .@"struct" => |s| {
            try out.print("fields: {d}\n", .{s.fields.len});
            inline for (s.fields, 0..) |f, idx| {
                try out.print("  {d}. {s}: {s}\n", .{ idx, f.name, @typeName(f.type) });
            }
        },
        else => try out.print("not a struct\n", .{}),
    }

    // Use reflection to initialize a default instance (here trivial)
    const p = Person{ .id = 42, .name = "Zig" };
    try out.print("example: id={} name={s} active={}\n", .{ p.id, p.name, p.active });

    try out.flush();
}

const std = @import("std");

fn stdout() *std.Io.Writer {
    const g = struct {
        var buf: [1024]u8 = undefined;
        var w = std.fs.File.stdout().writer(&buf);
    };
    return &g.w.interface;
}

// An inline function; the compiler is allowed to inline automatically too,
// but `inline` forces it (use sparingly—can increase code size).
inline fn mulAdd(a: u64, b: u64, c: u64) u64 {
    return a * b + c;
}

pub fn main() !void {
    const out = stdout();

    // inline for: unroll a small loop at compile time
    var acc: u64 = 0;
    inline for (.{ 1, 2, 3, 4 }) |v| {
        acc = mulAdd(acc, 2, v); // (((0*2+1)*2+2)*2+3)*2+4
    }
    try out.print("acc={}\n", .{acc});

    // demonstrate that `inline` is not magic; it's a trade-off
    // prefer profiling for hot paths before forcing inline.
    try out.flush();
}

const std = @import("std");

fn stdout() *std.Io.Writer {
    const g = struct {
        var buf: [1024]u8 = undefined;
        var w = std.fs.File.stdout().writer(&buf);
    };
    return &g.w.interface;
}

const WithStuff = struct {
    x: u32,
    pub const message: []const u8 = "compile-time constant";
    pub fn greet() []const u8 {
        return "hello";
    }
};

pub fn main() !void {
    const out = stdout();

    // Detect declarations and fields at comptime
    comptime {
        if (!@hasDecl(WithStuff, "greet")) {
            @compileError("missing greet decl");
        }
        if (!@hasField(WithStuff, "x")) {
            @compileError("missing field x");
        }
    }

    // @embedFile: include file contents in the binary at build time
    const embedded = @embedFile("hello.txt");

    try out.print("has greet: {}\n", .{@hasDecl(WithStuff, "greet")});
    try out.print("has field x: {}\n", .{@hasField(WithStuff, "x")});
    try out.print("message: {s}\n", .{WithStuff.message});
    try out.print("embedded:\n{s}", .{embedded});
    try out.flush();
}

const std = @import("std");

fn stdout() *std.Io.Writer {
    const g = struct {
        var buf: [2048]u8 = undefined;
        var w = std.fs.File.stdout().writer(&buf);
    };
    return &g.w.interface;
}

// A generic function that accepts any element type and sums a slice.
// We use reflection to print type info at runtime.
pub fn sum(comptime T: type, slice: []const T) T {
    var s: T = 0;
    var i: usize = 0;
    while (i < slice.len) : (i += 1) s += slice[i];
    return s;
}

pub fn describeAny(x: anytype) void {
    const T = @TypeOf(x);
    const out = stdout();
    out.print("value of type {s}: ", .{@typeName(T)}) catch {};
    // best-effort print
    out.print("{any}\n", .{x}) catch {};
}

pub fn main() !void {
    const out = stdout();

    // Explicit type parameter
    const a = [_]u32{ 1, 2, 3, 4 };
    const s1 = sum(u32, &a);
    try out.print("sum(u32,[1,2,3,4]) = {}\n", .{s1});

    // Inferred by helper that forwards T
    const b = [_]u64{ 10, 20 };
    const s2 = sum(u64, &b);
    try out.print("sum(u64,[10,20]) = {}\n", .{s2});

    // anytype descriptor
    describeAny(@as(u8, 42));
    describeAny("hello");

    try out.flush();
}