Fix the MSVC/Clang build even more

include/continuable/continuable-result.hpp

@@ -95,22 +95,17 @@ class result {
   detail::container::flat_variant<value_t, exception_t> variant_;
 
 public:
-  template <typename A = detail::traits::identity<>,
-            // I know this is a little bit hacky but it's a working version
-            // of a default constructor that is not present when the class is
-            // instantiated with zero arguments.
-            std::enable_if_t<((sizeof(A) * 0 + sizeof...(T)) > 0)>* = nullptr,
-            std::enable_if_t<
-                std::is_same<A, detail::traits::identity<>>::value>* = nullptr>
-  explicit result(A = {}) {
-  }
-  explicit result(result const&) = default;
-  explicit result(result&&) = default;
+  result() = default;
+  result(result const&) = default;
+  result(result&&) = default;
   result& operator=(result const&) = default;
   result& operator=(result&&) = default;
   ~result() = default;
 
-  explicit result(T... values) : variant_(trait::wrap(std::move(values)...)) {
+  template <typename... Args,
+            decltype(trait::wrap(std::declval<Args>()...))* = nullptr>
+  explicit result(Args&&... values)
+      : variant_(trait::wrap(std::forward<Args>(values)...)) {
   }
   explicit result(exception_t exception) : variant_(std::move(exception)) {
   }
@@ -192,7 +187,7 @@ template <>
 struct is_result<exceptional_result> : std::true_type {};
 
 template <typename... T>
-constexpr auto make_result(T&&... values) {
+auto make_result(T&&... values) {
   return result<detail::traits::unrefcv_t<T>...>(std::forward<T>(values)...);
 }
 

include/continuable/detail/utility/result-trait.hpp

@@ -61,7 +61,8 @@ template <typename First, typename Second, typename... Rest>
 struct result_trait<First, Second, Rest...> {
   using value_t = std::tuple<First, Second, Rest...>;
 
-  static auto wrap(First first, Second second, Rest... rest) {
+  static std::tuple<First, Second, Rest...> wrap(First first, Second second,
+                                                 Rest... rest) {
     return std::make_tuple(std::move(first), std::move(second),
                            std::move(rest)...);
   }

test/unit-test/single/test-continuable-result.cpp

@@ -29,6 +29,7 @@
 
 using cti::exception_t;
 using cti::result;
+using cti::make_result;
 
 static int const CANARY = 373671;
 
@@ -67,6 +68,8 @@ TYPED_TEST(result_all_tests, is_default_constructible) {
   result<> e1;
   result<int> e2;
   result<int, int> e3;
+
+  auto empty = make_result();
 }
 
 TYPED_TEST(result_all_tests, can_carry_errors) {