Comparison operator enum class <=> json could be discouraging.

[alex-700]

Lets start with an example: godbolt

Code

#include <iostream>
#include <nlohmann/json.hpp>

enum class Severity {
    Low,
    High,
};

NLOHMANN_JSON_SERIALIZE_ENUM(Severity, {
                                           {Severity::Low, "Low"},
                                           {Severity::High, "High"},
                                       });

int main() {
    std::cout << (Severity::High < nlohmann::json("Low")) << '\n'
              << (Severity::High < nlohmann::json("Low").get<Severity>())
              << '\n';
}

While using the library, it's a usual thing to have some enum, and [de]serialization for it via NLOHMANN_JSON_SERIALIZE_ENUM (or some other) macro. Also enums are comparable by default, and in some cases "Ord" comparison can be used (e.g. Severity::Low < Severity::High), but this is different in lexicographic comparison of string representation ("Low" > "High").

Assume that one gets some json with "severity" inside, and would like to compare severity from json with some value:

Severity::High < nlohmann::json("Low")

it can be compiled (due to this overload of <=>), but gets the wrong result. One (who does not know about this overloading) can expect that it works the right way by choosing operator <=>(Severity, Severity) and the implicit conversion from json to Severity.

I can understand, why this <=> overload (with the current implementation) is here for std::is_arithmetic types (usually json [de]serialization for them is natural), but not for std::is_enum.

I suggest to remove this overload for enum-s.
IIUC, in this case, Severity::High < nlohmann::json("Low") will work correctly (in terms of operator<=>(Severity, Severity)), when JSON_USE_IMPLICIT_CONVERSIONS=1, and will not compilable (it seems to be a good thing) when JSON_USE_IMPLICIT_CONVERSIONS=0

Notes

• pre c++20 set of comparison operators need to be fixed also (if we decide about <=>)
• I am talking mostly about strangeness of comparison operators like <, <=, >, >=, but not about equality operators. For example, json::operator == for enums is semantically OK with the current implementation (hidden to_string conversion can be not-optimal way to do this, but this is for another discussion).

[alex-700]

@nlohmann could you share your thoughts about the topic?

[nlohmann]

Sounds reasonable.