implement Result::or_default

Author: liam-teale

include/common/result.hpp

@@ -175,6 +175,25 @@ class Result<T, Errs...> {
         }, std::forward<Self>(self).error);
     }
 
+    /**
+     * @brief If the Result contains an error, return the given value, otherwise return the value of
+     * the Result
+     *
+     * @tparam Self deduced self type
+     * @tparam U default value type. Must be convertible to Result value type
+     * @param self the current Result instance
+     * @param val the value to use if self contains an error
+     */
+    template<typename Self, typename U>
+        requires std::convertible_to<U, T>
+    constexpr T or_default(this Self&& self, U&& val) {
+        if (self.has_error()) {
+            return std::forward<U>(val);
+        } else {
+            return std::forward<Self>(self);
+        }
+    }
+
     /**
      * @brief invoke a callable with the error, if present
      *
@@ -198,7 +217,8 @@ class Result<T, Errs...> {
         // 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
+            // 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");
@@ -302,9 +322,9 @@ class Result<void, Errs...> {
     /**
      * @brief and_then monadic function
      *
-     * The callable must be able to take the perfectly-forwarded value of this Result instance as an
-     * argument. The callable must be able to return any error passed to it. The callable must
-     * return a Result.
+     * The callable must be able to take the perfectly-forwarded value of this Result instance
+     * as an argument. The callable must be able to return any error passed to it. The callable
+     * must return a Result.
      *
      * @tparam Self deduced self type
      * @tparam F the type of the callable
@@ -319,8 +339,9 @@ class Result<void, Errs...> {
         // if there is an error, return said error immediately
         if (self.has_error()) {
             return std::visit([](auto&& arg) -> std::invoke_result_t<F> {
-                // even though this conditional is impossible, it's necessary to stop the compiler
-                // from thinking that ReturnType could be constructed with std::monostate
+                // even though this conditional is impossible, it's necessary to stop the
+                // compiler from thinking that ReturnType could be constructed 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 {
@@ -401,7 +422,8 @@ class Result<void, Errs...> {
         // 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
+            // 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");