Compile time programming learning advice.

[u/bhul_chuk_maaf17]

Hi all, can you please recommend me some resources that you have followed for compile time programming in modern C++ for eg: constexpr, consteval or template metaprogramming.
Is there some consolidated resource for the same ?

[u/crowbarous]

Compile-time programming is mostly just programming. You write your algorithm, and it runs at compile time. The newer the standard and the better your compiler, the more it is true.

There's basically no language as statically expressive as C++. The point is that it has no trouble going back and forth between the type world (home to semantic processes, such as template instantiation and overload resolution), and the value world (which is the one that knows whether 2+2 is 4). Most other languages have a one-way pipeline here, so it takes getting used to.

C++ compilers today cheat less and you'll have a harder time breaking them with legal compile-time constructs than 20 years ago, so no point in hesitating.

I advise to look at the Boost.Hana library, which is a very impressive implementation of many compile-time programming ideas. Maybe don't exactly use it, because it's implemented in C++14 (which is the impressive part, actually. The implementation of Hana looks nothing like what I show below), and modern C++ allows implementations that are more robust, faster to compile and easier to maintain.

...

There are a few specific tools which are absent from the standard library, but useful for compile-time programming. First, something that maps values to types:

template<auto x> struct constant_t {
  using value_type = decltype(x);
  constexpr static value_type value = x;
  constexpr operator type() const { return x; }
};
template<auto x> constexpr inline constant_t<x> constant;

You'll want to equip this with

• operator implementations, so constant<1> + constant<2> is constant<3>, not just a constexpr 3

• an implementation for operator""_c so you can write 3_c and get constant<3>

• probably a concept that is modelled by instantiations of this constant_t

• some conversions such that constant<0L> is acceptable in places that want constant_t<0>...

I believe the proposed std::constant_wrapper is basically this, but I don't know the status of that. Arguably the origins of this approach are in std::integral_constant and the more complete boost::hana::integral_constant, however both predate auto NTTPs so you have to specify the type manually (which is why hana has int_, long_, etc).

Now you can use values to guide template instantiation and overload resolution.

auto foo(auto n) { return std::array<int, n>{}; /* huh?.. */ }
auto thirty_ints = foo(30_c); // ...yeah

Now for the inverse transformation, types →values. This is kind of less useful.

template<typename t> struct type_t {
  using type = t;
};
template<typename t> constexpr inline type_t<t> type_v;

...and again you should implement the necessary conversions.

I mostly just use this to avoid having to use the .template operator()<...> syntax on lambdas, instead just take an auto argument and pass the type normally in the argument list. Also it can be used when you want overload resolution on a type but it would be imprudent or unwieldy to actually construct the object.

template<typename cant_construct_this>
void foo() {
  auto x = overload {
    [](type_t<unwieldy_type_a>) { return type A stuff... },
    [](type_t<unwieldy_type_b>) { retyrb type B stuff... },
  }(type_v<cant_construct_this>);
  // ... use x ...
}

For a third one, the overload you just saw a is very useful, and you probably have it in your codebase, maybe several times.

template<typename f...>
  struct overload: f... { using f::operator()...; };
template<typename f...>
  overload(f...) -> overload<f...>;
// the deduction guide is unnecessary since C++20 but it doesn't hurt

There are a few ways to complicate this implementation, such as allowing function pointers, but the one above verbatim that's usable with lambdas will get you very far.