Support more unary and binary fold-expressions

Also support interpolation and "as std::string" for ints and bools (and remove uses of `std::boolalpha`, use `as std::string` or interpolation instead)

Author: hsutter

include/cpp2util.h

@@ -286,10 +286,13 @@ using __uchar   = unsigned char;    // normally use u8 instead
 //-----------------------------------------------------------------------
 //
 
-constexpr auto max(auto... values) {
+inline constexpr auto max(auto... values) {
     return std::max( { values... } );
 }
 
+template <class T, class... Ts>
+inline constexpr auto is_any = std::disjunction_v<std::is_same<T, Ts>...>;
+
 
 //-----------------------------------------------------------------------
 //
@@ -781,6 +784,108 @@ class out {
 }(PARAM1)
 
 
+//-----------------------------------------------------------------------
+//
+//  to_string for string interpolation
+//
+//-----------------------------------------------------------------------
+//
+inline auto to_string(...) -> std::string
+{
+    return "(customize me - no cpp2::to_string overload exists for this type)";
+}
+
+inline auto to_string(std::same_as<std::any> auto const&) -> std::string
+{
+    return "std::any";
+}
+
+inline auto to_string(bool b) -> std::string
+{
+    return b ? "true" : "false";
+}
+
+template<typename T>
+inline auto to_string(T const& t) -> std::string
+    requires requires { std::to_string(t); }
+{
+    return std::to_string(t);
+}
+
+inline auto to_string(char const& t) -> std::string
+{
+    return std::string{t};
+}
+
+inline auto to_string(char const* s) -> std::string
+{
+    return std::string{s};
+}
+
+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... Ts>
+inline auto to_string(std::variant<Ts...> const& v) -> std::string;
+
+template < typename T, typename U>
+inline auto to_string(std::pair<T,U> const& p) -> std::string;
+
+template < typename... Ts>
+inline auto to_string(std::tuple<Ts...> const& t) -> std::string;
+
+template<typename T>
+inline auto to_string(std::optional<T> const& o) -> std::string {
+    if (o.has_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 {
+        return cpp2::to_string(arg);
+    }, 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;
+    }
+}
+
+
 //-----------------------------------------------------------------------
 //
 //  is and as
@@ -1000,9 +1105,20 @@ auto as( X& x ) -> decltype(auto) {
     return x;
 }
 
+
+template< typename C, typename X >
+auto as(X const& x) -> C
+    requires (std::is_same_v<C, std::string> && std::is_integral_v<X>)
+{
+    return cpp2::to_string(x);
+}
+
+
 template< typename C, typename X >
 auto as( X const& x ) -> auto
-    requires (!std::is_same_v<C, X> && !std::is_base_of_v<C, X> && requires { C{x}; })
+    requires (!std::is_same_v<C, X> && !std::is_base_of_v<C, X> && requires { C{x}; }
+              && !(std::is_same_v<C, std::string> && std::is_integral_v<X>) // exclude above case
+             )
 {
     //  Experiment: Recognize the nested `::value_type` pattern for some dynamic library types
     //  like std::optional, and try to prevent accidental narrowing conversions even when
@@ -1158,9 +1274,6 @@ constexpr auto is( std::variant<Ts...> const& x, auto const& value ) -> bool
 
 //  as
 //
-template <class T, class... Ts>
-inline constexpr auto is_any = std::disjunction_v<std::is_same<T, Ts>...>;
-
 template<typename T, typename... Ts>
 auto is( std::variant<Ts...> const& x ) {
     if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as< 0>(x)), T >) { if (x.index() ==  0) return true; }
@@ -1424,115 +1537,6 @@ class finally
 };
 
 
