r/Zig

Andrew on readonly or private struct members

https://github.com/ziglang/zig/issues/2479

> This is one of those things where zig is going to not provide a language feature that, admittedly, could be useful, but ultimately is unnecessary to accomplish zig's goals.

I guess the goal of zig is to alienate fans of the language that write programs with complex state machines.

I’m writing this post solely to express my frustration.

Zig is basically solving every crappy thing about C++ with its amazing comptime, build system, very nice syntax, error handling, etc … that won me over easily after reading the (entire) documentation.

Several of its design decisions are IMHO is better than rust.

That said, the idealistic design decision to not have private members boggles the mind !

Any serious real world application that isn’t a small app or utility will have an internal state that is strictly accessed by core functionality which must be allowed to make assumptions about said state. Allowing a (possibly dumb) user to manipulate the state means one of the following:

1. Add a huge amount of avoidable validation and internal error reporting (a broken state is rarely recoverable)

2. Having to educate the user with naming, comments, meetings and 100s of closed get-good tickets to keep repeating STOP TOUCHING MY PRIVATE DATA

Finally, given that “good naming” and comments should do the trick. It begs the question, why this aspect of safe coding (on both the supplier and user side) didn’t get the safe-explicit-by-design no-footgun treatment.

Every deficit in C that zig is trying to fix can also be fixed in C with better naming and comments. What’s the point of zig then ?

The decision is arbitrary.

And for someone who has been using C++ for so long and desperately desires a performant, simple, powerful-meta-programming, reflective programming language. I find myself reading the release notes of every zig release and checking up on the subreddit regularly to hopefully see this “everything-public” anti-pattern revoked or sidestepped nicely.

There I said my peace.

I know I’m not the only one and this is not the first time this is discussed, but something really should move here.

Hello folks,

I am trying to work with the Io interface. I'm trying to use it as described in this post: https://pedropark99.github.io/zig-book/Chapters/12-file-op.html.

Nonetheless, the compiler seems unable to find the Threaded namespace. I'm not sure what the error could be.

The Zig version I am using is 0.15.2.

Many thanks in advance!

Hi there, sorry if this is not the correct place to ask, but with Stack Overflow kinda dead I really don't know where else to put this question.

A bit of context: I'm currently working on a library to simplify Zig-Lua interop. For that I created a marker strategy to represent the metadata of Zig structs, unions and enums that defines metatables and encoding/decoding strategies.

The problem is that it is fragile in the sense that forgetting pub on ZUA_META, or misspelling it, causes the encode/decode paths to fall back to the default strategy. That is intentional since the core idea is to allow interop with as little ceremony as possible, so small DTOs should not need any annotation. But the silent fallback causes two kinds of errors: types with non-table strategies get encoded and decoded as plain tables (the minor problem), and methods never get attached to the metatable (the major one, since Lua ends up calling nil and the error message gives no hint about what went wrong on the Zig side).

To catch this I added a comptime guard inside the metadata type constructor so that a misspelled or private ZUA_META would produce a @ compileError. It does not fire. After debugging with @ compileLog I confirmed the cause is that Zig lazily evaluates generic type instantiations, so the check never runs if the result is never actually used. I can confirm this by forcing evaluation manually:

const Vector2 = struct {
    const ZUA_META = zua.Meta.Table(Vector2, .{ .length = length });

    x: f64,
    y: f64,

    pub fn length(self: Vector2) f64 {
        _ = ZUA_META; // force evaluation
        return std.math.sqrt(self.x * self.x + self.y * self.y);
    }
};

_ = (Vector2{ .x = 0, .y = 0 }).length(); // only now the compileError fires

Is there any mechanism in Zig to force eager evaluation of a comptime block, or to guarantee a generic type instantiation is always evaluated even when its result is not directly used? I cannot require explicit registration calls because that would break the zero-ceremony DTO use case. I also cannot use a struct field with a default value because the marker needs to work for enums and unions too, not just structs.

btw here is the commit where I implemented the check that is not working: https://github.com/SolracHQ/zua/commit/ea6f4f083e795874c98d4a1ae55ca4236715fa8e

btw 2, it is a bit ironic that Zig is extremely strict about unused variables everywhere else but silently skips evaluation of unused type declarations with no warning at all. Even a warning would have saved me a lot of debugging time.

Thanks for any help.

Hi everyone!

Zignal 0.10.0 is out. compilable with Zig 0.16.0.

There are the usual performance improvements and bug fixes, but the main highlight is a simple CLI tool to perform various image operations via the terminal.

You can get an idea of what it can do with:

Usage: zignal [options] <command> [command-options]

Global Options:
--log-level <level>   Set the logging level (err, warn, info, debug)

Commands:
blur     Apply various blur effects to images.
diff     Compute the visual difference between two images.
display  Display an image in the terminal using supported graphics protocols.
edges    Perform edge detection on an image using Sobel, Canny, or Shen-Castan algorithms.
fdm      Apply Feature Distribution Matching (style transfer) from target to source image.
info     Display detailed information about one or more image files.
metrics  Compute quality metrics (PSNR, SSIM, Mean Error) between a reference and target images.
resize   Resize an image using various interpolation methods.
tile     Combine multiple images into a single tiled image.
version  Display version information.
help     Display this help message

Run 'zignal help <command>' for more information on a specific command.

For example:

zignal help display

Usage: zignal display <image> [options]
Display an image in the terminal using supported graphics protocols.

Options:
--width <N>     Target width in pixels
--height <N>    Target height in pixels
--protocol <p>  Force protocol: kitty, sixel, sgr, braille, auto

Full release notes here:

https://github.com/arrufat/zignal/releases/tag/0.10.0