add Result::inspect_error

Author: liam-teale

include/common/result.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "common/result.hpp"
 #define I_WANT_RESULT_IMPL
 #include "common/result_impl.hpp"
 #undef I_WANT_RESULT_IMPL
@@ -165,8 +166,7 @@ class Result<T, Errs...> {
 
         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
+            // compiler will compile a branch where f is invoked with std::monostate
             if constexpr (std::same_as<std::monostate, std::remove_cvref_t<decltype(arg)>>) {
                 throw std::logic_error("This exception is unreachable");
             } else {
@@ -175,6 +175,39 @@ class Result<T, Errs...> {
         }, std::forward<Self>(self).error);
     }
 
+    /**
+     * @brief invoke a callable with the error, if present
+     *
+     * constraints:
+     * - Callable must be invocable with at least 1 of the possible error types
+     * - Callable must return void, if invocable
+     *
+     * @tparam Self deduced self type
+     * @tparam F the type of the callable
+     * @param self the current Result instance
+     * @param f the callable
+     */
+    template<typename Self, typename F>
+        requires traits::AnyInvocable<Self, F, Errs...>
+                 && traits::AllVoid<traits::inspect_error_return_t<Self, F, Errs>...>
+    constexpr void inspect_error(this Self&& self, F&& f) {
+        // if there's no error contained, return
+        if (!self.has_error()) {
+            return;
+        }
+        // otherwise, invoke the callable
+        std::visit([&f](auto&& arg) {
+            // 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 (std::same_as<std::monostate, std::remove_cvref_t<decltype(arg)>>
+                          || !traits::Invocable<Self, F, std::remove_cvref_t<decltype(arg)>>) {
+                throw std::logic_error("This exception is unreachable");
+            } else {
+                std::invoke(f, std::forward<decltype(arg)>(arg));
+            }
+        }, std::forward<Self>(self).error);
+    }
+
     constexpr operator T&() & {
         return value;
     }
@@ -336,14 +369,46 @@ class Result<void, Errs...> {
 
         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
+            // compiler will compile a branch where f is invoked with std::monostate
             if constexpr (std::same_as<std::monostate, std::remove_cvref_t<decltype(arg)>>) {
                 throw std::logic_error("This exception is unreachable");
             } else {
                 return std::invoke(f, std::forward<decltype(arg)>(arg));
             }
         }, std::forward<Self>(self).error);
     }
+
+    /**
+     * @brief invoke a callable with the error, if present
+     *
+     * constraints:
+     * - Callable must be invocable with at least 1 of the possible error types
+     * - Callable must return void, if invocable
+     *
+     * @tparam Self deduced self type
+     * @tparam F the type of the callable
+     * @param self the current Result instance
+     * @param f the callable
+     */
+    template<typename Self, typename F>
+        requires traits::AnyInvocable<Self, F, Errs...>
+                 && traits::AllVoid<traits::inspect_error_return_t<Self, F, Errs>...>
+    constexpr void inspect_error(this Self&& self, F&& f) {
+        // if there's no error contained, return
+        if (!self.has_error()) {
+            return;
+        }
+        // otherwise, invoke the callable
+        std::visit([&f](auto&& arg) {
+            // 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 (std::same_as<std::monostate, std::remove_cvref_t<decltype(arg)>>
+                          || !traits::Invocable<Self, F, std::remove_cvref_t<decltype(arg)>>) {
+                throw std::logic_error("This exception is unreachable");
+            } else {
+                std::invoke(f, std::forward<decltype(arg)>(arg));
+            }
+        }, std::forward<Self>(self).error);
+    }
 };
 } // namespace zest

include/common/result_impl.hpp

@@ -242,6 +242,14 @@ inline constexpr bool all_same_v<T, Ts...> =
 template<typename... Ts>
 concept AllSame = all_same_v<Ts...>;
 
+/**
+ * @brief Check whether all types in a pack are void
+ *
+ * @tparam Ts types to check
+ */
+template<typename... Ts>
+concept AllVoid = true && ((std::same_as<void, Ts> || std::same_as<ignored_type, Ts>) && ...);
+
 /**
  * @brief Find the first type in a typename pack that satisfies the given condition
  *
@@ -308,17 +316,25 @@ template<typename R, typename F, typename E>
 concept Invocable = std::invocable<F, decltype((std::get<E>(std::declval<R>().error)))>;
 
 /**
- * @brief check whether a callable is invocable with any of the given argument types
- *
- * @note Result::or_else helper
+ * @brief check whether a callable is invocable with all of the given argument types
  *
  * @tparam R the Result
  * @tparam F the callable
- * @tparam Es the possible argument types passed to the callable
+ * @tparam Es the possible error types passed to the callable
  */
 template<typename R, typename F, typename... Es>
 concept AllInvocable = (Invocable<R, F, Es> && ...);
 
+/**
+ * @brief check whether a callable is invocable with any of the given argument types
+ *
+ * @tparam R the Result
+ * @tparam F the callable
+ * @tparam Es the possible error types passed to the callable
+ */
+template<typename R, typename F, typename... Es>
+concept AnyInvocable = (Invocable<R, F, Es> || ...);
+
 /**
  * @brief check whether a callable is invocable given the Result and argument type
  *
@@ -386,6 +402,18 @@ using and_then_return_t = std::invoke_result_t<F, decltype((std::declval<R>().va
 template<typename R, typename F, typename E>
 using or_else_return_t = invoke_result_t<F, decltype((std::get<E>(std::declval<R>().error)))>;
 
+/**
+ * @brief get the return type of the callable passed to Result::inspect_error
+ *
+ * @note if the callable is not invocable, the type is ignored_type
+ *
+ * @tparam R the Result
+ * @tparam F the callable
+ * @tparam E the callable argument
+ */
+template<typename R, typename F, typename E>
+using inspect_error_return_t = or_else_return_t<R, F, E>;
+
 /**
  * @brief check whether the callable return types are all Result
  *