feat(error): add capture function to convert exception to std::expected

Author: Hackerl

include/zero/error.h

@@ -4,6 +4,7 @@
 #include <array>
 #include <utility>
 #include <expected>
+#include <exception>
 #include <system_error>
 
 #if __has_include(<stacktrace>)
@@ -687,6 +688,25 @@ namespace zero::error {
         else
             return *std::move(expected);
     }
+
+    template<typename F>
+    std::expected<std::invoke_result_t<F>, std::exception_ptr>
+    capture(F &&f) {
+        using T = std::invoke_result_t<F>;
+
+        try {
+            if constexpr (std::is_void_v<T>) {
+                f();
+                return {};
+            }
+            else {
+                return f();
+            }
+        }
+        catch (const std::exception &) {
+            return std::unexpected{std::current_exception()};
+        }
+    }
 }
 
 #endif //ZERO_ERROR_H

test/error.cpp

@@ -1,5 +1,6 @@
 #include "catch_extensions.h"
 #include <zero/error.h>
+#include <catch2/matchers/catch_matchers_all.hpp>
 
 namespace {
     std::string stringify(const int value) {
@@ -447,3 +448,83 @@ TEST_CASE("custom extended error condition defined in class", "[error]") {
         REQUIRE(condition == static_cast<ErrorTransformerExWrapper::ErrorTransformerEx>(ETIMEDOUT));
     }
 }
+
+TEST_CASE("guard", "[error]") {
+    SECTION("void") {
+        SECTION("success") {
+            REQUIRE_NOTHROW(zero::error::guard(std::expected<void, std::error_code>{}));
+        }
+
+        SECTION("failure") {
+            REQUIRE_THROWS_MATCHES(
+                zero::error::guard(
+                    std::expected<void, std::error_code>{std::unexpect, make_error_code(std::errc::invalid_argument)}
+                ),
+                std::system_error,
+                Catch::Matchers::Predicate<std::system_error>([](const auto &error) {
+                    return error.code() == std::errc::invalid_argument;
+                })
+            );
+        }
+    }
+
+    SECTION("not void") {
+        SECTION("success") {
+            REQUIRE(zero::error::guard(std::expected<int, std::error_code>{0}) == 0);
+        }
+
+        SECTION("failure") {
+            REQUIRE_THROWS_MATCHES(
+                zero::error::guard(
+                    std::expected<int, std::error_code>{std::unexpect, make_error_code(std::errc::invalid_argument)}
+                ),
+                std::system_error,
+                Catch::Matchers::Predicate<std::system_error>([](const auto &error) {
+                    return error.code() == std::errc::invalid_argument;
+                })
+            );
+        }
+    }
+}
+
+TEST_CASE("capture", "[error]") {
+    SECTION("void") {
+        SECTION("success") {
+            REQUIRE(zero::error::capture([] {}));
+        }
+
+        SECTION("failure") {
+            const auto result = zero::error::capture([] {
+                throw std::system_error{make_error_code(std::errc::invalid_argument)};
+            });
+            REQUIRE_FALSE(result);
+            REQUIRE_THROWS_MATCHES(
+                std::rethrow_exception(result.error()),
+                std::system_error,
+                Catch::Matchers::Predicate<std::system_error>([](const auto &error) {
+                    return error.code() == std::errc::invalid_argument;
+                })
+            );
+        }
+    }
+
+    SECTION("not void") {
+        SECTION("success") {
+            REQUIRE(zero::error::capture([] { return 0; }) == 0);
+        }
+
+        SECTION("failure") {
+            const auto result = zero::error::capture([]() -> int {
+                throw std::system_error{make_error_code(std::errc::invalid_argument)};
+            });
+            REQUIRE_FALSE(result);
+            REQUIRE_THROWS_MATCHES(
+                std::rethrow_exception(result.error()),
+                std::system_error,
+                Catch::Matchers::Predicate<std::system_error>([](const auto &error) {
+                    return error.code() == std::errc::invalid_argument;
+                })
+            );
+        }
+    }
+}

test/utility.cpp

@@ -19,7 +19,7 @@ TEST_CASE("flatten std::expected", "[utility]") {
         }
 
         SECTION("has error") {
-            REQUIRE_ERROR(zero::flatten(std::expected<std::expected<void, short>, int>{std::unexpected{-1}}), -1);
+            REQUIRE_ERROR(zero::flatten(std::expected<std::expected<void, short>, int>{std::unexpect, -1}), -1);
         }
     }
 
@@ -29,7 +29,7 @@ TEST_CASE("flatten std::expected", "[utility]") {
         }
 
         SECTION("has error") {
-            REQUIRE_ERROR(zero::flatten(std::expected<std::expected<int, short>, int>{std::unexpected{-1}}), -1);
+            REQUIRE_ERROR(zero::flatten(std::expected<std::expected<int, short>, int>{std::unexpect, -1}), -1);
         }
     }
 }
@@ -42,7 +42,7 @@ TEST_CASE("flatten std::expected with error type", "[utility]") {
 
         SECTION("has error") {
             REQUIRE_ERROR(
-                zero::flattenWith<long>(std::expected<std::expected<void, short>, int>{std::unexpected{-1}}),
+                zero::flattenWith<long>(std::expected<std::expected<void, short>, int>{std::unexpect, -1}),
                 -1
             );
         }
@@ -55,9 +55,7 @@ TEST_CASE("flatten std::expected with error type", "[utility]") {
 
         SECTION("has error") {
             REQUIRE_ERROR(
-                zero::flattenWith<long>(std::expected<std::expected<int, short>, int>{
-                    std::unexpected{-1}
-                }),
+                zero::flattenWith<long>(std::expected<std::expected<int, short>, int>{std::unexpect, -1}),
                 -1
             );
         }
@@ -70,7 +68,7 @@ TEST_CASE("extract std::expected", "[utility]") {
     }
 
     SECTION("has error") {
-        REQUIRE_FALSE(zero::extract(std::expected<int, int>{std::unexpected{-1}}));
+        REQUIRE_FALSE(zero::extract(std::expected<int, int>{std::unexpect, -1}));
     }
 }
 
@@ -86,7 +84,7 @@ TEST_CASE("transpose std::expected", "[utility]") {
     }
 
     SECTION("has error") {
-        REQUIRE(zero::transpose(std::expected<std::optional<int>, int>{std::unexpected{-1}}) == std::unexpected{-1});
+        REQUIRE(zero::transpose(std::expected<std::optional<int>, int>{std::unexpect, -1}) == std::unexpected{-1} );
     }
 }