diff options
Diffstat (limited to 'src/base/result.h')
| -rw-r--r-- | src/base/result.h | 983 |
1 files changed, 983 insertions, 0 deletions
diff --git a/src/base/result.h b/src/base/result.h new file mode 100644 index 0000000..27500de --- /dev/null +++ b/src/base/result.h @@ -0,0 +1,983 @@ +/* + Mathieu Stefani, 03 mai 2016 + + This header provides a Result type that can be used to replace exceptions in code + that has to handle error. + + Result<T, E> can be used to return and propagate an error to the caller. Result<T, E> is an algebraic + data type that can either Ok(T) to represent success or Err(E) to represent an error. +*/ + +#pragma once + +#include <stdio.h> +#include <exception> +#include <functional> +#include <type_traits> + +namespace types { + template<typename T> + struct Ok { + Ok(const T& val) : val(val) { } + Ok(T&& val) : val(std::move(val)) { } + + T val; + }; + + template<> + struct Ok<void> { }; + + template<typename E> + struct Err { + Err(const E& val) : val(val) { } + Err(E&& val) : val(std::move(val)) { } + + E val; + }; + + template<> + struct Err<void> { }; +}; + +template<typename T, typename CleanT = typename std::decay<T>::type> +types::Ok<CleanT> Ok(T&& val) { + return types::Ok<CleanT>(std::forward<T>(val)); +} + +inline types::Ok<void> Ok() { + return {}; +} + +template<typename E, typename CleanE = typename std::decay<E>::type> +types::Err<CleanE> Err(E&& val) { + return types::Err<CleanE>(std::forward<E>(val)); +} + +inline types::Err<void> Err() { + return {}; +} + +template<typename T, typename E> struct Result; + +namespace details { + +template<typename ...> struct void_t { typedef void type; }; + +namespace impl { + template<typename Func> struct result_of; + + template<typename Ret, typename Cls, typename... Args> + struct result_of<Ret (Cls::*)(Args...)> : public result_of<Ret (Args...)> { }; + + template<typename Ret, typename... Args> + struct result_of<std::function<Ret (Args...)>> { + typedef Ret type; + }; +} + +template<typename Func> +struct result_of : public impl::result_of<decltype(&Func::operator())> { }; + +template<typename Ret, typename Cls, typename... Args> +struct result_of<Ret (Cls::*) (Args...) const> { + typedef Ret type; +}; + +template<typename Ret, typename... Args> +struct result_of<Ret (*)(Args...)> { + typedef Ret type; +}; + +template<typename R> +struct ResultOkType { typedef typename std::decay<R>::type type; }; + +template<typename T, typename E> +struct ResultOkType<Result<T, E>> { + typedef T type; +}; + +template<typename R> +struct ResultErrType { typedef R type; }; + +template<typename T, typename E> +struct ResultErrType<Result<T, E>> { + typedef typename std::remove_reference<E>::type type; +}; + +template<typename R> struct IsResult : public std::false_type { }; +template<typename T, typename E> +struct IsResult<Result<T, E>> : public std::true_type { }; + +namespace ok { + +namespace impl { + +template<typename T> struct Map; + +template<typename Ret, typename Cls, typename Arg> +struct Map<Ret (Cls::*)(Arg) const> : public Map<Ret (Arg)> { }; + +template<typename Ret, typename Cls, typename Arg> +struct Map<Ret (Cls::*)(Arg)> : public Map<Ret (Arg)> { }; + +// General implementation +template<typename Ret, typename Arg> +struct Map<Ret (Arg)> { + + static_assert(!IsResult<Ret>::value, + "Can not map a callback returning a Result, use then instead"); + + template<typename T, typename E, typename Func> + static Result<Ret, E> map(const Result<T, E>& result, Func func) { + + static_assert( + std::is_same<T, Arg>::value || + std::is_convertible<T, Arg>::value, + "Incompatible types detected"); + + if (result.isOk()) { + auto res = func(result.storage().template get<T>()); + return types::Ok<Ret>(std::move(res)); + } + + return types::Err<E>(result.storage().template get<E>()); + } +}; + +// Specialization for callback returning void +template<typename Arg> +struct Map<void (Arg)> { + + template<typename T, typename E, typename Func> + static Result<void, E> map(const Result<T, E>& result, Func func) { + + if (result.isOk()) { + func(result.storage().template get<T>()); + return types::Ok<void>(); + } + + return types::Err<E>(result.storage().template get<E>()); + } +}; + +// Specialization for a void Result +template<typename Ret> +struct Map<Ret (void)> { + + template<typename T, typename E, typename Func> + static Result<Ret, E> map(const Result<T, E>& result, Func func) { + static_assert(std::is_same<T, void>::value, + "Can not map a void callback on a non-void Result"); + + if (result.isOk()) { + auto ret = func(); + return types::Ok<Ret>(std::move(ret)); + } + + return types::Err<E>(result.storage().template get<E>()); + } +}; + +// Specialization for callback returning void on a void Result +template<> +struct Map<void (void)> { + + template<typename T, typename E, typename Func> + static Result<void, E> map(const Result<T, E>& result, Func func) { + static_assert(std::is_same<T, void>::value, + "Can not map a void callback on a non-void Result"); + + if (result.isOk()) { + func(); + return types::Ok<void>(); + } + + return types::Err<E>(result.storage().template get<E>()); + } +}; + +// General specialization for a callback returning a Result +template<typename U, typename E, typename Arg> +struct Map<Result<U, E> (Arg)> { + + template<typename T, typename Func> + static Result<U, E> map(const Result<T, E>& result, Func func) { + static_assert( + std::is_same<T, Arg>::value || + std::is_convertible<T, Arg>::value, + "Incompatible types detected"); + + if (result.isOk()) { + auto res = func(result.storage().template get<T>()); + return res; + } + + return types::Err<E>(result.storage().template get<E>()); + } +}; + +// Specialization for a void callback returning a Result +template<typename U, typename E> +struct Map<Result<U, E> (void)> { + + template<typename T, typename Func> + static Result<U, E> map(const Result<T, E>& result, Func func) { + static_assert(std::is_same<T, void>::value, "Can not call a void-callback on a non-void Result"); + + if (result.isOk()) { + auto res = func(); + return res; + } + + return types::Err<E>(result.storage().template get<E>()); + } + +}; + +} // namespace impl + +template<typename Func> struct Map; + +template<typename Ret, typename... Args> +struct Map<Ret (*) (Args...)> : public impl::Map<Ret (Args...)> { }; + +template<typename Ret, typename... Args> +struct Map<Ret (Args...)> : public impl::Map<Ret (Args...)> { }; + +template<typename Ret, typename Cls, typename... Args> +struct Map<Ret (Cls::*) (Args...)> : public impl::Map<Ret (Args...)> { }; + +template<typename Ret, typename Cls, typename... Args> +struct Map<Ret (Cls::*) (Args...) const> : public impl::Map<Ret (Args...)> { }; + +template<typename Ret, typename... Args> +struct Map<std::function<Ret (Args...)>> : public impl::Map<Ret (Args...)> { }; + +} // namespace ok + + +namespace err { + +namespace impl { + +template<typename T> struct Map; + +template<typename Ret, typename Cls, typename Arg> +struct Map<Ret (Cls::*)(Arg) const> { + + static_assert(!IsResult<Ret>::value, + "Can not map a callback returning a Result, use orElse instead"); + + template<typename T, typename E, typename Func> + static Result<T, Ret> map(const Result<T, E>& result, Func func) { + if (result.isErr()) { + auto res = func(result.storage().template get<E>()); + return types::Err<Ret>(res); + } + + return types::Ok<T>(result.storage().template get<T>()); + } + + template<typename E, typename Func> + static Result<void, Ret> map(const Result<void, E>& result, Func func) { + if (result.isErr()) { + auto res = func(result.storage().template get<E>()); + return types::Err<Ret>(res); + } + + return types::Ok<void>(); + } + + +}; + +} // namespace impl + +template<typename Func> struct Map : public impl::Map<decltype(&Func::operator())> { }; + +} // namespace err; + +namespace And { + +namespace impl { + + template<typename Func> struct Then; + + template<typename Ret, typename... Args> + struct Then<Ret (*)(Args...)> : public Then<Ret (Args...)> { }; + + template<typename Ret, typename Cls, typename... Args> + struct Then<Ret (Cls::*)(Args...)> : public Then<Ret (Args...)> { }; + + template<typename Ret, typename Cls, typename... Args> + struct Then<Ret (Cls::*)(Args...) const> : public Then<Ret (Args...)> { }; + + template<typename Ret, typename Arg> + struct Then<Ret (Arg)> { + static_assert(std::is_same<Ret, void>::value, + "then() should not return anything, use map() instead"); + + template<typename T, typename E, typename Func> + static Result<T, E> then(const Result<T, E>& result, Func func) { + if (result.isOk()) { + func(result.storage().template get<T>()); + } + return result; + } + }; + + template<typename Ret> + struct Then<Ret (void)> { + static_assert(std::is_same<Ret, void>::value, + "then() should not return anything, use map() instead"); + + template<typename T, typename E, typename Func> + static Result<T, E> then(const Result<T, E>& result, Func func) { + static_assert(std::is_same<T, void>::value, "Can not call a void-callback on a non-void Result"); + + if (result.isOk()) { + func(); + } + + return result; + } + }; + + +} // namespace impl + +template<typename Func> +struct Then : public impl::Then<decltype(&Func::operator())> { }; + +template<typename Ret, typename... Args> +struct Then<Ret (*) (Args...)> : public impl::Then<Ret (Args...)> { }; + +template<typename Ret, typename Arg> +struct Then<Ret (Arg)> : public impl::Then<Ret (Arg)> { }; + +template<typename Ret, typename Cls, typename... Args> +struct Then<Ret (Cls::*)(Args...)> : public impl::Then<Ret (Args...)> { }; + +template<typename Ret, typename Cls, typename... Args> +struct Then<Ret (Cls::*)(Args...) const> : public impl::Then<Ret (Args...)> { }; + +template<typename Ret, typename... Args> +struct Then<std::function<Ret (Args...)>> : public impl::Then<Ret (Args...)> { }; + +} // namespace And + +namespace Or { + +namespace impl { + + template<typename Func> struct Else; + + template<typename Ret, typename... Args> + struct Else<Ret (*)(Args...)> : public Else<Ret (Args...)> { }; + + template<typename Ret, typename Cls, typename... Args> + struct Else<Ret (Cls::*)(Args...)> : public Else<Ret (Args...)> { }; + + template<typename Ret, typename Cls, typename... Args> + struct Else<Ret (Cls::*)(Args...) const> : public Else<Ret (Args...)> { }; + + template<typename T, typename F, typename Arg> + struct Else<Result<T, F> (Arg)> { + + template<typename E, typename Func> + static Result<T, F> orElse(const Result<T, E>& result, Func func) { + static_assert( + std::is_same<E, Arg>::value || + std::is_convertible<E, Arg>::value, + "Incompatible types detected"); + + if (result.isErr()) { + auto res = func(result.storage().template get<E>()); + return res; + } + + return types::Ok<T>(result.storage().template get<T>()); + } + + template<typename E, typename Func> + static Result<void, F> orElse(const Result<void, E>& result, Func func) { + if (result.isErr()) { + auto res = func(result.storage().template get<E>()); + return res; + } + + return types::Ok<void>(); + } + + }; + + template<typename T, typename F> + struct Else<Result<T, F> (void)> { + + template<typename E, typename Func> + static Result<T, F> orElse(const Result<T, E>& result, Func func) { + static_assert(std::is_same<T, void>::value, + "Can not call a void-callback on a non-void Result"); + + if (result.isErr()) { + auto res = func(); + return res; + } + + return types::Ok<T>(result.storage().template get<T>()); + } + + template<typename E, typename Func> + static Result<void, F> orElse(const Result<void, E>& result, Func func) { + if (result.isErr()) { + auto res = func(); + return res; + } + + return types::Ok<void>(); + } + + }; + +} // namespace impl + +template<typename Func> +struct Else : public impl::Else<decltype(&Func::operator())> { }; + +template<typename Ret, typename... Args> +struct Else<Ret (*) (Args...)> : public impl::Else<Ret (Args...)> { }; + +template<typename Ret, typename Cls, typename... Args> +struct Else<Ret (Cls::*)(Args...)> : public impl::Else<Ret (Args...)> { }; + +template<typename Ret, typename Cls, typename... Args> +struct Else<Ret (Cls::*)(Args...) const> : public impl::Else<Ret (Args...)> { }; + +} // namespace Or + +namespace Other { + +namespace impl { + + template<typename Func> struct Wise; + + template<typename Ret, typename... Args> + struct Wise<Ret (*)(Args...)> : public Wise<Ret (Args...)> { }; + + template<typename Ret, typename Cls, typename... Args> + struct Wise<Ret (Cls::*)(Args...)> : public Wise<Ret (Args...)> { }; + + template<typename Ret, typename Cls, typename... Args> + struct Wise<Ret (Cls::*)(Args...) const> : public Wise<Ret (Args...)> { }; + + template<typename Ret, typename Arg> + struct Wise<Ret (Arg)> { + + template<typename T, typename E, typename Func> + static Result<T, E> otherwise(const Result<T, E>& result, Func func) { + static_assert( + std::is_same<E, Arg>::value || + std::is_convertible<E, Arg>::value, + "Incompatible types detected"); + + static_assert(std::is_same<Ret, void>::value, + "callback should not return anything, use mapError() for that"); + + if (result.isErr()) { + func(result.storage().template get<E>()); + } + return result; + } + + }; + +} // namespace impl + +template<typename Func> +struct Wise : public impl::Wise<decltype(&Func::operator())> { }; + +template<typename Ret, typename... Args> +struct Wise<Ret (*) (Args...)> : public impl::Wise<Ret (Args...)> { }; + +template<typename Ret, typename Cls, typename... Args> +struct Wise<Ret (Cls::*)(Args...)> : public impl::Wise<Ret (Args...)> { }; + +template<typename Ret, typename Cls, typename... Args> +struct Wise<Ret (Cls::*)(Args...) const> : public impl::Wise<Ret (Args...)> { }; + +} // namespace Other + +template<typename T, typename E, typename Func> +decltype(auto) map(const Result<T, E>& result, Func func) { + return ok::Map<Func>::map(result, func); +} + +template<typename T, typename E, typename Func, + typename Ret = + Result<T, + typename details::ResultErrType< + typename details::result_of<Func>::type + >::type + > + > +Ret mapError(const Result<T, E>& result, Func func) { + return err::Map<Func>::map(result, func); +} + +template<typename T, typename E, typename Func> +Result<T, E> then(const Result<T, E>& result, Func func) { + return And::Then<Func>::then(result, func); +} + +template<typename T, typename E, typename Func> +Result<T, E> otherwise(const Result<T, E>& result, Func func) { + return Other::Wise<Func>::otherwise(result, func); +} + +template<typename T, typename E, typename Func, + typename Ret = + Result<T, + typename details::ResultErrType< + typename details::result_of<Func>::type + >::type + > +> +Ret orElse(const Result<T, E>& result, Func func) { + return Or::Else<Func>::orElse(result, func); +} + +struct ok_tag { }; +struct err_tag { }; + +template<typename T, typename E> +struct Storage { + static constexpr size_t Size = sizeof(T) > sizeof(E) ? sizeof(T) : sizeof(E); + static constexpr size_t Align = sizeof(T) > sizeof(E) ? alignof(T) : alignof(E); + + typedef typename std::aligned_storage<Size, Align>::type type; + + Storage() + : initialized_(false) + { } + + void construct(types::Ok<T> ok) + { + new (&storage_) T(std::move(ok.val)); + initialized_ = true; + } + void construct(types::Err<E> err) + { + new (&storage_) E(err.val); + initialized_ = true; + } + + template<typename U> + void rawConstruct(U&& val) { + typedef typename std::decay<U>::type CleanU; + + new (&storage_) CleanU(std::forward<U>(val)); + initialized_ = true; + } + + template<typename U> + const U& get() const { + return *reinterpret_cast<const U *>(&storage_); + } + + template<typename U> + U& get() { + return *reinterpret_cast<U *>(&storage_); + } + + void destroy(ok_tag) { + if (initialized_) { + get<T>().~T(); + initialized_ = false; + } + } + + void destroy(err_tag) { + if (initialized_) { + get<E>().~E(); + initialized_ = false; + } + } + + type storage_; + bool initialized_; +}; + +template<typename E> +struct Storage<void, E> { + typedef typename std::aligned_storage<sizeof(E), alignof(E)>::type type; + + void construct(types::Ok<void>) + { + initialized_ = true; + } + + void construct(types::Err<E> err) + { + new (&storage_) E(err.val); + initialized_ = true; + } + + template<typename U> + void rawConstruct(U&& val) { + typedef typename std::decay<U>::type CleanU; + + new (&storage_) CleanU(std::forward<U>(val)); + initialized_ = true; + } + + void destroy(ok_tag) { initialized_ = false; } + void destroy(err_tag) { + if (initialized_) { + get<E>().~E(); initialized_ = false; + } + } + + template<typename U, + typename = std::enable_if_t<!std::is_same<U, void>::value>> + const U& get() const { + return *reinterpret_cast<const U *>(&storage_); + } + + template<typename U, + typename = std::enable_if_t<!std::is_same<U, void>::value>> + typename std::add_lvalue_reference<U>::type get() { + return *reinterpret_cast<U *>(&storage_); + } + + template<typename U, + typename = std::enable_if_t<std::is_same<U, void>::value>> + void get() {} + + type storage_; + bool initialized_; +}; + +template<typename T, typename E> +struct Constructor { + + static void move(Storage<T, E>&& src, Storage<T, E>& dst, ok_tag) { + dst.rawConstruct(std::move(src.template get<T>())); + src.destroy(ok_tag()); + } + + static void copy(const Storage<T, E>& src, Storage<T, E>& dst, ok_tag) { + dst.rawConstruct(src.template get<T>()); + } + + static void move(Storage<T, E>&& src, Storage<T, E>& dst, err_tag) { + dst.rawConstruct(std::move(src.template get<E>())); + src.destroy(err_tag()); + } + + static void copy(const Storage<T, E>& src, Storage<T, E>& dst, err_tag) { + dst.rawConstruct(src.template get<E>()); + } +}; + +template<typename E> +struct Constructor<void, E> { + static void move(Storage<void, E>&& src, Storage<void, E>& dst, ok_tag) { + } + + static void copy(const Storage<void, E>& src, Storage<void, E>& dst, ok_tag) { + } + + static void move(Storage<void, E>&& src, Storage<void, E>& dst, err_tag) { + dst.rawConstruct(std::move(src.template get<E>())); + src.destroy(err_tag()); + } + + static void copy(const Storage<void, E>& src, Storage<void, E>& dst, err_tag) { + dst.rawConstruct(src.template get<E>()); + } +}; + +} // namespace details + +namespace concept { + +template<typename T, typename = void> struct EqualityComparable : std::false_type { }; + +template<typename T> +struct EqualityComparable<T, +typename std::enable_if< + true, + typename details::void_t<decltype(std::declval<T>() == std::declval<T>())>::type + >::type +> : std::true_type +{ +}; + + +} // namespace concept + +template<typename T, typename E> +struct Result { + + static_assert(!std::is_same<E, void>::value, "void error type is not allowed"); + + typedef details::Storage<T, E> storage_type; + + Result(types::Ok<T> ok) + : ok_(true) + { + storage_.construct(std::move(ok)); + } + + Result(types::Err<E> err) + : ok_(false) + { + storage_.construct(std::move(err)); + } + + Result(Result&& other) { + if (other.isOk()) { + details::Constructor<T, E>::move(std::move(other.storage_), storage_, details::ok_tag()); + ok_ = true; + } else { + details::Constructor<T, E>::move(std::move(other.storage_), storage_, details::err_tag()); + ok_ = false; + } + } + + Result(const Result& other) { + if (other.isOk()) { + details::Constructor<T, E>::copy(other.storage_, storage_, details::ok_tag()); + ok_ = true; + } else { + details::Constructor<T, E>::copy(other.storage_, storage_, details::err_tag()); + ok_ = false; + } + } + + ~Result() { + if (ok_) + storage_.destroy(details::ok_tag()); + else + storage_.destroy(details::err_tag()); + } + + bool isOk() const { + return ok_; + } + + bool isErr() const { + return !ok_; + } + + T expect(const char* str) + { + if (!isOk()) { + ::fprintf(stderr, "%s\n", str); + abort(); + } + return expect_impl(std::is_same<T, void>()); + } + + template<typename Func> + auto map(Func func) + { + using return_type = decltype(func(T{})); + + if (this->isOk()) { + auto value = std::move(this->storage().template get<T>()); + auto res = func(std::move(value)); + return Result<return_type, E>( + types::Ok<return_type>(std::move(res))); + } + + return Result<return_type, E>( + types::Err<E>(this->storage().template get<E>())); + } + + template<typename Func, + typename Ret = + Result<T, + typename details::ResultErrType< + typename details::result_of<Func>::type + >::type + > + > + Ret mapError(Func func) const { + return details::mapError(*this, func); + } + + template<typename Func> + Result<void, E> then(Func func) { + if (this->isOk()) { + func(std::move(this->storage().template get<T>())); + + return Ok(); + } + + return Err(std::move(this->storage().template get<E>())); + } + + template<typename Func> + Result<typename std::result_of<Func>::type, E> then(Func func) { + if (this->isOk()) { + return Ok(func(std::move(this->storage().template get<T>()))); + } + + return Err(std::move(this->storage().template get<E>())); + } + + template<typename Func> + void otherwise(Func func) { + if (this->isOk()) { + return; + } + + func(std::move(this->storage().template get<E>())); + } + + template<typename Func, + typename Ret = + Result<T, + typename details::ResultErrType< + typename details::result_of<Func>::type + >::type + > + > + Ret orElse(Func func) const { + return details::orElse(*this, func); + } + + storage_type& storage() { + return storage_; + } + + const storage_type& storage() const { + return storage_; + } + + template<typename U = T> + typename std::enable_if< + !std::is_same<U, void>::value, + T + >::type + unwrapOr(const U& defaultValue) const { + if (isOk()) { + return storage().template get<T>(); + } + return defaultValue; + } + + template<typename Func> + auto unwrapOrElse(Func func) const { + if (isOk()) { + return storage().template get<T>(); + } + return func(this->storage().template get<E>()); + } + + template<typename U = T> + typename std::enable_if< + !std::is_same<U, void>::value, + U + >::type + unwrap() const { + if (isOk()) { + return std::move(storage().template get<U>()); + } + + ::fprintf(stderr, "Attempting to unwrap an error Result\n"); + abort(); + } + + template<typename U = T> + typename std::enable_if< + !std::is_same<U, void>::value, + U + >::type + unwrap() { + if (isOk()) { + return std::move(storage().template get<U>()); + } + + ::fprintf(stderr, "Attempting to unwrap an error Result\n"); + abort(); + } + + template<typename U = T> + typename std::enable_if<std::is_same<U, void>::value, U>::type unwrap() + const + { + if (isOk()) { + return; + } + + ::fprintf(stderr, "Attempting to unwrap an error Result\n"); + abort(); + } + + E unwrapErr() const + { + if (isErr()) { + return storage().template get<E>(); + } + + ::fprintf(stderr, "Attempting to unwrapErr an ok Result\n"); + abort(); + } + +private: + T expect_impl(std::true_type) const {} + T expect_impl(std::false_type) + { + return std::move(storage_.template get<T>()); + } + + bool ok_; + storage_type storage_; +}; + +template<typename T, typename E> +bool operator==(const Result<T, E>& lhs, const Result<T, E>& rhs) { + static_assert(concept::EqualityComparable<T>::value, "T must be EqualityComparable for Result to be comparable"); + static_assert(concept::EqualityComparable<E>::value, "E must be EqualityComparable for Result to be comparable"); + + if (lhs.isOk() && rhs.isOk()) { + return lhs.storage().template get<T>() == rhs.storage().template get<T>(); + } + if (lhs.isErr() && rhs.isErr()) { + return lhs.storage().template get<E>() == rhs.storage().template get<E>(); + } +} + +template<typename T, typename E> +bool operator==(const Result<T, E>& lhs, types::Ok<T> ok) { + static_assert(concept::EqualityComparable<T>::value, "T must be EqualityComparable for Result to be comparable"); + + if (!lhs.isOk()) return false; + + return lhs.storage().template get<T>() == ok.val; +} + +template<typename E> +bool operator==(const Result<void, E>& lhs, types::Ok<void>) { + return lhs.isOk(); +} + +template<typename T, typename E> +bool operator==(const Result<T, E>& lhs, types::Err<E> err) { + static_assert(concept::EqualityComparable<E>::value, "E must be EqualityComparable for Result to be comparable"); + if (!lhs.isErr()) return false; + + return lhs.storage().template get<E>() == err.val; +} + +#define TRY(...) \ + ({ \ + auto res = __VA_ARGS__; \ + if (!res.isOk()) { \ + typedef typename ::details::ResultErrType<decltype(res)>::type E; \ + return ::types::Err<E>(res.storage().template get<E>()); \ + } \ + res.unwrap(); \ + }) |