If you have a hierarchy of types

    struct A {vector<B> Children; int NChildren = 2, ...};
    struct B {vector<C> Children; int NChildren = 2; ...};
    struct C {vector<D> Children; int NChildren = 2; ...};
    struct D {...)

and a function template

    template<typename T> T miniParser() { return T{}; }

and you call it like

    struct A;
    recurseFillChildren<A, B, C, D>(A);

It expands into nested loops that fill the "Children" areas of each type with two default-constructed values of the next type down the hierarchy, until you get to D, at which point it does nothing.

The reason you can't implement this in Rust is that Rust Generics (their "template-y" language feature) is missing a few capabilities relative to C++ templates. Namely,

1. They don't operate on numbers

2. They have no notion of collections of types

Because of this, they

1. Can't know that there is a collection of types

2. Can't extract the size of the collection of types

This comes up in numerical code, where in C++ it is easy to write e.g. geometry code that is generic in the number of spatial dimensions, but in Rust it is a pain in the ass.

This is a "non-type template parameter," that is, it's generic over that size_t i. Rust cannot yet do this. This is "const generics" in Rust speak.

I used to know C++. But not sure what's happening here.

This is me too and sometimes I feel like the language is going in two directions. The academic / scholar path where people show off unreadable C++ like this and the business path where professionals that use a subset of the language (mandated by corporate code base or teams) that are competent C++ developers but maybe not writing this complicated C++.

I work in telecoms and 'template like this' show up from time to time sometimes for reasonable reasons, sometimes for 'optimisations' reasons which are not backed by figures (some programmers like to show off).

Templates, in my opinion, are often extremely hard to read, not unlike Perl in its time.

And I will always prefer more verbose code that I can read, understand and maintain.

It demonstrates a method of generating a family of types or functions that, until C++17, would have required Template Metaprogramming via partial specialization or template function overloading, but is now just programming.

The key line is "if constexpr", which is evaluated at compile time and terminates the recursion.

could a proc macro not do it?