View source for Talk:cpp/language/constexpr

== Non Literal (but unused) parameters to constexpr functions ==

At the current time, all parameters to constexpr functions must be ''Literal''.  It seems to me that parameters that are not used by the function body should not have to meet this restriction.  Unused parameters can be included for a number of reasons, including differentiation between function overloads.  Ignoring things like promotion of short to int, here are examples, very much simplified:
    (1) constexpr std::string_view type_name(bool value) { return "bool" }
    (2) constexpr std::string_view type_name(int value) { return "int" }
    (3) constexpr std::string_view type_name(double value) { return "double" }
    (4) constexpr std::string_view type_name(long double value) { return "long double" }

One might expect to be able to extend this further:
    (5) constexpr std::string_view type_name(std::string value) { return "string" }
but that fails because std::string can't be a ''Literal'' value.  Luckily, references are ''Literal'' so the following does work:
    (6) constexpr std::string_view type_name(std::string &value) { return "string" }

Add a template and things get more complicated:
    (7) constexpr std::string_view type_name(T value) {
            if std::is_enum_v<T> return "enum"sv;
            if std::is_integral_v<T> return "some other integral type"sv;
            if std::is_floating_point_v<T> return "some other floating type"sv;
            return "something else not yet implemented"
        }
The template CAN be used with a what appears to be non-''Literal'' type because it actually matches with T being a reference (such as "std::map<...> &").

Anyway, my suggestion for improvement is that if the parameter is anonymous (e.g., "std:string" instead of "std:string value") then that parameter should not keep the function from being declared constexpr.  Anonymous parameters don't prevent a function from being executed at compile time!

(If you wanted to take this reasoning further, then any parameters that are not used anywhere inside a function's body, anonymous or named, should not keep that function from being declared constexpr.)

Having laid this long groundwork, does my reasoning make sense to others?  Should a change be proposed the C++ standard committee for some future revision?

[[Special:Contributions/172.88.122.95|172.88.122.95]] 16:21, 10 January 2022 (PST)

: That non-trivial {{tt|std::string}} (which is actually allowed in C++20) still needs its destructor executed, so it doesn't quite have no effect on the function, and I would generally advise that you don't add useless parameters to your functions if they really are useless --[[User:Ybab321|Ybab321]] ([[User talk:Ybab321|talk]]) 04:41, 11 January 2022 (PST)