🎨 Make multi-arg transform work on std::optional

Problem:
- Sometimes we want to use `std::optional` (not just `stdx::optional`) as an
  applicative functor.

Solution:
- Make multi-arg `transform` work on `std::optional` as well as `stdx::optional`.

Author: elbeno

include/stdx/optional.hpp

@@ -318,21 +318,30 @@ template <typename T, typename TS = tombstone_traits<T>> class optional {
 
 template <typename T> optional(T) -> optional<T>;
 
+namespace detail {
+template <typename T>
+constexpr bool optional_like =
+    stdx::is_specialization_of_v<stdx::remove_cvref_t<T>, optional> or
+    stdx::is_specialization_of_v<stdx::remove_cvref_t<T>, std::optional>;
+
+template <typename R, template <typename> typename O, typename... Ts>
+auto convert_optional(O<Ts> const &...) -> O<R>;
+} // namespace detail
+
 template <typename F, typename... Ts,
-          typename = std::enable_if_t<
-              (... and stdx::is_specialization_of_v<stdx::remove_cvref_t<Ts>,
-                                                    optional>)>>
+          typename = std::enable_if_t<(... and detail::optional_like<Ts>)>>
 constexpr auto transform(F &&f, Ts &&...ts) {
     using func_t = stdx::remove_cvref_t<F>;
     using R = std::invoke_result_t<
         func_t,
         forward_like_t<Ts, typename stdx::remove_cvref_t<Ts>::value_type>...>;
+    using O = decltype(detail::convert_optional<R>(ts...));
     if ((... and ts.has_value())) {
-        return optional<R>{with_result_of{[&] {
+        return O{with_result_of{[&] {
             return std::forward<F>(f)(std::forward<Ts>(ts).value()...);
         }}};
     }
-    return optional<R>{};
+    return O{};
 }
 } // namespace v1
 } // namespace stdx

test/optional.cpp

@@ -334,6 +334,16 @@ TEST_CASE("transform (multi-arg)", "[optional]") {
     auto o3 =
         transform([](S &x, S &y) { return S{x.value + y.value}; }, o1, o2);
     CHECK(o3->value == 59);
+    STATIC_REQUIRE(std::is_same_v<decltype(o3), stdx::optional<S>>);
+}
+
+TEST_CASE("multi-arg transform works on std::optional", "[optional]") {
+    auto o1 = std::optional<S>{17};
+    auto o2 = std::optional<S>{42};
+    auto o3 = stdx::transform([](S &x, S &y) { return S{x.value + y.value}; },
+                              o1, o2);
+    CHECK(o3->value == 59);
+    STATIC_REQUIRE(std::is_same_v<decltype(o3), std::optional<S>>);
 }
 
 namespace {