✨ Add optional tombstones for product types

Problem:
- Product types cannot easily be put into `stdx::optional` without specifying a
  separate tombstone value.

Solution:
- If the types inside the product already have tombstone values, use them.

Author: elbeno

include/stdx/optional.hpp

@@ -23,6 +23,11 @@ template <typename T, typename = void> struct tombstone_traits {
     }
 };
 
+template <typename T, typename = void> constexpr auto has_tombstone_v = true;
+template <typename T>
+constexpr auto has_tombstone_v<
+    T, std::void_t<typename tombstone_traits<T>::unspecialized>> = false;
+
 template <typename T>
 struct tombstone_traits<T, std::enable_if_t<std::is_floating_point_v<T>>> {
     constexpr auto operator()() const {
@@ -35,6 +40,19 @@ struct tombstone_traits<T, std::enable_if_t<std::is_pointer_v<T>>> {
     constexpr auto operator()() const { return nullptr; }
 };
 
+template <template <typename...> typename L, typename... Ts>
+constexpr auto has_tombstone_v<
+    L<Ts...>,
+    std::void_t<std::enable_if_t<std::is_constructible_v<L<Ts...>, Ts...>>>> =
+    ((sizeof...(Ts) > 0) and ... and has_tombstone_v<Ts>);
+
+template <template <typename...> typename L, typename... Ts>
+struct tombstone_traits<L<Ts...>, std::enable_if_t<has_tombstone_v<L<Ts...>>>> {
+    constexpr auto operator()() const {
+        return L<Ts...>{tombstone_traits<Ts>{}()...};
+    }
+};
+
 template <auto V> struct tombstone_value {
     constexpr auto operator()() const {
         if constexpr (stdx::is_cx_value_v<decltype(V)>) {

test/optional.cpp

@@ -34,6 +34,14 @@ template <> struct stdx::tombstone_traits<S> {
     constexpr auto operator()() const { return S{-1}; }
 };
 
+TEST_CASE("tombstone detection", "[optional]") {
+    STATIC_REQUIRE(stdx::has_tombstone_v<E>);
+    STATIC_REQUIRE(stdx::has_tombstone_v<S>);
+    STATIC_REQUIRE(stdx::has_tombstone_v<float>);
+    STATIC_REQUIRE(stdx::has_tombstone_v<int *>);
+    STATIC_REQUIRE(not stdx::has_tombstone_v<int>);
+}
+
 TEST_CASE("sizeof(optional<T>) == sizeof(T)", "[optional]") {
     using O1 = stdx::optional<E>;
     STATIC_REQUIRE(sizeof(O1) == sizeof(E));
@@ -428,18 +436,31 @@ TEST_CASE("tombstone with non-structural value", "[optional]") {
 }
 #endif
 
-#if __cplusplus >= 202002L
 namespace {
 template <typename T>
-using my_optional = stdx::conditional_t<requires {
-    typename stdx::tombstone_traits<T>::unspecialized;
-}, std::optional<T>, stdx::optional<T>>;
+using my_optional = stdx::conditional_t<stdx::has_tombstone_v<T>,
+                                        stdx::optional<T>, std::optional<T>>;
 } // namespace
 
 TEST_CASE("select optional implementation based on whether tombstone traits "
           "are present",
           "[optional]") {
-    static_assert(std::is_same_v<my_optional<S>, stdx::optional<S>>);
-    static_assert(std::is_same_v<my_optional<int>, std::optional<int>>);
+    STATIC_REQUIRE(std::is_same_v<my_optional<S>, stdx::optional<S>>);
+    STATIC_REQUIRE(std::is_same_v<my_optional<int>, std::optional<int>>);
+}
+
+TEST_CASE("product types have tombstones iff their components do",
+          "[optional]") {
+    STATIC_REQUIRE(not stdx::has_tombstone_v<std::tuple<>>);
+    STATIC_REQUIRE(stdx::has_tombstone_v<std::tuple<E, S>>);
+    STATIC_REQUIRE(not stdx::has_tombstone_v<std::tuple<int>>);
+    STATIC_REQUIRE(stdx::has_tombstone_v<std::pair<E, S>>);
+}
+
+TEST_CASE("tombstone traits for product types come from components",
+          "[optional]") {
+    constexpr auto o = stdx::optional<std::tuple<E, S, float>>{};
+    STATIC_REQUIRE(not o);
+    STATIC_REQUIRE(*o == std::tuple{E{0xffu}, S{-1},
+                                    std::numeric_limits<float>::infinity()});
 }
-#endif