Add to_string support for types like filesystem::path and complex that support << streaming

And simplify by converting the default implementations from overloads into a merged function with if-constexpr cases

Author: hsutter

include/cpp2util.h

@@ -1190,73 +1190,63 @@ struct nonesuch_ {
 };
 constexpr inline nonesuch_ nonesuch;
 
-inline auto to_string([[maybe_unused]] auto const& _) -> std::string
-{
-    return "(customize me - no cpp2::to_string overload exists for this type)";
-}
-
-inline auto to_string(nonesuch_) -> std::string
+//  Suppress spurious MSVC warnings about unreachable code
+#ifdef _MSC_VER
+#pragma warning( push )
+#pragma warning( disable : 4702 )
+#endif
+inline auto to_string(auto const& x) -> std::string
 {
-    return "(invalid type)";
-}
+    //  Handle degenerate case
+    if constexpr (std::is_same_v<CPP2_TYPEOF(x), std::string>) {
+        return x;
+    }
 
-inline auto to_string(std::same_as<std::any> auto const&) -> std::string
-{
-    return "std::any";
-}
+    //  Else customize bool (prefer this over << to avoid std::boolalpha)
+    if constexpr( std::is_same_v<CPP2_TYPEOF(x), bool> ) {
+        return x ? "true" : "false";
+    }
 
-inline auto to_string(bool b) -> std::string
-{
-    return b ? "true" : "false";
-}
+    //  Else customize char (before int)
+    if constexpr (std::is_same_v<CPP2_TYPEOF(x), char>) {
+        return std::string{ x };
+    }
 
-template<typename T>
-inline auto to_string(T const& t) -> std::string
-    requires requires { std::to_string(t); }
-{
-    return std::to_string(t);
-}
+    //  Else customize char*
+    if constexpr (std::is_same_v<CPP2_TYPEOF(x), const char*>) {
+        return std::string{ x };
+    }
 
-////  We'd like to add this convenience, which would support std::filesystem::path() and similar.
-////
-////  TODO: As written, this one would make some cases ambiguous. We should rewrite these
-////  common to_string functions as a single template with 'if constexpr' alternatives,
-////  as was done with 'is', and then this will be simpler.
-//template<typename T>
-//inline auto to_string(T const& t) -> std::string
-//    requires std::is_convertible_v<decltype((std::stringstream() << t).str()), std::string>
-//{
-//    return (std::stringstream() << t).str();
-//}
+    //  Else prefer string_view if available
+    if constexpr (std::is_convertible_v<CPP2_TYPEOF(x), std::string_view>) {
+        return std::string{ x };
+    }
 
-template<typename T>
-inline auto to_string(T const& t) -> std::string
-    requires std::is_convertible_v<decltype(t.to_string()), std::string>
-{
-    return t.to_string();
-}
+    //  Else prefer std::to_string if available
+    if constexpr( requires { std::to_string(x); } ) {
+        return std::to_string(x);
+    }
 
-inline auto to_string(char const& t) -> std::string
-{
-    return std::string{t};
-}
+    //  Else prefer streaming << if available
+    if constexpr( requires { { (std::stringstream() << x).str() } -> std::convertible_to<std::string>; } ) {
+        return (std::stringstream() << x).str();
+    }
 
-inline auto to_string(char const* s) -> std::string
-{
-    return std::string{s};
-}
+    //  Else complain about a 'nonesuch' result
+    if constexpr( std::is_same_v<CPP2_TYPEOF(x), nonesuch_> ) {
+        return "(invalid type)";
+    }
 
-inline auto to_string(std::string const& s) -> std::string const&
-{
-    return s;
+    //  Else prompt to customize
+    return "(customize me - no cpp2::to_string overload exists for this type)";
 }
+#ifdef _MSC_VER
+#pragma warning( pop )
+#endif
 
-template<typename T>
-inline auto to_string(T const& sv) -> std::string
-    requires (std::is_convertible_v<T, std::string_view>
-              && !std::is_convertible_v<T, const char*>)
+inline auto to_string(std::same_as<std::any> auto const&) -> std::string
 {
-    return std::string{sv};
+    return "std::any";
 }
 
 template <typename... Ts>

regression-tests/pure2-interpolation.cpp2

@@ -28,4 +28,7 @@ main: ()->int = {
         std::cout << "(x.name():20)$ color (x.color():10)$ price (x.price(): <10.2f)$ in stock = (x.count() > 0)$\n";
     }
 
+    ri: std::complex = ( 1.2, 3.4 );
+    std::cout << "complex: (ri)$\n";    // works on GCC 11.2+ and Clang 13+
+                                        // prints "customize me" on GCC 11.1 and Clang 12
 }

regression-tests/test-results/clang-12-c++20/pure2-interpolation.cpp.execution

@@ -10,3 +10,4 @@ pl(ug$h
 0pl(ug$h
 Dog kennel           color mauve      price 3.14       in stock = true
 Dog kennel color mauve price 3.140000 in stock = true
+complex: (customize me - no cpp2::to_string overload exists for this type)

regression-tests/test-results/gcc-10-c++20/pure2-interpolation.cpp.execution

@@ -10,3 +10,4 @@ pl(ug$h
 0pl(ug$h
 Dog kennel           color mauve      price 3.14       in stock = true
 Dog kennel color mauve price 3.140000 in stock = true
+complex: (customize me - no cpp2::to_string overload exists for this type)

regression-tests/test-results/gcc-14-c++2b/pure2-interpolation.cpp.execution

@@ -10,3 +10,4 @@ pl(ug$h
 0pl(ug$h
 Dog kennel           color mauve      price 3.14       in stock = true
 Dog kennel           color mauve      price 3.14       in stock = true
+complex: (1.2,3.4)

regression-tests/test-results/msvc-2022-c++latest/pure2-interpolation.cpp.execution

@@ -10,3 +10,4 @@ pl(ug$h
 0pl(ug$h
 Dog kennel           color mauve      price 3.14       in stock = true
 Dog kennel           color mauve      price 3.14       in stock = true
+complex: (1.2,3.4)

regression-tests/test-results/pure2-interpolation.cpp

@@ -71,5 +71,8 @@ auto const& x{item()};
 }
 
 #line 31 "pure2-interpolation.cpp2"
+    std::complex ri {1.2, 3.4}; 
+    std::cout << ("complex: " + cpp2::to_string(cpp2::move(ri)) + "\n");// works on GCC 11.2+ and Clang 13+
+                                        // prints "customize me" on GCC 11.1 and Clang 12
 }