You're forced to emulate exactness by always destructuring objects - not great.

It’s almost like using objects as enumerable maps is an anti-pattern.

The problem has nothing to do with objects. The problem is, how do you type check something like sprintf without ad hoc type rules?

Typescript can check sprintf though using template string types: https://www.hacklewayne.com/a-truly-strongly-typed-printf-in...

Meanwhile, both Rust [1] and Haskell [2] manage to implement statically type-safe string interpolation.

[1]: https://willcrichton.net/notes/type-safe-printf/

[2]: https://hackage.haskell.org/package/formatting

Yes but the Rust example is an ad hoc type rule implemented behind the macro. You can make it type-safe but you lose the ability to have a formatting language in the string itself.

Rust has explicit support for it in the compiler, which is not great.

Zig does it the right way - it's defined in zig itself, no special cases in compiler like in Rust.

I don’t think I’m following well enough to provide a meaningful response.

This is not meant as an argument against what you’re saying, because I know you were just giving an example, but I found this and thought you may find it interesting: https://www.hacklewayne.com/a-truly-strongly-typed-printf-in...

To extend on it a bit, flow has really good story with:

1. nominal types for classes (with correct variance/liskov substitution principles)

2. structural types for the rest

3. explicit annotation for exact structural types

This setup is brilliant.