Result::or_else callable must always be invocable

Author: liam-teale

include/common/result.hpp

@@ -280,7 +280,7 @@ concept Invocable = std::invocable<F, decltype((std::get<E>(std::declval<R>().er
  * @tparam Es the possible argument types passed to the callable
  */
 template<typename R, typename F, typename... Es>
-concept AnyInvocable = (Invocable<R, F, Es> || ...);
+concept AllInvocable = (Invocable<R, F, Es> && ...);
 
 /**
  * @brief check whether a callable is invocable given the Result and argument type

include/common/result_impl.hpp

@@ -131,7 +131,7 @@ class Result {
      * expressions, as fold expressions significantly complicates error messages
      *
      * constraints:
-     * - Callable must be invocable with at least one error type as an argument
+     * - Callable must be invocable with all error types as arguments
      * - If invocable, the callable must always return the same type regardless of argument type
      * - If invocable, the callable must return a Result
      * - The Result returned by the callable must have the same value type
@@ -142,53 +142,29 @@ class Result {
      * @param f the callable
      */
     template<typename Self, typename F>
-        requires traits::AnyInvocable<Self, F, Errs...>
+        requires traits::AllInvocable<Self, F, Errs...>
                  // the callable must always return the same type (if it's invocable)
                  && traits::AllSame<traits::or_else_return_t<Self, F, Errs>...>
                  // the callable must return a Result (if it's invocable)
                  && traits::AllResult<Self, F, Errs...>
                  // the Result returned by the callable must have the same value type
                  && traits::AllValueTypeMatch<Self, traits::or_else_return_t<Self, F, Errs>...>
     constexpr auto or_else(this Self&& self, F&& f) {
-        using namespace traits;
-
-        // the return type is the same as the return type of the callable, unless the callable
-        // returns void. In that case, the return type is Self with cv-refs removed
-        using CallableReturnType =
-            first_type_that_satisfies_t<invocable_indirect_v<F, Self>, Errs...>;
-        using ReturnType = std::conditional_t<
-            IsResult<CallableReturnType>,
-            CallableReturnType,
-            std::remove_cvref_t<Self>>;
+        using ReturnType = std::invoke_result_t<
+            F,
+            decltype((std::get<std::tuple_element_t<0, std::tuple<Errs...>>>(std::declval<Self>()
+                                                                                 .error)))>;
 
         // if there isn't an error, return the value
         if (!self.has_error()) {
             return ReturnType(std::forward<Self>(self).value);
         }
 
-        // if the callable returns void
-        if constexpr (std::same_as<void, CallableReturnType>) {
-            return std::visit([&f](auto&& arg) -> ReturnType {
-                // even though this condition is impossible, it's necessary. Otherwise the
-                // compiler will compile a branch where f is invoked with an unsupported argument
-                // type
-                if constexpr (!Invocable<Self, F, decltype((arg))>
-                              || std::same_as<std::monostate, std::remove_cvref_t<decltype(arg)>>) {
-                    throw std::logic_error("This exception is unreachable");
-                } else {
-                    std::invoke(f, std::forward<decltype(arg)>(arg));
-                    return std::forward<decltype(arg)>(arg);
-                }
-            }, std::forward<Self>(self).error);
-        }
-
-        // if the callable returns Result
         return std::visit([&f](auto&& arg) -> ReturnType {
             // even though this condition is impossible, it's necessary. Otherwise the
             // compiler will compile a branch where f is invoked with an unsupported argument
             // type
-            if constexpr (!Invocable<Self, F, decltype((arg))>
-                          || std::same_as<std::monostate, std::remove_cvref_t<decltype(arg)>>) {
+            if constexpr (std::same_as<std::monostate, std::remove_cvref_t<decltype(arg)>>) {
                 throw std::logic_error("This exception is unreachable");
             } else {
                 std::invoke(f, std::forward<decltype(arg)>(arg));
@@ -331,7 +307,7 @@ class Result<void, Errs...> {
      * expressions, as fold expressions significantly complicates error messages
      *
      * constraints:
-     * - Callable must be invocable with at least one error type as an argument
+     * - Callable must be invocable with any error type as an argument
      * - If invocable, the callable must always return the same type regardless of argument type
      * - If invocable, the callable must return a Result
      * - The Result returned by the callable must have the same value type
@@ -342,53 +318,28 @@ class Result<void, Errs...> {
      * @param f the callable
      */
     template<typename Self, typename F>
-        requires traits::AnyInvocable<Self, F, Errs...>
+        requires traits::AllInvocable<Self, F, Errs...>
                  // the callable must always return the same type (if it's invocable)
                  && traits::AllSame<traits::or_else_return_t<Self, F, Errs>...>
                  // the callable must return a Result (if it's invocable)
                  && traits::AllResult<Self, F, Errs...>
                  // the Result returned by the callable must have the same value type
                  && traits::AllValueTypeMatch<Self, traits::or_else_return_t<Self, F, Errs>...>
     constexpr auto or_else(this Self&& self, F&& f) {
-        using namespace traits;
-
-        // the return type is the same as the return type of the callable, unless the callable
-        // returns void. In that case, the return type is Self with cv-refs removed
-        using CallableReturnType =
-            first_type_that_satisfies_t<invocable_indirect_v<F, Self>, Errs...>;
-        using ReturnType = std::conditional_t<
-            IsResult<CallableReturnType>,
-            CallableReturnType,
-            std::remove_cvref_t<Self>>;
-
+        using ReturnType = std::invoke_result_t<
+            F,
+            decltype((std::get<std::tuple_element_t<0, std::tuple<Errs...>>>(std::declval<Self>()
+                                                                                 .error)))>;
         // if there isn't an error, return
         if (!self.has_error()) {
             return ReturnType();
         }
 
-        // if the callable returns void
-        if constexpr (std::same_as<void, CallableReturnType>) {
-            return std::visit([&f](auto&& arg) -> ReturnType {
-                // even though this condition is impossible, it's necessary. Otherwise the
-                // compiler will compile a branch where f is invoked with an unsupported argument
-                // type
-                if constexpr (!Invocable<Self, F, decltype((arg))>
-                              || std::same_as<std::monostate, std::remove_cvref_t<decltype(arg)>>) {
-                    throw std::logic_error("This exception is unreachable");
-                } else {
-                    std::invoke(f, std::forward<decltype(arg)>(arg));
-                    return std::forward<decltype(arg)>(arg);
-                }
-            }, std::forward<Self>(self).error);
-        }
-
-        // if the callable returns Result
         return std::visit([&f](auto&& arg) -> ReturnType {
             // even though this condition is impossible, it's necessary. Otherwise the
             // compiler will compile a branch where f is invoked with an unsupported argument
             // type
-            if constexpr (!Invocable<Self, F, decltype((arg))>
-                          || std::same_as<std::monostate, std::remove_cvref_t<decltype(arg)>>) {
+            if constexpr (std::same_as<std::monostate, std::remove_cvref_t<decltype(arg)>>) {
                 throw std::logic_error("This exception is unreachable");
             } else {
                 std::invoke(f, std::forward<decltype(arg)>(arg));