What type trait is used to select between object and list-of-pairs serialisation for map types?

[eddyashton]

When converting a std::map (or similar type) to JSON, it will sometimes be converted to a JSON object and sometimes to a list of lists. This choice depends on the key type; if the key can be converted to string, then the map can be converted to an object. eg:

std::cout << nlohmann::json(std::map<std::string, int>{{"a", 42}}) << std::endl;
// {"a":42}
std::cout << nlohmann::json(std::map<int, int>{{0, 42}}) << std::endl;
// [[0,42]]

The object case is not just for when the key is std::string, but somehow detects that it is convertible to std::string, so this even works for user-defined types:

struct Test {
  std::string s;
  Test() = default;
  Test(const std::string& s_): s(s_) {}
  operator std::string() const { return s; }
  bool operator<(const Test& t) const { return s < t.s; }
};

std::cout << nlohmann::json(std::map<Test, int>{{{"a"}, 42}}) << std::endl;
// {"a":42}

What makes this choice? I've poked around json.hpp but can't work out which bit of template machinery is doing this.
Is this logic exposed as a type trait that I can reuse elsewhere, to determine whether my type will become an object?

My use case is that I'm trying to generate JSON schema that describe how my C++ types will be serialised to JSON. This works correctly for most types, but not for some map types. I currently only check if the key type is std::string, but nlohmann::json will also produce an object for other types (ie - has operator std::string() const defined, and potentially some other cases?). The relevant snippet is here:

      else if constexpr (
        nonstd::is_specialization<T, std::map>::value ||
        nonstd::is_specialization<T, std::unordered_map>::value)
      {
        // Nlohmann serialises maps to an array of (K, V) pairs...
        if (std::is_same<typename T::key_type, std::string>::value) //< Inaccurate
        {
          // ...unless the keys are strings!
          schema["type"] = "object";
          schema["additionalProperties"] =
            schema_element<typename T::mapped_type>();
        }
        else
        {
          schema["type"] = "array";

Is there something I can drop in to replace the //< Inaccurate line which will correctly detect all the types which are convertible to objects?

[eddyashton]

We eventually found nlohmann::detail::is_compatible_object_type<nlohmann::json, T>, which appears to do what we want. Not sure what the API guarantees are on the detail namespace, or if this is intended to be used outside, but hope this is a useful pointer for anyone else trying to solve the same thing.

[nlohmann]

I currently give no guarantee about the stability of the details namespace, but I should document this at some point.