compile-time-regular-expressions

Other examples are CTRE (https://github.com/hanickadot/compile-time-regular-expressio...) and format string compilation (https://fmt.dev/12.0/api/#compile-api). The closest C counterpart is re2c which also requires external tooling.

The problem can occur in general if there is a greedy match within the regex: https://github.com/hanickadot/compile-time-regular-expressio... Although it looks like that this got fixed for simple patterns.

Hana Dusikova did this in C++ several years ago, with her CTRE library. https://github.com/hanickadot/compile-time-regular-expressio... Of course, it has all the usual tradeoffs of compile-time template programming.

entirely. Good alternatives are CTRE (https://github.com/hanickadot/compile-time-regular-expressio...) which parses the regex and instantiates the automaton entirely at compile-time, or Google's re2 (https://github.com/google/re2) if you need to generate regular expressions at run-time. Even boost.regex on which std::regex is originally based, performs better because they can afford to break ABI.

I don't want to start a language war, given that I like both languages anyway, you should have a look at https://github.com/hanickadot/compile-time-regular-expressio... However even counting with upcoming C++23 features, Lisp is much more ergonomic for this kind of stuff.

I agree with your list. However, I don't find the first library you referenced readable (i.e. https://github.com/hanickadot/compile-time-regular-expressio...), and I am a C++ user since the nineties.

Here are a couple of expertly-written C++17/C++20 repositories: https://github.com/hanickadot/compile-time-regular-expressio... https://github.com/nlohmann/json If you've not written C++ code before, it can take a while to catch up with the latest developments in C++23. Start with C, and learn these, in approximately the specified order: 1. lvalue references. 2. Constructors, destructors, and inheritance. 3. Annotations such as const and noexcept on members. 4. Simple type templates, and value templates. 5. constexpr, std::move, and rvalue references. 6. Type traits and std::enable_if. 7. Concepts. Once you learn the core language features, learning the various data structures/algorithms in `std` should just be a matter of looking them up in cppreference, and using them over and over again. Good luck.

One use case of something similar is generating a regular expression matcher at compile time for example. This is what the C++ library https://github.com/hanickadot/compile-time-regular-expressio... does. There are a lot of uses of compile-time code. One I have been interested in is generating bindings to other languages or generating serialization code, or even generating bytecodes for VMs with specific bytecodes for accessing your native data structures (instead of adding a level of indirection).

> Passing strings into a templates ... wouldn't work in C++ ... https://www.youtube.com/watch?v=QM3W36COnE4 Here's an example of parsing regular expressions in C++ at compile time. Code here: https://github.com/hanickadot/compile-time-regular-expressio...

> I really don't get this argument. If you don't need pedal-to-the-metal performance then why are you using C++ in the first place? (Unless, of course, your answer is "legacy code".) There is many other things that pure compute-bound CPU performance that can drive you to a GC-less language like C++. Fine grain memory usage is one of them, latency control is an other. > `std::regex`'s performance is bad. , `std::unique_ptr` doesn't optimize as well as a plain pointers std::regex is not defendable, specially when there is much better implementation already available (https://github.com/hanickadot/compile-time-regular-expressio...) However, do you have any bench / source for std::unique_ptr ? You are the first one I hear giving critics on it. > Do you, though? Rust already replaced their standard hash map implementation with a completely dif

constexpr evaluation results are needed in the frontend long before LLVM IR ever comes into the picture. Also, people have done interesting things in constexpr that currently suffer from slow compile times: https://github.com/hanickadot/compile-time-regular-expressio...

C++ now has constexpr, so that pro is now shared by both C++ and D, somewhat (ignoring templates, D is still more versatile). That being said, C++ template metaprogramming can be pretty elegant[1] (there was a video where she describes the template functional style, but it seems to have been deleted). [1]: https://github.com/hanickadot/compile-time-regular-expressio...