Added generic "is empty" support via is void or synonym is empty

Author: hsutter

include/cpp2util.h

@@ -481,6 +481,10 @@ class out {
 //  when customizing is/as for std::variant
 static std::nullptr_t nonesuch = nullptr;
 
+//  For designating "holds no value" -- used only with is, not as
+//  TODO: Does this really warrant a new synonym? Perhaps "is void" is enough
+using empty = void;
+
 template< typename C, typename X >
 auto is( X const& ) -> bool {
     return false;
@@ -510,6 +514,12 @@ auto is( X const* x ) -> bool {
     return dynamic_cast<C const&>(x) != nullptr;
 }
 
+template< typename C, typename X >
+    requires (requires (X x) { *x; X(); } && std::is_same_v<C, empty>)
+auto is( X const& x ) -> bool {
+    return x == X();
+}
+
 
 //-------------------------------------------------------------------------------------------------------------
 //  Built-in as (partial)
@@ -570,6 +580,7 @@ template<typename... Ts>
 constexpr auto operator_is( std::variant<Ts...> const& x ) {
     return x.index();
 }
+
 template<size_t I, typename... Ts>
 constexpr auto operator_as( std::variant<Ts...> const& x ) -> auto&& {
     if constexpr (I < std::variant_size_v<std::variant<Ts...>>) {
@@ -580,6 +591,10 @@ constexpr auto operator_as( std::variant<Ts...> const& x ) -> auto&& {
     }
 }
 
+//  A helper for is...
+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;
@@ -592,6 +607,11 @@ auto is( std::variant<Ts...> const& x ) {
     if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<7>(x)), T >) if (x.index() == 7) return true;
     if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<8>(x)), T >) if (x.index() == 8) return true;
     if constexpr (std::is_same_v< CPP2_TYPEOF(operator_as<9>(x)), T >) if (x.index() == 9) return true;
+    if constexpr (std::is_same_v< T, empty > ) {
+        if (x.valueless_by_exception()) return true;
+        //  Need to guard this with is_any otherwise the get_if is illegal
+        if constexpr (is_any<std::monostate, Ts...>) return std::get_if<std::monostate>(&x) != nullptr;
+    }
     return false;
 }
 
@@ -615,10 +635,15 @@ auto as( std::variant<Ts...> const& x ) {
 //  std::any is and as
 //
 template<typename T, typename X>
-    requires (std::is_same_v<X,std::any> && !std::is_same_v<T,std::any>)
+    requires (std::is_same_v<X,std::any> && !std::is_same_v<T,std::any> && !std::is_same_v<T,empty>)
 constexpr auto is( X const& x ) -> bool
     { return x.type() == typeid(T); }
 
+template<typename T, typename X>
+    requires (std::is_same_v<X,std::any> && std::is_same_v<T,empty>)
+constexpr auto is( X const& x ) -> bool
+    { return !x.has_value(); }
+
 template<typename T, typename X>
     requires (!std::is_reference_v<T> && std::is_same_v<X,std::any> && !std::is_same_v<T,std::any>)
 constexpr auto as( X const& x ) -> T
@@ -633,6 +658,11 @@ template<typename T, typename X>
 constexpr auto is( X const& x ) -> bool
     { return x.has_value(); }
 
+template<typename T, typename U>
+    requires std::is_same_v<T,empty>
+constexpr auto is( std::optional<U> const& x ) -> bool
+    { return !x.has_value(); }
+
 template<typename T, typename X>
     requires std::is_same_v<X,std::optional<T>>
 constexpr auto as( X const& x ) -> auto&&

regression-tests/pure2-inspect-generic-void-empty-with-variant-any-optional.cpp2

@@ -0,0 +1,26 @@
+
+main: () -> int = {
+    p: std::unique_ptr<int> = ();
+    i: std::vector<int>::iterator = ();
+    v: std::variant<std::monostate, int, std::string> = ();
+    a: std::any = ();
+    o: std::optional<std::string> = ();
+
+    std::cout << "\nAll these cases satisfy \"VOYDE AND EMPTIE\"\n";
+
+    test_generic(p);
+    test_generic(i);
+    test_generic(v);
+    test_generic(a);
+    test_generic(o);
+}
+
+test_generic: ( x: _ ) = {
+    std::cout
+        << "\n" << typeid(x).name() << "\n    ..."
+        << inspect x -> std::string {
+            is void = " VOYDE AND EMPTIE";
+            is _   = " no match";
+        }
+        << "\n";
+}

regression-tests/test-results/pure2-inspect-generic-void-empty-with-variant-any-optional.cpp

@@ -0,0 +1,39 @@
+// ----- Cpp2 support -----
+#define CPP2_USE_MODULES         Yes
+#include "cpp2util.h"
+
+
+#line 2 "pure2-inspect-generic-void-empty-with-variant-any-optional.cpp2"
+[[nodiscard]] auto main() -> int;
+#line 18 "pure2-inspect-generic-void-empty-with-variant-any-optional.cpp2"
+auto test_generic(auto const& x) -> void;
+
+//=== Cpp2 definitions ==========================================================
+
+#line 1 "pure2-inspect-generic-void-empty-with-variant-any-optional.cpp2"
+
+[[nodiscard]] auto main() -> int{
+    std::unique_ptr<int> p {  }; 
+    std::vector<int>::iterator i {  }; 
+    std::variant<std::monostate,int,std::string> v {  }; 
+    std::any a {  }; 
+    std::optional<std::string> o {  }; 
+
+    std::cout << "\nAll these cases satisfy \"VOYDE AND EMPTIE\"\n";
+
+    test_generic(p);
+    test_generic(i);
+    test_generic(v);
+    test_generic(a);
+    test_generic(o);
+}
+
+auto test_generic(auto const& x) -> void{
+    std::cout 
+        << "\n" << typeid(x).name() << "\n    ..." 
+        << [&] () -> std::string { auto&& __expr = x;
+            if (cpp2::is<void>(__expr)) { if constexpr( requires{" VOYDE AND EMPTIE";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(" VOYDE AND EMPTIE"),std::string> ) return " VOYDE AND EMPTIE"; else return std::string{}; else return std::string{}; }
+            else return " no match"; }
+        ()
+        << "\n";
+}

regression-tests/test-results/pure2-inspect-generic-void-empty-with-variant-any-optional.cpp2

@@ -0,0 +1,26 @@
+
+main: () -> int = {
+    p: std::unique_ptr<int> = ();
+    i: std::vector<int>::iterator = ();
+    v: std::variant<std::monostate, int, std::string> = ();
+    a: std::any = ();
+    o: std::optional<std::string> = ();
+
+    std::cout << "\nAll these cases satisfy \"VOYDE AND EMPTIE\"\n";
+
+    test_generic(p);
+    test_generic(i);
+    test_generic(v);
+    test_generic(a);
+    test_generic(o);
+}
+
+test_generic: ( x: _ ) = {
+    std::cout
+        << "\n" << typeid(x).name() << "\n    ..."
+        << inspect x -> std::string {
+            is void = " VOYDE AND EMPTIE";
+            is _   = " no match";
+        }
+        << "\n";
+}

regression-tests/test-results/pure2-inspect-generic-void-empty-with-variant-any-optional.cpp2-output

@@ -0,0 +1,2 @@
+pure2-inspect-generic-void-empty-with-variant-any-optional.cpp2... ok (all Cpp2, passes safety checks)
+