"if constexpr" and compile-time reflection making meta-programming without macros

[Xtricman]

C++ has "if constexpr" to enable conditional compilation, with the type_traits functions, so it can generate code based on properties of a type using normal C++ grammar instead of writing macros, but type_traits are very tricky to implement (usually involving SFINAE or even intrinsics) because C++ currently doesn't have compile-time reflection, SFINAE can't inspect fields of a type.

Rust already support compile time evaluation, can we add "if constexpr" and compile-time reflection to Rust so meta-programing would be much easier using normal Rust grammar?

[jonas-schievink]

This is already covered by #[cfg], const fn, and procedural macros. If you need more language features to cover your use cases, they need to go through the RFC process first, so closing in favor of that.

[jgarvin]

I'm not knowledgable enough yet to do an RFC, but I thought I would record here why the features @jonas-schievink lists are not equivalent.

#[cfg] is for feature switches to change a function definition which doesn't vary at each function call site, const fn only lets you compute const values, it doesn't let you control code generation, and procedural macros operate on token streams and so can't see types. if constexpr lets you control code generation in a way that varies by call site while also having access to types -- you can do things like change your return type based on a const fn that is a function of a generic parameter, b/c after if constexpr evaluation only one return is left so the return type is considered consistent:

template<class T>
auto foo()
{
    if constexpr(compile_time_compute_value_changing_depending_on_T<T>()) {
        return Type1();
    else {
        return Type2();
    }
}