On the author’s point of a “debug build” with runtime type checking, there is ts-runtime-checks [0], which looks to do something similar! I don’t have any experience with it however, just seen it looking at typescript-runtime-type-benchmarks [1]. There’s a few other similar things there too

[0] https://github.com/GoogleFeud/ts-runtime-checks

[1] https://github.com/moltar/typescript-runtime-type-benchmarks

Out of curiosity, how long is your experience with TypeScript? I feel like I have to ask.

>TypeScript does not modify this code when it compiles to JavaScript

TypeScript does not modify any code which is valid JavaScript. Your idea of adding some sort of "debug build" to TypeScript would never be performed by `tsc`, but perhaps by bundlers, etc.

You might want to look up libraries like zod, or even better, Effect: https://effect.website/

I don't come from TS, but this seems like a good intro to zig from that sort of perspective. There's a whole lot of paradigms to relearn when you switch to something like Zig and this kind of content is useful.

I'll nitpick with one complaint though...

    const values = std.AutoHashMap(Point, u32);
    defer values.deinit();
    try values.put(Point{ .x = 0, .y = 0 }, 1);
    //  ~~~~~~^~~~ error: expected 3 argument(s), found 2

> The mistake here isn't on that line, and it doesn't have to do with the number of arguments. Rather, it's that I forgot to call .init() on the hash map

Well...

    >>> class MyType():
    ...    def test(self, a, b): return a + b;
    ... 
    >>> x = MyType
    >>> x.test(1, 2)
    Traceback (most recent call last):
       File "<stdin>", line 1, in <module>
    TypeError: test() missing 1 required positional argument: 'b'

How else do you want unbound functions to behave when you haven't constructed an instance of the type yet? (And FWIW, zls in vscode correctly annotates values as having type `type` for me)

I'm surprised that the list of Zig quirks doesn't include aliasing and functions parameters: the compiler can pass your parameter by value or by reference as it wants so your function behaviour can change in case of aliasing..

An implementation defined behaviour worse than C, that's surprising..

Ada has the same issue, I wonder if Ada users can tell us if this pitfall is an issue or not in practice.

Another language that we can build type with its own language is Python. The problem is that there is no checker for that kind of type, however :)

If the type is `type`, and you're missing one argument, and the types of the arguments suggest you're missing the first argument, then that's an opportunity for a much more specific error message.

But before we even get to that stage, I would prefer that "." isn't the syntax for both types of call.

Yuck. The type itself should be a different type from instances of the type, and therefore that error should be "function not found".

For the first one, constructors should generally do required init, although there are circumstances where that's very hard. Hence the builder pattern.

Yes, the error is much clearer when you realize where the mistake is :)

There's an interesting point here, though: while comptime lets Zig unify function calls and generic type instantiation, this also creates the possibility of confusing the two and getting confusing error messages.