Add interpolation support for more std types, closes #37, closes #39, closes #40

Author: hsutter

include/cpp2util.h

@@ -763,14 +763,58 @@ inline auto to_string(std::string const& s) -> std::string const&
     return s;
 }
 
+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*>)
+{
+    return std::string{sv};
+}
+
 template<typename T>
 inline auto to_string(std::optional<T> const& o) -> std::string {
     if (o.has_value()) {
-        return std::to_string(o.value());
+        return cpp2::to_string(o.value());
     }
     return "(empty)";
 }
 
+template <typename... Ts>
+inline auto to_string(std::variant<Ts...> const& v) -> std::string
+{
+    if (v.valueless_by_exception()) return "(empty)";
+    //  Need to guard this with is_any otherwise the get_if is illegal
+    if constexpr (is_any<std::monostate, Ts...>) if (std::get_if<std::monostate>(&v) != nullptr) return "(empty)";
+
+    return std::visit([](auto&& arg) -> std::string {
+        if constexpr (requires { cpp2::to_string(arg); }) {
+            return cpp2::to_string(arg);
+        }
+        return "";
+    }, v);
+}
+
+template < typename T, typename U>
+inline auto to_string(std::pair<T,U> const& p) -> std::string
+{
+    return "(" + cpp2::to_string(p.first) + ", " + cpp2::to_string(p.second) + ")";
+}
+
+template < typename... Ts>
+inline auto to_string(std::tuple<Ts...> const& t) -> std::string
+{
+    if constexpr (sizeof...(Ts) == 0) {
+        return "()";
+    } else {
+        std::string out = "(" + cpp2::to_string(std::get<0>(t));
+        std::apply([&out](auto&&, auto&&... args) {
+            ((out += ", " + cpp2::to_string(args)), ...);
+        }, t);
+        out += ")";
+        return out;
+    }
+}
+
 inline auto to_string(...) -> std::string {
     return "(customize me - no cpp2::to_string overload exists for this type)";
 }

regression-tests/mixed-string-interpolation.cpp2

@@ -1,4 +1,7 @@
 #include <iostream>
+#include <string_view>
+#include <utility>
+#include <tuple>
 
 main: () -> int = {
     a := 2;
@@ -7,4 +10,29 @@ main: () -> int = {
 
     b = 42;
     std::cout << "a^2 + b = (a * a + b.value())$\n";
+
+    sv: std::string_view = "my string_view";
+    std::cout << "sv = (sv)$\n";
+
+    osv: std::optional<std::string_view> = ();
+    std::cout << "osv = (osv)$\n";
+    osv = "string literal bound to optional string_view";
+    std::cout << "osv = (osv)$\n";
+
+    var: std::variant<std::monostate, std::string, double> = ();
+    std::cout << "var = (var)$\n";
+    var = "abracadabra";
+    std::cout << "var = (var)$\n";
+    var = 2.71828;
+    std::cout << "var = (var)$\n";
+
+    mypair: std::pair<int, double> = (12, 3.4);
+    std::cout << "mypair = (mypair)$\n";
+
+    tup1: std::tuple<int> = (12);
+    tup2: std::tuple<int, double> = (12, 3.4);
+    tup3: std::tuple<int, double, std::string> = (12, 3.4, "456");
+    std::cout << "tup1 = (tup1)$\n";
+    std::cout << "tup2 = (tup2)$\n";
+    std::cout << "tup3 = (tup3)$\n";
 }

regression-tests/test-results/mixed-string-interpolation.cpp

@@ -3,12 +3,15 @@
 
 #line 1 "mixed-string-interpolation.cpp2"
 #include <iostream>
+#include <string_view>
+#include <utility>
+#include <tuple>
 
 [[nodiscard]] auto main() -> int;
 
 //=== Cpp2 definitions ==========================================================
 
-#line 2 "mixed-string-interpolation.cpp2"
+#line 5 "mixed-string-interpolation.cpp2"
 
 [[nodiscard]] auto main() -> int{
     auto a { 2 }; 
@@ -17,4 +20,29 @@
 
     b = 42;
     std::cout << "a^2 + b = " + cpp2::to_string(a * a + b.value()) + "\n";
+
+    std::string_view sv { "my string_view" }; 
+    std::cout << "sv = " + cpp2::to_string(sv) + "\n";
+
+    std::optional<std::string_view> osv {  }; 
+    std::cout << "osv = " + cpp2::to_string(osv) + "\n";
+    osv = "string literal bound to optional string_view";
+    std::cout << "osv = " + cpp2::to_string(osv) + "\n";
+
+    std::variant<std::monostate,std::string,double> var {  }; 
+    std::cout << "var = " + cpp2::to_string(var) + "\n";
+    var = "abracadabra";
+    std::cout << "var = " + cpp2::to_string(var) + "\n";
+    var = 2.71828;
+    std::cout << "var = " + cpp2::to_string(var) + "\n";
+
+    std::pair<int,double> mypair { 12, 3.4 }; 
+    std::cout << "mypair = " + cpp2::to_string(mypair) + "\n";
+
+    std::tuple<int> tup1 { 12 }; 
+    std::tuple<int,double> tup2 { 12, 3.4 }; 
+    std::tuple<int,double,std::string> tup3 { 12, 3.4, "456" }; 
+    std::cout << "tup1 = " + cpp2::to_string(tup1) + "\n";
+    std::cout << "tup2 = " + cpp2::to_string(tup2) + "\n";
+    std::cout << "tup3 = " + cpp2::to_string(tup3) + "\n";
 }