test "if branch hints" {
    var t: bool = undefined;
    t = true;
    if (t) {
        @branchHint(.likely);
    } else {
        @branchHint(.cold);
    }
}

test "orelse branch hints" {
    var x: ?u32 = undefined;
    x = 123;
    const val = x orelse val: {
        @branchHint(.cold);
        break :val 456;
    };
    try expect(val == 123);
}

const Enum = enum {
    a,

    const a = 0;
};

const Struct = {
    func: *const fn() void,

    fn func(_: Struct) void {}
};

comptime {
    _ = Enum.a; // выберется "const a = 0;"
    // чтобы получить именно тег, можно вот так:
    _ = @as(Enum, .a);

    _ = Struct.func; // только метод понятное дело, нельзя поля так получать
    var instance: Struct = .{ .func = undefined };
    _ = instance.func(); // выберется "func: *const fn() void"
    // чтобы получить именно метод, можно вот так:
    _ = Struct.func(instance);
}

const S = struct {
    x: u32,
    y: u32,
    fn init(val: u32) S {
        return .{ .x = val + 1, .y = val + 2 };
    }
};
test "call decl literal" {
    const a: S = .init(100);
    try std.testing.expectEqual(101, a.val.x);
    try std.testing.expectEqual(102, a.val.y);
}
const std = @import("std");

const value = package.SomeType.init(4);

const value: package.SomeType = .init(4);

std.debug.print(chroma.format("{blue}Eventually, the {red}formatting{reset} looks like {130;43;122}{s} !\n"), .{"this"});

{
    float sum = 0;
    for (i=0; i < result->w; ++i) {
      float k;
      int m;
      sum += scanline2[i];
      k = scanline[i] + sum;
      k = (float) STBTT_fabs(k)*255 + 0.5f;
      m = (int) k;
      if (m > 255) m = 255;
      result->pixels[j*result->stride + i] = (unsigned char) m;
    }
}

{
    var sum: f32 = 0;
    for (scanline, scanline2, result.pixels[j*result.stride..][0..result.w]) |s, s2, *p| {
        sum += s2;
        p.* = @min(@abs(s + sum)*255 + 0.5, 255);
    }
}