Comparison to Go?

This is mostly off-topic but: It's not just text mangling, once you get into metaprogramming. It's a powerful duck-typed language for writing programs that execute at compile-time, where the values in that language include ints, bools, and (crucially) C++ types. The use of C++ types as values is what makes it "meta" and distinguishes it from compile-time evaluation of regular C++ code, and also distinguishes it from the C preprocessor (which _is_ basically text mangling). The metaprogram can see all the types (including classes) in your non-meta code, and can output new types and functions for use by the non-meta code.

For example you can write something like `template<typename T> auto deref(T p) { if constexpr (std::is_pointer_v<T>) return deref(*p); else return p; }` which will convert e.g. `int***` to `int`. The metaprogram has input parameter `T` which is a C++ type; it can observe and manipulate that type in various ways (like with `is_pointer_v` to test if it's a pointer type), and in this case it outputs a C++ function that only includes the `*p` expression when it's legal to do so.

(Originally C++'s metaprogramming language was horrifically ugly, very hard to use, a pure functional language, and bore little resemblance to non-meta C++; it existed more by accident than by design. Nowadays with features like `if constexpr`, it's not always so bad, though it's often still quite bad.)

I think the closest equivalent functionality in Rust is procedural macros, but those are compile-time programs that operate over Rust tokens or ASTs, not over Rust types, so they're not really very similar. (I think no other language has anything very similar to C++ template metaprogramming, because you can get 90% of its functionality with very different designs that are 90% less insane.)