Adjust to PR feedback.

doc/api.rst

@@ -472,11 +472,11 @@ A ``std::variant`` is only formattable if every variant alternative is formattab
   #include <fmt/std.h>
 
   std::variant<char, float> v0{'x'};
-  // Prints "<'x'>"
+  // Prints "variant('x')"
   fmt::print("{}", v0);
 
-  std::variant<std::monostate, char> v1{};
-  // Prints "< >"
+  std::variant<std::monostate, char> v1;
+  // Prints "variant(monostate)"
 
 .. _compile-api:
 

include/fmt/std.h

@@ -72,6 +72,7 @@ FMT_END_NAMESPACE
 
 #ifdef __cpp_lib_variant
 #  include <variant>
+
 FMT_BEGIN_NAMESPACE
 template <typename Char> struct formatter<std::monostate, Char> {
   template <typename ParseContext>
@@ -83,7 +84,7 @@ template <typename Char> struct formatter<std::monostate, Char> {
   auto format(const std::monostate&, FormatContext& ctx) const
       -> decltype(ctx.out()) {
     auto out = ctx.out();
-    *out++ = ' ';
+    out = detail::write<Char>(out, "monostate");
     return out;
   }
 };
@@ -134,27 +135,28 @@ template <typename T, typename C> struct is_variant_formattable {
       detail::is_variant_formattable_<T, C>::value;
 };
 
-template <typename VariantT, typename Char>
+template <typename Variant, typename Char>
 struct formatter<
-    VariantT, Char,
+    Variant, Char,
     std::enable_if_t<std::conjunction_v<
-        is_variant_like<VariantT>, is_variant_formattable<VariantT, Char>>>> {
+        is_variant_like<Variant>, is_variant_formattable<Variant, Char>>>> {
   template <typename ParseContext>
   FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
     return ctx.begin();
   }
 
-  template <typename FormatContext = format_context>
-  auto format(const VariantT& value, FormatContext& ctx) const
+  template <typename FormatContext>
+  auto format(const Variant& value, FormatContext& ctx) const
       -> decltype(ctx.out()) {
     auto out = ctx.out();
-    *out++ = '<';
+
+    out = detail::write<Char>(out, "variant(");
     std::visit(
         [&](const auto& v) {
           out = detail::write_variant_alternative<Char>(out, v);
         },
         value);
-    *out++ = '>';
+    *out++ = ')';
     return out;
   }
 };

test/std-test.cc

@@ -37,16 +37,16 @@ TEST(std_test, thread_id) {
 
 TEST(std_test, variant) {
 #ifdef __cpp_lib_variant
-  EXPECT_EQ(fmt::format("{}", std::monostate{}), " ");
+  EXPECT_EQ(fmt::format("{}", std::monostate{}), "monostate");
   using V0 = std::variant<int, float, std::string, char>;
   V0 v0(42);
   V0 v1(1.5f);
   V0 v2("hello");
   V0 v3('i');
-  EXPECT_EQ(fmt::format("{}", v0), "<42>");
-  EXPECT_EQ(fmt::format("{}", v1), "<1.5>");
-  EXPECT_EQ(fmt::format("{}", v2), "<\"hello\">");
-  EXPECT_EQ(fmt::format("{}", v3), "<'i'>");
+  EXPECT_EQ(fmt::format("{}", v0), "variant(42)");
+  EXPECT_EQ(fmt::format("{}", v1), "variant(1.5)");
+  EXPECT_EQ(fmt::format("{}", v2), "variant(\"hello\")");
+  EXPECT_EQ(fmt::format("{}", v3), "variant('i')");
 
   struct unformattable {};
   EXPECT_FALSE((fmt::is_formattable<unformattable>::value));
@@ -61,7 +61,7 @@ TEST(std_test, variant) {
   V1 v4{};
   V1 v5{std::in_place_index<1>, "yes, this is variant"};
 
-  EXPECT_EQ(fmt::format("{}", v4), "< >");
-  EXPECT_EQ(fmt::format("{}", v5), "<\"yes, this is variant\">");
+  EXPECT_EQ(fmt::format("{}", v4), "variant(monostate)");
+  EXPECT_EQ(fmt::format("{}", v5), "variant(\"yes, this is variant\")");
 #endif
 }