Hacker News new | past | comments | ask | show | jobs | submit
stephc_int13 | on: Zig by Example
Encapsulating arguments inside .{} seems superfluous and noisy.

I'm sure this can be rationalized in some way, to either simplify parsing or solve some rare ambiguity, but I just don't see it.

I know this is a minor thing and can be considered as nitpicky, and I expect some friction with syntax when learning a new language, but I just can't stand things I see as gratuitous. Same with the forced use of _ = foo(.{}); to avoid compiling errors...

brodo | parent | next
In Zig, function arguments are not wrapped in `.{}`. `.{}` is the syntax for creating a struct or a tuple. This is used as a pattern for allowing optional arguments (options struct) and variadic functions (tuple).

Explicitly discarding return values is a thing many modern programming languages force you to do.

loading story #48446684
dnautics | parent | next
> Encapsulating arguments inside .{} seems superfluous and noisy.

You don't do this? This is only for varargs or optionals.

.{<stuff>} is just a shorthand for Type{<stuff>} (struct constructor) plus, "hey compiler, you figure out the type". So if anything it's LESS noisy than the alternative, and more forward-compatible if you change a type name for example.

hiccuphippo | parent
I see it this way, the full signature for defining a variable is:

    var foo: Foo = Foo{};
There's two ways to shorten it:

    var foo = Foo{};
    var foo: Foo = .{};
It can infer the type of the var from the right hand side; or the type of the right side from the type of the var.

So when you see .{} as an argument, it is inferring the type from the function signature. It happens to be empty only because it's using default values (or is a tuple with 0 items).

Edit: fixed the extra dots.

loading story #48446769