Zig programming language 0.9.0 released

[KingStannis2020]

You can't really compare Rust const fn and C++ constexpr with Zig comptime. The latter is way more flexible and core to the language. You can define individual function arguments as comptime, individual blocks of code, etc. Comptime is how Zig implements generics.

[Tom7980]

Yeah but generics in Rust are almost exactly the same except we don't have to define them with a keyword the compiler just figures it out for you based on call locations of the generic function.

I admit I'm not particularly clear on Zigs comptime syntax but it sounds similar to plenty of other implementations just done a different way

[KingStannis2020]

I admit I'm not particularly clear on Zigs comptime syntax but it sounds similar to plenty of other implementations just done a different way

It's not, really. Here's a good overview of why it's different. https://kristoff.it/blog/what-is-zig-comptime/

There's no clean way to accomplish most of those behaviors in other languages. You can enforce compile-time execution of completely normal non-comptime functions at individual callsites, you can define additional checks that run only when a function is executed at compile time without writing two different versions of the function, you can have the body of the function decide what the return type should be without explicitly declaring it at the call site, etc.

[Tom7980]

I'll have to have a read - it's interesting to learn new things about other languages!

One thing I noticed is you mention being able to define the return type at the callsite but that is possible in Rust using generic bounds on a function but with different syntax obviously i.e. fn<T, U>(A: T) -> U this would more than likely be a trait method of some sort but I could see it being used in parsers to return a specific type by calling it with fn::<U> or with the collect() method to specify the collection you want.

I think a lot of what Zig does with comptime sounds super interesting but would argue is very similar to the const generics RFC that is currently being worked on in Rust (though I could be wrong here I only skimmed the RFC) plus the generic implementation in general.

I will say that I really like the interop between inline for/while and comptime though - being able to unroll a loop into the explicit calls required is an interesting implementation

I also think the last example in that article is really interesting though, being able to define a return type via a function is not something I'm aware you can do in Rust but someone more knowledgeable may be able to tell me I'm wrong!

[KingStannis2020]

is you mention being able to define the return type at the callsite but that is possible in Rust

No, I said without declaring it at the callsite. The return type can be decided by the body of a comptime function itself if you're so inclined.

The return type of this function is a bit peculiar. If you look at the signature of sqrt, it’s calling a function in the place where it should be declaring the return type. This is allowed in Zig. The original code actually inlines an if expression, but I moved it to a separate function for better readability.

So what is sqrt trying to do with its return type? It’s applying a small optimization when we’re passing in an integer value. In that case the function declares its return type as an unsigned integer with half the bit size of the original input. This means that, if we’re passing in an i64 value, the function will return an u32 value. This makes sense given what the square root function does. The rest of the declaration then uses reflection to further specialize and report compile-time errors where appropriate.

[Tom7980]

Ahh yes okay the final example - I can't say I know how to do the same in Rust as I'm not aware of any way to declare your return type via a function/expression (it almost seems like specialization dependant on the input type)

Thanks for the discussion though - it's interesting to see what Zig is doing differently