In my grad school days, a couple of decades ago, I had written a library for my own use to facilitate chaining of different kinds of numeric operations on data vectors and sequences. Essentially, for a very simple form of deforestation [0,1], equipped with intermediate buffers to facilitate SIMD.

GCC, surprisingly, was quite good at generating SIMD code from it and eliminating temporary data vectors. GCC was even quite good at explaining why it didn't emit SIMD that I wanted it to emit. Much to my surprise GCC was better in this regard than Clang. From what I had read about Clang at that time, it should have been the otherway round. The error messages were better too (wonders of competition).

I quite liked it. It was a loads of fun. I would however be wary of using it in anger.

The problem is, this sublanguage feels more like a dynamically typed language where errors would be thrown deep in the instantiation chain when it ultimately failed to instantiate.

There was no type-system to guide you ahead-of-time that what you are trying to do would eventually fail to instantiate.

The code got lost when Bitbucket stopped it's support for Mercurial. I still likely have it somewhere in my old files.

Later I wanted to rewrite this in D but never started (thrown out of my university because I graduated).

[0] https://en.wikipedia.org/wiki/Deforestation_(computer_scienc...

[1] https://en.wikipedia.org/wiki/Expression_templates

> This is not something you would use in production

Ages ago in C++98/03 era, cons based lists were the only way to do type lists or tuples, so solutions like these did see some production use (and yes, it did kill compile time).

Of course these days variadics have made these solutions obsolete.

This is very cool. I had a lot of fun doing C++ template meta programming two decades ago and the language got a lot more interesting. Just realize that you can waste a huge amount of time without anything doing remotely useful.

(And please don't use any of it in any professional context.)

While cool for those stuck in C++17, which are plenty given the C++ version of "can I use", C++26 should make many of these approaches more easily available.

However it is still a few years away to be widely deployed, and a few niceties have been postponed into C++29.

This shows you how fun, useful and fascinating C++ template meta programming can be but also the dark side as a perfect example of inscrutable code that can be a real pain when you run across this sort of thing in production code with no documentation.

That could be pretty cool, I wonder what it does for compile time though.

if this is a C++17 library why couldn't you use `constexpr` evaluation and not murder your compilation time?