4 ms·

My 2 cents: it's a bad idea because it's hard to test / debug. C++ template / overload resolution involves some very convoluted logic. And it can take some wo

My 2 cents: it's a bad idea because it's hard to test / debug. C++ template / overload resolution involves some very convoluted logic. And it can take some work to even notice if / how it went differently than a programmer expected. Programmers typically have logging, interactive debugging, etc. to investigate complicated algorithms like this. But (almost?) no C++ compiler provides such tooling for investigating the behavior of this algorithm. IMHO it's an area where C++ tooling could serious use improvement.

actionfromafar 3y ago
Yes! I never thought of it that way, but imagine having a real nice IDE with a "compilation debugger", showing all these things unfolding in real-time as you change a function.
nix0n 3y ago
This is why the C preprocessor is superior to templates: gcc's "-E" option will show you the preprocessed source file. (I think clang also?) My personal theory is that compiler authors have not provided a template equivalent, because they are embarrassed about the code that's being produced. (If you disagree, prove me wrong!)
- gpderetta 3y ago
  > prove me wrong Template don't "produce code". They get expanded well after parsing. There is no code to be embarrassed for. Also you can ask GCC to dump any intermediate state: https://gcc.gnu.org/onlinedocs/gcc/Developer-Options.html https://gcc.gnu.org/onlinedocs/gcc/Developer-Options.html.
  - nix0n 3y ago
    Is there a specific "-fdump" that you recommend?
- planede 3y ago
  cppinsights.io shows expanded function templates as explicit specializations. It's built on LLVM, but I don't think that this tool is upstreamed. https://cppinsights.io/lnk?code=dm9pZCBmb28oYXV0bykge30KCnZvaWQgYmFyKCkgeyBmb28oMCk7IH0=&insightsOptions=cpp23&std=cpp23&rev=1.0 https://cppinsights.io/lnk?code=dm9pZCBmb28oYXV0bykge30KCnZv...
  - nix0n 3y ago
    Thank you! This is exactly the sort of thing I was looking for. I found the source at https://github.com/andreasfertig/cppinsights https://github.com/andreasfertig/cppinsights
logicchains 3y ago
You have static_assert for testing/debugging. The lovely thing about compile-time programming is you don't even need a separate test stage; the compiler runs your tests (asserts) for you. Then if the code builds you know it's correct. This pattern is getting easier and easier in modern C++ as more and more thing are made constexpr.

actionfromafar 3y ago

Yes! I never thought of it that way, but imagine having a real nice IDE with a "compilation debugger", showing all these things unfolding in real-time as you change a function.

nix0n 3y ago

This is why the C preprocessor is superior to templates: gcc's "-E" option will show you the preprocessed source file. (I think clang also?) My personal theory is that compiler authors have not provided a template equivalent, because they are embarrassed about the code that's being produced. (If you disagree, prove me wrong!)

gpderetta 3y ago
> prove me wrong Template don't "produce code". They get expanded well after parsing. There is no code to be embarrassed for. Also you can ask GCC to dump any intermediate state: https://gcc.gnu.org/onlinedocs/gcc/Developer-Options.html https://gcc.gnu.org/onlinedocs/gcc/Developer-Options.html.
- nix0n 3y ago
  Is there a specific "-fdump" that you recommend?
planede 3y ago
cppinsights.io shows expanded function templates as explicit specializations. It's built on LLVM, but I don't think that this tool is upstreamed. https://cppinsights.io/lnk?code=dm9pZCBmb28oYXV0bykge30KCnZvaWQgYmFyKCkgeyBmb28oMCk7IH0=&insightsOptions=cpp23&std=cpp23&rev=1.0 https://cppinsights.io/lnk?code=dm9pZCBmb28oYXV0bykge30KCnZv...
- nix0n 3y ago
  Thank you! This is exactly the sort of thing I was looking for. I found the source at https://github.com/andreasfertig/cppinsights https://github.com/andreasfertig/cppinsights

logicchains 3y ago

You have static_assert for testing/debugging. The lovely thing about compile-time programming is you don't even need a separate test stage; the compiler runs your tests (asserts) for you. Then if the code builds you know it's correct. This pattern is getting easier and easier in modern C++ as more and more thing are made constexpr.