It feels more lightweight and consistent, and collisions aren’t super common once you adopt some conventions.

It’s a tradeoff for sure, but this preference comes from having lived in both worlds.

The identifier on the right is looked up in the scope of the identifier on the left. If it resolves to a module, then it's a module. If it resolves to a function, then it's a function. If the left side is a pointer (not a symbol with a scope) then the right side resolves to a member.

It also makes refactoring much easier - changing a pointer to a reference does not require a global search/replace of -> with .

> Focus on debugging your application rather than debugging your programming language knowledge.

Clearly, you think the language fails at this criteria (your subjective opinion). Please be honest and say that, rather than implying that it's not explicitly one of the core design principles of the language (objectively false).

A more concrete example that might explain it better is looking at Advent of Code solutions.

One thing that struck me was that doing typical tasks for parsing would be 2-3 functions stringed together in a smart way in the Zig solutions, whereas in Odin and C3 it was achieved by having a single standard library function that did these steps.

From what I understand, there is a pushback against creating convenience functions in the Zig standard library, if the same thing can be achieved by stacking together a few functions.

My understanding is that doing these smart things with the Zig library with the existing functionality of considered a cool way to leverage existing code.

In C3, and I feel Odin as well, the lack of such a convenience function would be considered an omission to patch, and that having to stack things together should be reserved for specialized solutions, rather than having to stack things together for everyday tasks.

Thus in C3 and Odin, it is okay to trade detailed explicitness for convenience, whereas this is a no-no in Zig.

But what this means is that Zig users tend to celebrate and focus on smart and clever code, whereas this is a complete non-goal in C3 and Odin.

I could probably have formulated this better before.

This is very much not productive and you’re now part of spreding this narrative. There’s plenty of people out there who has «figured out» and appreciate both Zig and Rust without becoming attached to it.

I’m interested in communities which looks towards other languages for inspiration and admiration, not judgements and alienation.

``` int[<3>] a = { 11, 22, 33 }; int[<4>] b = a.xxzx; ```

I assume that the `xxzx` is translated directly by the compiler. not seen that in any other language though ruby can fake it pretty easily via `method_missing`

For ex. parens-less calls (myfunc 42 "hello") are elegant but don't stand out and - for me - take more time to identify.

Also `fun foo(i:int)` is easier on the parser than C-style `void foo(int i)`

    #if defined(__SunOS)
        presult = getprotobyname_r(proto,&result,tmp,sizeof(tmp));
        if (presult == NULL)
          return luaL_error(L,"protocol: %s",strerror(errno));
    #elif defined(__linux__)
        if (getprotobyname_r(proto,&result,tmp,sizeof(tmp),&presult) != 0)
          return luaL_error(L,"protocol: %s",strerror(errno));
    #else
        presult = getprotobyname(proto);
        if (presult == NULL)
          return luaL_error(L,"protocol: %s",strerror(errno));
        result = *presult;
    #endif

C2 is over 11 years now. C3’s recent breakthrough this last half year is unlikely to have had much impact on its ability to grow the last 10 years.