Just a thought: add a way to register transpiler or compiler.

[niyarlatotep]

Maybe we can simply add a way to register any type checker or transpiler like it implemented in node js (or similar) i mean --loader (transpiler loader). And just write js code with types, then in the beginning of "main" module import (run) this checker or transpiler and it will typecheck and/or transpile code on the fly. It doesn't resolve typing "forks" problem but does the type annotation? I'm not a big expert but in my view it may solve most of noted in proposal problems.

Pros:

• If we want to save original code (with types) we include complier/transpiler import in prod.
• If we want plain js without types we can pretranspile (and if needed minify) it for prod release version, but use integrated compiler for easy debug and bugs catching for dev version.
• We can provide integrated in our app compiler that will have real runtime checks (more size, less speed, but more safety maybe)
• We can use (theoretically) any language like ocaml, clojurescript etc
• Backward compatibility
• No need any syntax changes

Cons:

• Bigger code size if we save import in prod (but we still cat erase it)
• Complexity of implementation (not sure not an expert but probably)
• Potential security issues (probably)
• Others those I don't know

We can somehow use compilers (transpilers) compiled to wasm if we need speed it up, or we want to have compiler written in other languages like rust etc

[tocque]

Translated from Chinese by GPT

I don't want to discuss the feasibility of this idea. But I think it should be noted that this idea can be used to negate the majority of proposals that have already been passed. For example, most methods added to built-in objects can be polyfilled, and async/await is just syntactic sugar. So I think this idea is not in line with the consistent thinking of TC-39.

[niyarlatotep]

Yes I understand the idea but it slightly different. When we discuss about async/await syntactic sugar (for instance) we have two ways to implement it:

1. Polyfilling (many different design implementations)
2. Standardization and add to language (single design implementation)

But if we discuss about the language it has its own standards in their ecosystems for example features instead of async/away etc. So yes if we want to standardized type annotation way in JS my idea is not suitable it's rather another proposal. The question is more about another way for solving sounded problems and about does it really solve the problem does we realy have such problems? Don't we already have checkers that doing the same things and mature enough?

[azder]

@niyarlatotep FYI https://github.com/tc39/proposal-type-annotations/issues/176#issuecomment-1732690996 it is the same or similar idea and a little above in another comment https://github.com/tc39/proposal-type-annotations/issues/176#issuecomment-1732520344