-//-----------------------------------------------------------------------
-//
-//  to_string for string interpolation
-//
-//-----------------------------------------------------------------------
-//
-inline auto to_string(...) -> std::string {
-    return "(customize me - no cpp2::to_string overload exists for this type)";
-}
-
-inline auto to_string(std::same_as<std::any> auto const&) -> std::string {
-    return "std::any";
-}
-
-template<typename T>
-inline auto to_string(T const& t) -> std::string
-    requires requires { std::to_string(t); }
-{
-    return std::to_string(t);
-}
-
-inline auto to_string(char const& t) -> std::string
-{
-    return std::string{t};
-}
-
-inline auto to_string(char const* s) -> std::string
-{
-    return std::string{s};
-}
-
-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... Ts>
-inline auto to_string(std::variant<Ts...> const& v) -> std::string;
-
-template < typename T, typename U>
-inline auto to_string(std::pair<T,U> const& p) -> std::string;
-
-template < typename... Ts>
-inline auto to_string(std::tuple<Ts...> const& t) -> std::string;
-
-template<typename T>
-inline auto to_string(std::optional<T> const& o) -> std::string {
-    if (o.has_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 {
-        return cpp2::to_string(arg);
-    }, 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;
-    }
-}
-
-
-//-----------------------------------------------------------------------
-//
-//  and "as std::string" for the same cases
-//
-template< typename C >
-auto as(auto& x) -> C
-    requires (std::is_same_v<C, std::string>
-              && requires { cpp2::to_string(x); })
-{
-    return cpp2::to_string(x);
-}
-
-
-
 //-----------------------------------------------------------------------
 //
 //  args: see main() arguments as vector<string_view>

regression-tests/mixed-fixed-type-aliases.cpp2

