Adding upstream version 0.11.2.upstream/0.11.2

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1032 insertions, 0 deletions

diff --git a/src/base/result.h b/src/base/result.h
new file mode 100644
index 0000000..e3e8ac5
--- /dev/null
+++ b/src/base/result.h
@@ -0,0 +1,1032 @@
+/*
+   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 <exception>
+#include <functional>
+#include <type_traits>
+
+#include <stdio.h>
+
+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> {};
+};  // namespace types
+
+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;
+};
+}  // namespace impl
+
+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 local_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 local_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(local_concept::EqualityComparable<T>::value,
+                  "T must be EqualityComparable for Result to be comparable");
+    static_assert(local_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(local_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(local_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(); \
+    })