Add compose_first_error_and_result, closes #265 (#329)

Pairs a possibly-failing side-effecting function (e.g. logging,
metrics, validation, audit, cache lookup) with a regular
result-returning function. Both are called on the same input;
the second runs regardless of whether the first one failed. The
error of the first is preserved as a Maybe alongside the second's
unmodified Result.

Author: Dobiasd

include/fplus/result.hpp

@@ -346,4 +346,25 @@ auto compose_result(Callables&&... callables)
     return internal::compose_binary_lift(bind_result,
         std::forward<Callables>(callables)...);
 }
+
+// API search type: compose_first_error_and_result : ((a -> Result b c), (a -> Result d e)) -> (a -> (Maybe c, Result d e))
+// Run two result-returning functions on the same input independently.
+// The first contributes only its potential error (as a Maybe), its Ok
+// value is discarded. The second's result is forwarded unchanged.
+// The second function is always called, regardless of whether the first
+// one failed. Useful for ancillary checks (logging, metrics, validation,
+// audit, cache lookup, ...) that may fail but should not block the main
+// computation.
+template <typename First, typename Second>
+auto compose_first_error_and_result(First first, Second second)
+{
+    return [first = std::move(first), second = std::move(second)](const auto& x) {
+        auto first_result = internal::invoke(first, x);
+        using FirstErr = typename std::decay_t<decltype(first_result)>::error_t;
+        auto first_err = is_error(first_result)
+            ? just<FirstErr>(unsafe_get_error(first_result))
+            : nothing<FirstErr>();
+        return std::make_pair(std::move(first_err), internal::invoke(second, x));
+    };
+}
 } // namespace fplus

include_all_in_one/include/fplus/fplus.hpp

@@ -5719,6 +5719,27 @@ auto compose_result(Callables&&... callables)
     return internal::compose_binary_lift(bind_result,
         std::forward<Callables>(callables)...);
 }
+
+// API search type: compose_first_error_and_result : ((a -> Result b c), (a -> Result d e)) -> (a -> (Maybe c, Result d e))
+// Run two result-returning functions on the same input independently.
+// The first contributes only its potential error (as a Maybe), its Ok
+// value is discarded. The second's result is forwarded unchanged.
+// The second function is always called, regardless of whether the first
+// one failed. Useful for ancillary checks (logging, metrics, validation,
+// audit, cache lookup, ...) that may fail but should not block the main
+// computation.
+template <typename First, typename Second>
+auto compose_first_error_and_result(First first, Second second)
+{
+    return [first = std::move(first), second = std::move(second)](const auto& x) {
+        auto first_result = internal::invoke(first, x);
+        using FirstErr = typename std::decay_t<decltype(first_result)>::error_t;
+        auto first_err = is_error(first_result)
+            ? just<FirstErr>(unsafe_get_error(first_result))
+            : nothing<FirstErr>();
+        return std::make_pair(std::move(first_err), internal::invoke(second, x));
+    };
+}
 } // namespace fplus
 
 #include <algorithm>

test/result_test.cpp

@@ -116,6 +116,34 @@ TEST_CASE("result_test - compose_result")
     REQUIRE_EQ(squareSumResult(5, 5), (ok<int, std::string>(100)));
 }
 
+TEST_CASE("result_test - compose_first_error_and_result")
+{
+    using namespace fplus;
+
+    const auto check_ok = [](int) {
+        return ok<int, std::string>(0);
+    };
+    const auto check_fail = [](int) {
+        return error<int, std::string>("check failed");
+    };
+    const auto run = [](int x) {
+        return x < 0
+            ? error<int, std::string>("negative input")
+            : ok<int, std::string>(x * x);
+    };
+
+    using Pair = std::pair<maybe<std::string>, result<int, std::string>>;
+
+    REQUIRE_EQ(compose_first_error_and_result(check_ok, run)(3),
+        Pair(nothing<std::string>(), ok<int, std::string>(9)));
+    REQUIRE_EQ(compose_first_error_and_result(check_ok, run)(-1),
+        Pair(nothing<std::string>(), error<int, std::string>("negative input")));
+    REQUIRE_EQ(compose_first_error_and_result(check_fail, run)(3),
+        Pair(just<std::string>("check failed"), ok<int, std::string>(9)));
+    REQUIRE_EQ(compose_first_error_and_result(check_fail, run)(-1),
+        Pair(just<std::string>("check failed"), error<int, std::string>("negative input")));
+}
+
 TEST_CASE("result_test - lift")
 {
     using namespace fplus;