@@ -8,8 +8,7 @@ namespace my {
 
 test: (x:_) = {
     std::cout
-        << std::boolalpha
-        << std::is_floating_point_v<CPP2_TYPEOF(x)>
+        << std::is_floating_point_v<CPP2_TYPEOF(x)> as std::string
         << "\n";
 }
 

regression-tests/pure2-bugfix-for-template-argument.cpp2

@@ -1,5 +1,2 @@
 main: () =
-    std::cout
-        << std::boolalpha
-        << (std::is_void_v<* i32> && std::is_void_v<const i32>)
-        << "\n";
+    std::cout << "(std::is_void_v<* i32> && std::is_void_v<const i32>)$\n";

regression-tests/pure2-chained-comparisons.cpp2

@@ -1,15 +1,14 @@
 main: () -> int = {
-    std::cout << std::boolalpha;
     i:=0; while i<3 next i++ {
         j:=0; while j<3 next j++ {
             k:=0; while k<3 next k++ {
                 std::cout
                     << i << " "
                     << j << " "
                     << k << ": "
-                    << (i == j == k) << " "
-                    << (i <  j <= k) << " "
-                    << (i >= j >  k) << "\n";
+                    << (i == j == k) as std::string << " "
+                    << (i <  j <= k) as std::string << " "
+                    << (i >= j >  k) as std::string << "\n";
             }
         }
     }

regression-tests/pure2-variadics.cpp2

@@ -1,8 +1,18 @@
 
+//  Type pack expansion
 x: <Ts...: type> type = {
     tup: std::tuple<Ts...> = ();
 }
 
+print: <Args...: type> (inout out: std::ostream, args...: Args) = {
+    //  Binary left fold expression
+    (out << ... << args);
+}
+
+all: <Args...: type> (args...: Args) -> bool =
+    //  Unary left fold expression
+    (... && args);
+
 make_string: <Args...: type> (forward args...: Args) -> _ = :std::string = args...;
 
 make: <T, Args...: type> (forward args...: Args) -> _ = :T = args...;
@@ -14,4 +24,9 @@ main: ()
     std::cout << std::string("xyzzy", 3) << "\n";
     std::cout << make_string("plugh", :u8=3) << "\n";
     std::cout << make<std::string>("abracadabra", :u8=3) << "\n";
+
+    print( std::cout, 3.14, "word", -1500 );
+
+    std::cout << "\nfirst all() returned (all(true, true, true, false))$";
+    std::cout << "\nsecond all() returned " << all(true, true, true, true) as std::string;
 }

regression-tests/test-results/clang-12/pure2-enum.cpp.execution

@@ -10,15 +10,15 @@ f2 is (none)
 f2 is (cached)
 f  as int  is 1
 f2 as int  is 1
-f  is (f2) is 1
-f2 is (f ) is 1
+f  is (f2) is true
+f2 is (f ) is true
 
 f  is (cached, current, obsolete, cached_and_current)
 f2 is (cached, current, cached_and_current)
 f  as int  is 7
 f2 as int  is 3
-f  == f2   is 0
-f  is (f2) is 0
-f2 is (f ) is 0
-(f & f2) == f2 is 1
+f  == f2   is false
+f  is (f2) is false
+f2 is (f ) is false
+(f & f2) == f2 is true
 inspecting: includes all f2's flags ('cached' and 'current')

regression-tests/test-results/clang-12/pure2-variadics.cpp.execution

@@ -1,3 +1,6 @@
 xyz
 plu
 abr
+3.14word-1500
+first all() returned false
+second all() returned true

regression-tests/test-results/gcc-10/pure2-bugfix-for-requires-clause-in-forward-declaration.cpp.output

@@ -11,18 +11,18 @@ pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:3:46: error: expect
 In file included from pure2-bugfix-for-requires-clause-in-forward-declaration.cpp:7:
 ../../../include/cpp2util.h:10005:47: error: static assertion failed: GCC 11 or higher is required to support variables and type-scope functions that have a 'requires' clause. This includes a type-scope 'forward' parameter of non-wildcard type, such as 'func: (this, forward s: std::string)', which relies on being able to add a 'requires' clause - in that case, use 'forward s: _' instead if you need the result to compile with GCC 10.
 pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:4:1: note: in expansion of macro ‘CPP2_REQUIRES_’
-pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:3:3: error: no declaration matches ‘element::element(auto:82&&) requires  is_same_v<typename std::remove_cv<typename std::remove_reference<decltype(element::__ct ::n)>::type>::type, std::__cxx11::string>’
+pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:3:3: error: no declaration matches ‘element::element(auto:81&&) requires  is_same_v<typename std::remove_cv<typename std::remove_reference<decltype(element::__ct ::n)>::type>::type, std::__cxx11::string>’
 pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:5:11: note: candidates are: ‘element::element(const element&)’
-pure2-bugfix-for-requires-clause-in-forward-declaration.cpp:16:20: note:                 ‘template<class auto:80> element::element(auto:80&&)’
+pure2-bugfix-for-requires-clause-in-forward-declaration.cpp:16:20: note:                 ‘template<class auto:79> element::element(auto:79&&)’
    16 |   public: explicit element(auto&& n)
       |                    ^~~~~~~
 pure2-bugfix-for-requires-clause-in-forward-declaration.cpp:14:7: note: ‘class element’ defined here
    14 | class element {
       |       ^~~~~~~
 pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:3:3: error: expected unqualified-id before ‘{’ token
-pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:3:8: error: no declaration matches ‘element& element::operator=(auto:83&&) requires  is_same_v<typename std::remove_cv<typename std::remove_reference<decltype(element::operator=::n)>::type>::type, std::__cxx11::string>’
+pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:3:8: error: no declaration matches ‘element& element::operator=(auto:82&&) requires  is_same_v<typename std::remove_cv<typename std::remove_reference<decltype(element::operator=::n)>::type>::type, std::__cxx11::string>’
 pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:6:16: note: candidates are: ‘void element::operator=(const element&)’
-pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:3:16: note:                 ‘template<class auto:81> element& element::operator=(auto:81&&)’
+pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:3:16: note:                 ‘template<class auto:80> element& element::operator=(auto:80&&)’
 pure2-bugfix-for-requires-clause-in-forward-declaration.cpp:14:7: note: ‘class element’ defined here
    14 | class element {
       |       ^~~~~~~