ctl VS stc

C Container Template Library (CTL)

I guess something like that may exist but it can be done with the preprocessor alone. See https://github.com/tylov/STC or https://github.com/glouw/ctl

I assume you refer to that two of the letters match with STL or STD, right? Even if they are not related to C at all. I assume STB, CTL, are not acceptable for you either?

The standard C library lacks any kind of containers (vectors, hash tables etc.) so the first thing would be to find one you like. For example, the C Template Library is a nice one: https://github.com/glouw/ctl

While I agree the common pattern is to use void*/dynamic dispatch, this is not necessary. E.g., https://github.com/glouw/ctl/ or https://github.com/c-blake/bst show a couple ways to have generic code statically specialized in regular old C.

The template instantiation is rewritten and is now similar to how glouw CTL library does it. STC no longer contains long macros for generating the templated code.

define type macros before #including the implementation. (intrusive) This is how https://github.com/glouw/ctl does it. The good: type-safety. no casting, clear error messages. Somewhat clumsy to have to individual #includes for each container type instantiation of the same container.

Wonder no more: https://github.com/dudykr/stc

Written in Rust by the (lead?) dev of SWC

SWC (speedy web compiler) compiles TS to JS

The analogy (by swc's author) would be https://github.com/dudykr/stc

I'm also hoping for STC https://stc.dudy.dev/ but I don't think it will be released any time soon.

MyPy and tsc on the other hand? Please make a Ruff for MyPy and hurry up and fund the author of SWC to develop STC. I'm tired of waiting several seconds after each :w for my quickcheck window to update.

>If we could push JavaScript performance to be another order of magnitude faster

And it would speed up the TypeScript Compiler.

My bet is:

TypeScript typechecker in Rust:

https://github.com/dudykr/stc

typescript(tsc) is the only one that does type checking.

bun, deno, esbuild, swc etc. can parse the syntax, but they chuck the TS (they probably don't even add it to the AST, but I haven't checked).

Keeping up with syntax is very doable. It doesn't change often, and updating the parser when it does isn't much work.

There are some past/ongoing projects[1][2] to create type checkers faster than tsc, but they aren't going to reach full parity and probably don't plan on keeping up with language features.

[1] https://github.com/dudykr/stc

Well the checker is in progress.