From 0803f83355e5ad1cd5f321fdc8a927a2939af022 Mon Sep 17 00:00:00 2001
From: altalk23 <45172705+altalk23@users.noreply.github.com>
Date: Fri, 2 Dec 2022 18:40:51 +0300
Subject: [PATCH 1/2] completely replace result impl - TODO: fix unzip

---
 .clang-format                                 |    3 +-
 bindings/Cocos2d.bro                          |    1 +
 loader/include/Geode/c++stl/gdlib.hpp         |  153 +
 loader/include/Geode/c++stl/gnustl.hpp        |  172 +-
 .../include/Geode/external/result/result.hpp  | 5994 +++++++++++++++++
 loader/include/Geode/utils/Result.hpp         |  408 +-
 loader/src/loader/Hook.cpp                    |    2 +-
 loader/src/loader/ModInfo.cpp                 |    4 +-
 loader/src/loader/Patch.cpp                   |    2 +-
 loader/src/platform/mac/Cocos2d.cpp           |    4 -
 loader/src/ui/nodes/Notification.cpp          |   37 +-
 loader/src/utils/file.cpp                     |   32 +-
 12 files changed, 6442 insertions(+), 370 deletions(-)
 create mode 100644 loader/include/Geode/c++stl/gdlib.hpp
 create mode 100644 loader/include/Geode/external/result/result.hpp

diff --git a/.clang-format b/.clang-format
index 48451bcf..974e428d 100644
--- a/.clang-format
+++ b/.clang-format
@@ -84,7 +84,7 @@ IndentCaseLabels: true
 IndentExternBlock: Indent
 IndentGotoLabels: true
 IndentPPDirectives: BeforeHash
-IndentRequiresClause: false
+IndentRequiresClause: true
 IndentWrappedFunctionNames: false
 # InsertBraces: true
 InsertTrailingCommas: None
@@ -101,6 +101,7 @@ PenaltyBreakBeforeFirstCallParameter: 19
 PenaltyBreakComment: 300
 PenaltyBreakFirstLessLess: 120
 PenaltyBreakString: 1000
+PenaltyBreakOpenParenthesis: 0
 PenaltyBreakTemplateDeclaration: 10
 PenaltyExcessCharacter: 1000000
 PenaltyReturnTypeOnItsOwnLine: 1000000
diff --git a/bindings/Cocos2d.bro b/bindings/Cocos2d.bro
index 71644c07..21cfb16e 100644
--- a/bindings/Cocos2d.bro
+++ b/bindings/Cocos2d.bro
@@ -210,6 +210,7 @@ class cocos2d::CCFileUtils : cocos2d::TypeInfo {
     virtual void addSearchPath(const char* path);
 	virtual void removeSearchPath(const char *path);
     virtual std::string fullPathForFilename(const char* filename, bool unk);
+    void removeAllPaths() = mac 0x241600;
 }
 
 class cocos2d::CCGLProgram {
diff --git a/loader/include/Geode/c++stl/gdlib.hpp b/loader/include/Geode/c++stl/gdlib.hpp
new file mode 100644
index 00000000..9e0e6fc6
--- /dev/null
+++ b/loader/include/Geode/c++stl/gdlib.hpp
@@ -0,0 +1,153 @@
+#pragma once
+
+#include <cstdint>
+#include <array>
+
+namespace geode::stl {
+
+	template <class Type>
+	class AllocatorTemplate {
+	protected:
+		inline Type* allocate(size_t count);
+		inline void deallocate(Type* pointer);
+	};
+
+#if defined(GEODE_IS_WINDOWS)
+	template <class Type>
+	class AllocatorBase {
+	protected:
+		inline Type* allocate(size_t count) {
+
+		}
+		inline void deallocate(Type* pointer) {
+
+		}
+	};
+#elif defined(GEODE_IS_MACOS) || defined(GEODE_IS_ANDROID)
+
+#elif defined(GEODE_IS_IOS)
+
+#endif
+
+
+	class StringTemplate : public AllocatorBase {
+	protected:
+		// depends on already set size and capacity
+		inline void setStorage(char* pointer) = delete;
+		inline char* getStorage() = delete;
+
+		inline void setSize(size_t size) = delete;
+		inline size_t getSize() = delete;
+
+		inline void setCapacity(size_t capacity) = delete;
+		inline size_t getCapacity() = delete;
+	};
+
+#if defined(GEODE_IS_WINDOWS)
+	class StringBase : public StringTemplate {
+	protected:
+		union {
+			std::array<char, 16> m_smallStorage;
+			char* m_bigStorage;
+		};
+
+		size_t m_size;
+		size_t m_capacity;
+
+		inline void setStorage(char* storage) {
+			if (m_capacity > 15) {
+				return m_bigStorage = storage;
+			}
+		}
+		inline char* getStorage() {
+			if (m_capacity > 15) {
+				return m_bigStorage;
+			}
+			return m_smallStorage.data();
+		}
+
+		inline void setSize(size_t size) {
+			m_size = size;
+		}
+		inline size_t getSize() {
+			return m_size;
+		}
+
+		inline void setCapacity(size_t capacity) {
+			m_capacity = capacity;
+		}
+		inline size_t getCapacity() {
+			return m_capacity;
+		}
+	};
+#elif defined(GEODE_IS_MACOS) || defined(GEODE_IS_ANDROID)
+	class StringBase : public StringTemplate {
+	protected:
+		char* m_storage;
+		size_t m_size;
+		size_t m_capacity;
+
+		inline void setStorage(char* storage) {
+			m_storage = storage;
+		}
+		inline char* getStorage() {
+			return m_storage;
+		}
+
+		inline void setSize(size_t size) {
+			m_size = size;
+		}
+		inline size_t getSize() {
+			return m_size;
+		}
+
+		inline void setCapacity(size_t capacity) {
+			m_capacity = capacity;
+		}
+		inline size_t getCapacity() {
+			return m_capacity;
+		}
+	};
+#elif defined(GEODE_IS_IOS)
+	class StringBase : public StringTemplate {
+	protected:
+		struct Short {
+			uint8_t sizex2;
+			std::array<char, 23> shortStorage;
+		};
+
+		struct Long {
+			size_t capacitym1;
+			size_t size;
+			char* longStorage;
+		};
+
+		union {
+			Short m_short;
+			Long m_long;
+		};
+
+		inline void setStorage(char* storage) {
+			m_storage = storage;
+		}
+		inline char* getStorage() {
+			return m_storage;
+		}
+
+		inline void setSize(size_t size) {
+			m_size = size;
+		}
+		inline size_t getSize() {
+			return m_size;
+		}
+
+		inline void setCapacity(size_t capacity) {
+			m_capacity = capacity;
+		}
+		inline size_t getCapacity() {
+			return m_capacity;
+		}
+	};
+#endif
+
+}
\ No newline at end of file
diff --git a/loader/include/Geode/c++stl/gnustl.hpp b/loader/include/Geode/c++stl/gnustl.hpp
index 5f0856ed..f6d67acb 100644
--- a/loader/include/Geode/c++stl/gnustl.hpp
+++ b/loader/include/Geode/c++stl/gnustl.hpp
@@ -296,68 +296,88 @@ namespace gd {
         }
     };
 
+    // template <class Type>
+    // using vector = std::vector<Type>;
+
     template <typename T>
     class GEODE_DLL vector {
     public:
         using value_type = T;
 
-        operator std::vector<T>() const {
-            std::vector<T> out;
-
-            for (auto i = m_start; i != m_finish; ++i) {
-                out.push_back(*i);
-            }
-            return out;
+        auto allocator() const {
+            return std::allocator<T>();
         }
 
-        vector(std::vector<T> input) {
-            std::allocator<T> alloc;
-            auto tmp = alloc.allocate(input.size());
+        operator std::vector<T>() const {
+            return std::vector<T>(m_start, m_finish);
+        }
 
-            m_start = tmp;
+        vector(std::vector<T> const& input) {
+            m_start = this->allocator().allocate(input.size());
             m_finish = m_start + input.size();
-            m_capacity_end = m_start + input.size();
-            for (auto i : input) {
-                *tmp = i;
-                tmp++;
-            }
+            m_reserveEnd = m_start + input.size();
+
+            std::copy(input.begin(), input.end(), m_start);
         }
 
         vector(std::initializer_list<T> const& input) {
-            std::allocator<T> alloc;
-            auto tmp = alloc.allocate(input.size());
-            m_start = tmp;
+            m_start = this->allocator().allocate(input.size());
             m_finish = m_start + input.size();
-            m_capacity_end = m_start + input.size();
-            std::copy(input.begin(), input.end(), tmp);
+            m_reserveEnd = m_start + input.size();
+
+            std::copy(input.begin(), input.end(), m_start);
         }
         
         void clear() {
-            std::allocator<T> alloc;
-            alloc.deallocate(m_start, (m_finish - m_start) / 8);
-            m_start = alloc.allocate(1);
+            std::destroy(m_start, m_finish);
+
+            this->allocator().deallocate(m_start, this->size());
+
+            m_start = this->allocator().allocate(16);
             m_finish = m_start;
-            m_capacity_end = m_start + 8;
+            m_reserveEnd = m_start;
+        }
+
+        T& operator[](size_t index) {
+            return m_start[index];
+        }
+
+        T const& operator[](size_t index) const {
+            return m_start[index];
+        }
+
+        T& at(size_t index) {
+            if (index >= this->size()) {
+                throw std::out_of_range("gd::vector::at");
+            }
+            return m_start[index];
+        }
+
+        T const& at(size_t index) const {
+            if (index >= this->size()) {
+                throw std::out_of_range("gd::vector::at");
+            }
+            return m_start[index];
         }
 
         T& front() {
             return *m_start;
         }
 
-        auto begin() {
+        T* begin() {
             return m_start;
         }
 
-        auto end() {
+        T* end() {
             return m_finish;
         }
 
-        auto begin() const {
-            return static_cast<const T*>(m_start);
+        T const* begin() const {
+            return m_start;
         }
 
-        auto end() const {
-            return static_cast<const T*>(m_finish);
+        T const* end() const {
+            return m_finish;
         }
 
         vector(vector const& lol) : vector(std::vector<T>(lol)) {}
@@ -370,10 +390,18 @@ namespace gd {
             }
         }
 
+        size_t size() const {
+            return m_finish - m_start;
+        }
+
+        size_t capacity() const {
+            return m_reserveEnd - m_start;
+        }
+
     protected:
         T* m_start;
         T* m_finish;
-        T* m_capacity_end;
+        T* m_reserveEnd;
     };
 
     struct _bit_reference {
@@ -436,55 +464,55 @@ namespace gd {
         }
     };
 
-    template <>
-    class vector<bool> {
-    protected:
-        _bit_iterator m_start;
-        _bit_iterator m_end;
-        uintptr_t* m_capacity_end;
+    // template <>
+    // class vector<bool> {
+    // protected:
+    //     _bit_iterator m_start;
+    //     _bit_iterator m_end;
+    //     uintptr_t* m_capacity_end;
 
-    public:
-        vector(std::vector<bool> input) : m_start(0), m_end(0) {
-            auto realsize = input.size() / int(sizeof(uintptr_t));
-            auto tmp = new uintptr_t[realsize];
+    // public:
+    //     vector(std::vector<bool> input) : m_start(0), m_end(0) {
+    //         auto realsize = input.size() / int(sizeof(uintptr_t));
+    //         auto tmp = new uintptr_t[realsize];
 
-            m_start = _bit_iterator(tmp);
-            m_end = _bit_iterator(tmp + realsize, input.size() % sizeof(uintptr_t));
-            m_capacity_end = tmp + realsize;
+    //         m_start = _bit_iterator(tmp);
+    //         m_end = _bit_iterator(tmp + realsize, input.size() % sizeof(uintptr_t));
+    //         m_capacity_end = tmp + realsize;
 
-            auto itmp = m_start;
-            for (auto i : input) {
-                *itmp = i;
-                ++itmp;
-            }
-        }
+    //         auto itmp = m_start;
+    //         for (auto i : input) {
+    //             *itmp = i;
+    //             ++itmp;
+    //         }
+    //     }
 
-        vector(vector<bool> const& lol) : vector(std::vector<bool>(lol)) {}
+    //     vector(vector<bool> const& lol) : vector(std::vector<bool>(lol)) {}
 
-        vector() : vector(std::vector<bool>()) {}
+    //     vector() : vector(std::vector<bool>()) {}
 
-        ~vector() {
-            delete[] m_start.m_bitptr;
-        }
+    //     ~vector() {
+    //         delete[] m_start.m_bitptr;
+    //     }
 
-        operator std::vector<bool>() const {
-            std::vector<bool> out;
-            for (auto i = m_start; i != m_end; ++i) {
-                out.push_back(*i);
-            }
-            return out;
-        }
+    //     operator std::vector<bool>() const {
+    //         std::vector<bool> out;
+    //         for (auto i = m_start; i != m_end; ++i) {
+    //             out.push_back(*i);
+    //         }
+    //         return out;
+    //     }
 
-        _bit_reference operator[](size_t index) {
-            const auto real_index = index / sizeof(uintptr_t);
-            const auto offset = index % sizeof(uintptr_t);
-            return _bit_reference(&m_start.m_bitptr[real_index], 1UL << offset);
-        }
+    //     _bit_reference operator[](size_t index) {
+    //         const auto real_index = index / sizeof(uintptr_t);
+    //         const auto offset = index % sizeof(uintptr_t);
+    //         return _bit_reference(&m_start.m_bitptr[real_index], 1UL << offset);
+    //     }
 
-        bool operator[](size_t index) const {
-            return const_cast<vector&>(*this)[index];
-        }
-    };
+    //     bool operator[](size_t index) const {
+    //         return const_cast<vector&>(*this)[index];
+    //     }
+    // };
 };
 
 #elif defined(GEODE_IS_IOS)
diff --git a/loader/include/Geode/external/result/result.hpp b/loader/include/Geode/external/result/result.hpp
new file mode 100644
index 00000000..f2ac2802
--- /dev/null
+++ b/loader/include/Geode/external/result/result.hpp
@@ -0,0 +1,5994 @@
+////////////////////////////////////////////////////////////////////////////////
+/// \file result.hpp
+///
+/// \brief This header contains the 'result' monadic type for indicating
+///        possible error conditions
+////////////////////////////////////////////////////////////////////////////////
+
+/*
+  The MIT License (MIT)
+
+  Copyright (c) 2017-2021 Matthew Rodusek All rights reserved.
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+#ifndef RESULT_RESULT_HPP
+#define RESULT_RESULT_HPP
+
+#include <cstddef>      // std::size_t
+#include <type_traits>  // std::enable_if, std::is_constructible, etc
+#include <new>          // placement-new
+#include <memory>       // std::address_of
+#include <functional>   // std::reference_wrapper, std::invoke
+#include <utility>      // std::in_place_t, std::forward
+#include <initializer_list> // std::initializer_list
+#include <string>       // std::string (for exception message)
+
+#if defined(RESULT_EXCEPTIONS_DISABLED)
+# include <cstdio> // std::fprintf, stderr
+#else
+# include <stdexcept> // std::logic_error
+#endif
+
+#if __cplusplus >= 201402L
+# define RESULT_CPP14_CONSTEXPR constexpr
+#else
+# define RESULT_CPP14_CONSTEXPR
+#endif
+
+#if __cplusplus >= 201703L
+# define RESULT_CPP17_INLINE inline
+#else
+# define RESULT_CPP17_INLINE
+#endif
+
+#if defined(__clang__) && defined(_MSC_VER)
+# define RESULT_INLINE_VISIBILITY __attribute__((visibility("hidden")))
+#elif defined(__clang__) || defined(__GNUC__)
+# define RESULT_INLINE_VISIBILITY __attribute__((visibility("hidden"), always_inline))
+#elif defined(_MSC_VER)
+# define RESULT_INLINE_VISIBILITY __forceinline
+#else
+# define RESULT_INLINE_VISIBILITY
+#endif
+
+// [[clang::warn_unused_result]] is more full-featured than gcc's variant, since
+// it supports being applied to class objects.
+#if __cplusplus >= 201703L
+# define RESULT_NODISCARD [[nodiscard]]
+# define RESULT_WARN_UNUSED [[nodiscard]]
+#elif defined(__clang__) && ((__clang_major__ > 3) || ((__clang_major__ == 3) && (__clang_minor__ >= 9)))
+# define RESULT_NODISCARD [[clang::warn_unused_result]]
+# define RESULT_WARN_UNUSED [[clang::warn_unused_result]]
+#elif defined(__GNUC__)
+# define RESULT_NODISCARD
+# define RESULT_WARN_UNUSED [[gnu::warn_unused_result]]
+#else
+# define RESULT_WARN_UNUSED
+# define RESULT_NODISCARD
+#endif
+
+#if defined(RESULT_NAMESPACE)
+# define RESULT_NAMESPACE_INTERNAL RESULT_NAMESPACE
+#else
+# define RESULT_NAMESPACE_INTERNAL cpp
+#endif
+#define RESULT_NS_IMPL RESULT_NAMESPACE_INTERNAL::bitwizeshift
+
+// clang's `-Wdocumentation-unknown-command` flag is bugged and does not
+// understand `\copydoc` tags, despite this being a valid doxygen tag.
+#if defined(__clang__)
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wdocumentation-unknown-command"
+#endif
+
+namespace RESULT_NAMESPACE_INTERNAL {
+inline namespace bitwizeshift {
+
+  //===========================================================================
+  // utilities : constexpr forward
+  //===========================================================================
+
+  // std::forward is not constexpr until C++14
+  namespace detail {
+#if __cplusplus >= 201402L
+    using std::forward;
+#else
+    template <typename T>
+    inline RESULT_INLINE_VISIBILITY constexpr
+    auto forward(typename std::remove_reference<T>::type& t)
+      noexcept -> T&&
+    {
+      return static_cast<T&&>(t);
+    }
+
+    template <typename T>
+    inline RESULT_INLINE_VISIBILITY constexpr
+    auto forward(typename std::remove_reference<T>::type&& t)
+      noexcept -> T&&
+    {
+      return static_cast<T&&>(t);
+    }
+#endif
+  } // namespace detail
+
+
+  //===========================================================================
+  // utilities : invoke / invoke_result
+  //===========================================================================
+
+  // std::invoke was introduced in C++17
+
+  namespace detail {
+#if __cplusplus >= 201703L
+    using std::invoke;
+    using std::invoke_result;
+    using std::invoke_result_t;
+#else
+    template<typename T>
+    struct is_reference_wrapper : std::false_type{};
+
+    template<typename U>
+    struct is_reference_wrapper<std::reference_wrapper<U>> : std::true_type{};
+
+    //-------------------------------------------------------------------------
+
+    template <typename Base, typename T, typename Derived, typename... Args,
+              typename = typename std::enable_if<
+                std::is_function<T>::value &&
+                std::is_base_of<Base, typename std::decay<Derived>::type>::value
+              >::type>
+    inline RESULT_INLINE_VISIBILITY constexpr
+    auto invoke(T Base::*pmf, Derived&& ref, Args&&... args)
+      noexcept(noexcept((::RESULT_NS_IMPL::detail::forward<Derived>(ref).*pmf)(::RESULT_NS_IMPL::detail::forward<Args>(args)...)))
+      -> decltype((::RESULT_NS_IMPL::detail::forward<Derived>(ref).*pmf)(::RESULT_NS_IMPL::detail::forward<Args>(args)...))
+    {
+      return (RESULT_NS_IMPL::detail::forward<Derived>(ref).*pmf)(RESULT_NS_IMPL::detail::forward<Args>(args)...);
+    }
+
+    template <typename Base, typename T, typename RefWrap, typename... Args,
+              typename = typename std::enable_if<
+                std::is_function<T>::value &&
+                is_reference_wrapper<typename std::decay<RefWrap>::type>::value
+              >::type>
+    inline RESULT_INLINE_VISIBILITY constexpr
+    auto invoke(T Base::*pmf, RefWrap&& ref, Args&&... args)
+      noexcept(noexcept((ref.get().*pmf)(std::forward<Args>(args)...)))
+      -> decltype((ref.get().*pmf)(RESULT_NS_IMPL::detail::forward<Args>(args)...))
+    {
+      return (ref.get().*pmf)(RESULT_NS_IMPL::detail::forward<Args>(args)...);
+    }
+
+    template <typename Base, typename T, typename Pointer, typename... Args,
+              typename = typename std::enable_if<
+                std::is_function<T>::value &&
+                !is_reference_wrapper<typename std::decay<Pointer>::type>::value &&
+                !std::is_base_of<Base, typename std::decay<Pointer>::type>::value
+              >::type>
+    inline RESULT_INLINE_VISIBILITY constexpr
+    auto invoke(T Base::*pmf, Pointer&& ptr, Args&&... args)
+      noexcept(noexcept(((*std::forward<Pointer>(ptr)).*pmf)(std::forward<Args>(args)...)))
+      -> decltype(((*RESULT_NS_IMPL::detail::forward<Pointer>(ptr)).*pmf)(RESULT_NS_IMPL::detail::forward<Args>(args)...))
+    {
+      return ((*RESULT_NS_IMPL::detail::forward<Pointer>(ptr)).*pmf)(RESULT_NS_IMPL::detail::forward<Args>(args)...);
+    }
+
+    template <typename Base, typename T, typename Derived,
+              typename = typename std::enable_if<
+                !std::is_function<T>::value &&
+                std::is_base_of<Base, typename std::decay<Derived>::type>::value
+              >::type>
+    inline RESULT_INLINE_VISIBILITY constexpr
+    auto invoke(T Base::*pmd, Derived&& ref)
+      noexcept(noexcept(std::forward<Derived>(ref).*pmd))
+      -> decltype(RESULT_NS_IMPL::detail::forward<Derived>(ref).*pmd)
+    {
+      return RESULT_NS_IMPL::detail::forward<Derived>(ref).*pmd;
+    }
+
+    template <typename Base, typename T, typename RefWrap,
+              typename = typename std::enable_if<
+                !std::is_function<T>::value &&
+                is_reference_wrapper<typename std::decay<RefWrap>::type>::value
+              >::type>
+    inline RESULT_INLINE_VISIBILITY constexpr
+    auto invoke(T Base::*pmd, RefWrap&& ref)
+      noexcept(noexcept(ref.get().*pmd))
+      -> decltype(ref.get().*pmd)
+    {
+      return ref.get().*pmd;
+    }
+
+    template <typename Base, typename T, typename Pointer,
+              typename = typename std::enable_if<
+                !std::is_function<T>::value &&
+                !is_reference_wrapper<typename std::decay<Pointer>::type>::value &&
+                !std::is_base_of<Base, typename std::decay<Pointer>::type>::value
+              >::type>
+    inline RESULT_INLINE_VISIBILITY constexpr
+    auto invoke(T Base::*pmd, Pointer&& ptr)
+      noexcept(noexcept((*std::forward<Pointer>(ptr)).*pmd))
+      -> decltype((*RESULT_NS_IMPL::detail::forward<Pointer>(ptr)).*pmd)
+    {
+      return (*RESULT_NS_IMPL::detail::forward<Pointer>(ptr)).*pmd;
+    }
+
+    template <typename F, typename... Args,
+              typename = typename std::enable_if<!std::is_member_pointer<typename std::decay<F>::type>::value>::type>
+    inline RESULT_INLINE_VISIBILITY constexpr
+    auto invoke(F&& f, Args&&... args)
+        noexcept(noexcept(std::forward<F>(f)(std::forward<Args>(args)...)))
+      -> decltype(RESULT_NS_IMPL::detail::forward<F>(f)(RESULT_NS_IMPL::detail::forward<Args>(args)...))
+    {
+      return RESULT_NS_IMPL::detail::forward<F>(f)(RESULT_NS_IMPL::detail::forward<Args>(args)...);
+    }
+
+    template<typename Fn, typename...Args>
+    struct is_invocable
+    {
+      template <typename Fn2, typename...Args2>
+      static auto test( Fn2&&, Args2&&... )
+        -> decltype(invoke(std::declval<Fn2>(), std::declval<Args2>()...), std::true_type{});
+
+      static auto test(...)
+        -> std::false_type;
+
+      using type = decltype(test(std::declval<Fn>(), std::declval<Args>()...));
+      static constexpr bool value = type::value;
+    };
+
+    template <bool B, typename Fn, typename...Args>
+    struct invoke_result_impl {
+      using type = decltype(RESULT_NS_IMPL::detail::invoke(std::declval<Fn>(), std::declval<Args>()...));
+    };
+    template <typename Fn, typename...Args>
+    struct invoke_result_impl<false, Fn, Args...>{};
+
+    template <typename Fn, typename...Args>
+    struct invoke_result
+      : invoke_result_impl<is_invocable<Fn,Args...>::value, Fn, Args...>{};
+
+    template <typename Fn, typename...Args>
+    using invoke_result_t = typename invoke_result<Fn, Args...>::type;
+#endif
+  }
+
+  //===========================================================================
+  // struct : in_place_t
+  //===========================================================================
+
+#if __cplusplus >= 201703L
+  using std::in_place_t;
+  using std::in_place;
+#else
+  /// \brief A structure for representing in-place construction
+  struct in_place_t
+  {
+    explicit in_place_t() = default;
+  };
+  RESULT_CPP17_INLINE constexpr auto in_place = in_place_t{};
+#endif
+
+  //===========================================================================
+  // struct : in_place_t
+  //===========================================================================
+
+  /// \brief A structure for representing in-place construction of an error type
+  struct in_place_error_t
+  {
+    explicit in_place_error_t() = default;
+  };
+
+  RESULT_CPP17_INLINE constexpr auto in_place_error = in_place_error_t{};
+
+  //===========================================================================
+  // forward-declarations
+  //===========================================================================
+
+  template <typename>
+  class failure;
+
+  template <typename, typename>
+  class result;
+
+  template <typename>
+  class bad_result_access;
+
+  //===========================================================================
+  // traits
+  //===========================================================================
+
+  template <typename T>
+  struct is_failure : std::false_type{};
+  template <typename E>
+  struct is_failure<failure<E>> : std::true_type{};
+
+  template <typename T>
+  struct is_result : std::false_type{};
+  template <typename T, typename E>
+  struct is_result<result<T,E>> : std::true_type{};
+
+  //===========================================================================
+  // trait : detail::wrapped_result_type
+  //===========================================================================
+
+  namespace detail {
+
+    template <typename T>
+    using wrapped_result_type = typename std::conditional<
+      std::is_lvalue_reference<T>::value,
+      std::reference_wrapper<
+        typename std::remove_reference<T>::type
+      >,
+      typename std::remove_const<T>::type
+    >::type;
+
+  } // namespace detail
+
+#if !defined(RESULT_DISABLE_EXCEPTIONS)
+
+  //===========================================================================
+  // class : bad_result_access<E>
+  //===========================================================================
+
+  /////////////////////////////////////////////////////////////////////////////
+  /// \brief An exception thrown when result::value is accessed without
+  ///        a contained value
+  /////////////////////////////////////////////////////////////////////////////
+  template <typename E>
+  class bad_result_access : public std::logic_error
+  {
+    //-------------------------------------------------------------------------
+    // Constructor / Assignment
+    //-------------------------------------------------------------------------
+  public:
+
+    /// \brief Constructs this exception using the underlying error type for
+    ///        the error type
+    ///
+    /// \param error the underlying error
+    template <typename E2,
+              typename = typename std::enable_if<std::is_constructible<E,E2>::value>::type>
+    explicit bad_result_access(E2&& error);
+
+    /// \{
+    /// \brief Constructs this exception using the underlying error type for
+    ///        the error and a message
+    ///
+    /// \param what_arg the message for the failure
+    /// \param error the underlying error
+    template <typename E2,
+              typename = typename std::enable_if<std::is_constructible<E,E2>::value>::type>
+    bad_result_access(const char* what_arg, E2&& error);
+    template <typename E2,
+              typename = typename std::enable_if<std::is_constructible<E,E2>::value>::type>
+    bad_result_access(const std::string& what_arg, E2&& error);
+    /// \}
+
+    bad_result_access(const bad_result_access& other) = default;
+    bad_result_access(bad_result_access&& other) = default;
+
+    //-------------------------------------------------------------------------
+
+    auto operator=(const bad_result_access& other) -> bad_result_access& = default;
+    auto operator=(bad_result_access&& other) -> bad_result_access& = default;
+
+    /// \{
+    /// \brief Gets the underlying error
+    ///
+    /// \return the error
+    auto error() & noexcept -> E&;
+    auto error() && noexcept -> E&&;
+    auto error() const & noexcept -> const E&;
+    auto error() const && noexcept -> const E&&;
+    /// \}
+
+    //-------------------------------------------------------------------------
+    // Private Members
+    //-------------------------------------------------------------------------
+  private:
+
+    E m_error;
+  };
+
+#endif
+
+  namespace detail {
+
+    template <typename E, typename E2>
+    using failure_is_value_convertible = std::integral_constant<bool,(
+      std::is_constructible<E, E2&&>::value &&
+      !std::is_same<typename std::decay<E2>::type, in_place_t>::value &&
+      !is_failure<typename std::decay<E2>::type>::value &&
+      !is_result<typename std::decay<E2>::type>::value
+    )>;
+
+    template <typename E, typename E2>
+    using failure_is_explicit_value_convertible = std::integral_constant<bool,(
+      failure_is_value_convertible<E, E2>::value &&
+      !std::is_convertible<E2, E>::value
+    )>;
+
+    template <typename E, typename E2>
+    using failure_is_implicit_value_convertible = std::integral_constant<bool,(
+      failure_is_value_convertible<E, E2>::value &&
+      std::is_convertible<E2, E>::value
+    )>;
+
+    template <typename E, typename E2>
+    using failure_is_value_assignable = std::integral_constant<bool,(
+      !is_result<typename std::decay<E2>::type>::value &&
+      !is_failure<typename std::decay<E2>::type>::value &&
+      std::is_assignable<wrapped_result_type<E>&,E2>::value
+    )>;
+
+  } // namespace detail
+
+  //===========================================================================
+  // class : failure_type
+  //===========================================================================
+
+  //////////////////////////////////////////////////////////////////////////////
+  /// \brief A semantic type used for distinguishing failure values in an
+  ///        API that returns result types
+  ///
+  /// \tparam E the error type
+  //////////////////////////////////////////////////////////////////////////////
+  template <typename E>
+  class failure
+  {
+    static_assert(
+      !is_result<typename std::decay<E>::type>::value,
+      "A (possibly CV-qualified) result 'E' type is ill-formed."
+    );
+    static_assert(
+      !is_failure<typename std::decay<E>::type>::value,
+      "A (possibly CV-qualified) failure 'E' type is ill-formed."
+    );
+    static_assert(
+      !std::is_void<typename std::decay<E>::type>::value,
+      "A (possibly CV-qualified) 'void' 'E' type is ill-formed."
+    );
+    static_assert(
+      !std::is_rvalue_reference<E>::value,
+      "rvalue references for 'E' type is ill-formed. "
+      "Only lvalue references are valid."
+    );
+
+    //-------------------------------------------------------------------------
+    // Public Member Types
+    //-------------------------------------------------------------------------
+  public:
+
+    using error_type = E;
+
+    //-------------------------------------------------------------------------
+    // Constructors / Assignment
+    //-------------------------------------------------------------------------
+  public:
+
+    /// \brief Constructs a failure via default construction
+    failure() = default;
+
+    /// \brief Constructs a failure by delegating construction to the
+    ///        underlying constructor
+    ///
+    /// \param args the arguments to forward to E's constructor
+    template <typename...Args,
+              typename = typename std::enable_if<std::is_constructible<E,Args...>::value>::type>
+    constexpr failure(in_place_t, Args&&...args)
+      noexcept(std::is_nothrow_constructible<E, Args...>::value);
+
+    /// \brief Constructs a failure by delegating construction to the
+    ///        underlying constructor
+    ///
+    /// \param ilist the initializer list
+    /// \param args the arguments to forward to E's constructor
+    template <typename U, typename...Args,
+              typename = typename std::enable_if<std::is_constructible<E,std::initializer_list<U>,Args...>::value>::type>
+    constexpr failure(in_place_t, std::initializer_list<U> ilist, Args&&...args)
+      noexcept(std::is_nothrow_constructible<E, std::initializer_list<U>, Args...>::value);
+
+    /// \{
+    /// \brief Constructs a failure from the given error
+    ///
+    /// \param error the error to create a failure from
+    template <typename E2,
+              typename std::enable_if<detail::failure_is_implicit_value_convertible<E,E2>::value,int>::type = 0>
+    constexpr failure(E2&& error)
+      noexcept(std::is_nothrow_constructible<E,E2>::value);
+    template <typename E2,
+              typename std::enable_if<detail::failure_is_explicit_value_convertible<E,E2>::value,int>::type = 0>
+    constexpr explicit failure(E2&& error)
+      noexcept(std::is_nothrow_constructible<E,E2>::value);
+    /// \}
+
+    /// \brief Constructs this failure by copying the contents of an existing
+    ///        one
+    ///
+    /// \param other the other failure to copy
+    /* implicit */ failure(const failure& other) = default;
+
+    /// \brief Constructs this failure by moving the contents of an existing
+    ///        one
+    ///
+    /// \param other the other failure to move
+    /* implicit */ failure(failure&& other) = default;
+
+    /// \brief Constructs this failure by copy-converting \p other
+    ///
+    /// \param other the other failure to copy
+    template <typename E2,
+              typename = typename std::enable_if<std::is_constructible<E,const E2&>::value>::type>
+    constexpr /* implicit */ failure(const failure<E2>& other)
+      noexcept(std::is_nothrow_constructible<E,const E2&>::value);
+
+    /// \brief Constructs this failure by move-converting \p other
+    ///
+    /// \param other the other failure to copy
+    template <typename E2,
+              typename = typename std::enable_if<std::is_constructible<E,E2&&>::value>::type>
+    constexpr /* implicit */ failure(failure<E2>&& other)
+      noexcept(std::is_nothrow_constructible<E,E2&&>::value);
+
+    //--------------------------------------------------------------------------
+
+    /// \brief Assigns the value of \p error to this failure through
+    ///        move-assignment
+    ///
+    /// \param error the value to assign
+    /// \return reference to `(*this)`
+    template <typename E2,
+              typename = typename std::enable_if<detail::failure_is_value_assignable<E,E2>::value>::type>
+    RESULT_CPP14_CONSTEXPR
+    auto operator=(E2&& error)
+      noexcept(std::is_nothrow_assignable<E,E2>::value || std::is_lvalue_reference<E>::value) -> failure&;
+
+    /// \brief Assigns the contents of \p other to this by copy-assignment
+    ///
+    /// \param other the other failure to copy
+    /// \return reference to `(*this)`
+    auto operator=(const failure& other) -> failure& = default;
+
+    /// \brief Assigns the contents of \p other to this by move-assignment
+    ///
+    /// \param other the other failure to move
+    /// \return reference to `(*this)`
+    auto operator=(failure&& other) -> failure& = default;
+
+    /// \brief Assigns the contents of \p other to this by copy conversion
+    ///
+    /// \param other the other failure to copy-convert
+    /// \return reference to `(*this)`
+    template <typename E2,
+              typename = typename std::enable_if<std::is_assignable<E&,const E2&>::value>::type>
+    RESULT_CPP14_CONSTEXPR
+    auto operator=(const failure<E2>& other)
+      noexcept(std::is_nothrow_assignable<E,const E2&>::value) -> failure&;
+
+    /// \brief Assigns the contents of \p other to this by move conversion
+    ///
+    /// \param other the other failure to move-convert
+    /// \return reference to `(*this)`
+    template <typename E2,
+              typename = typename std::enable_if<std::is_assignable<E&,E2&&>::value>::type>
+    RESULT_CPP14_CONSTEXPR
+    auto operator=(failure<E2>&& other)
+      noexcept(std::is_nothrow_assignable<E,E2&&>::value) -> failure&;
+
+    //--------------------------------------------------------------------------
+    // Observers
+    //--------------------------------------------------------------------------
+  public:
+
+    /// \{
+    /// \brief Gets the underlying error
+    ///
+    /// \return the underlying error
+    RESULT_CPP14_CONSTEXPR
+    auto error() & noexcept
+      -> typename std::add_lvalue_reference<E>::type;
+    RESULT_CPP14_CONSTEXPR
+    auto error() && noexcept
+      -> typename std::add_rvalue_reference<E>::type;
+    constexpr auto error() const & noexcept
+      -> typename std::add_lvalue_reference<typename std::add_const<E>::type>::type;
+    constexpr auto error() const && noexcept
+      -> typename std::add_rvalue_reference<typename std::add_const<E>::type>::type;
+    /// \}
+
+    //-------------------------------------------------------------------------
+    // Private Member Types
+    //-------------------------------------------------------------------------
+  private:
+
+    using underlying_type = detail::wrapped_result_type<E>;
+
+    //-------------------------------------------------------------------------
+    // Private Members
+    //-------------------------------------------------------------------------
+  private:
+
+    underlying_type m_failure;
+  };
+
+#if __cplusplus >= 201703L
+  template <typename T>
+  failure(std::reference_wrapper<T>) -> failure<T&>;
+
+  template <typename T>
+  failure(T&&) -> failure<typename std::decay<T>::type>;
+#endif
+
+  //===========================================================================
+  // non-member functions : class : failure
+  //===========================================================================
+
+  //---------------------------------------------------------------------------
+  // Comparison
+  //---------------------------------------------------------------------------
+
+  template <typename E1, typename E2>
+  constexpr auto operator==(const failure<E1>& lhs,
+                            const failure<E2>& rhs) noexcept -> bool;
+  template <typename E1, typename E2>
+  constexpr auto operator!=(const failure<E1>& lhs,
+                            const failure<E2>& rhs) noexcept -> bool;
+  template <typename E1, typename E2>
+  constexpr auto operator<(const failure<E1>& lhs,
+                           const failure<E2>& rhs) noexcept -> bool;
+  template <typename E1, typename E2>
+  constexpr auto operator>(const failure<E1>& lhs,
+                           const failure<E2>& rhs) noexcept -> bool;
+  template <typename E1, typename E2>
+  constexpr auto operator<=(const failure<E1>& lhs,
+                            const failure<E2>& rhs) noexcept -> bool;
+  template <typename E1, typename E2>
+  constexpr auto operator>=(const failure<E1>& lhs,
+                            const failure<E2>& rhs) noexcept -> bool;
+
+  //---------------------------------------------------------------------------
+  // Utilities
+  //---------------------------------------------------------------------------
+
+  /// \brief Deduces and constructs a failure type from \p e
+  ///
+  /// \param e the failure value
+  /// \return a constructed failure value
+  template <typename E>
+  RESULT_WARN_UNUSED
+  constexpr auto fail(E&& e)
+    noexcept(std::is_nothrow_constructible<typename std::decay<E>::type,E>::value)
+    -> failure<typename std::decay<E>::type>;
+
+  /// \brief Deduces a failure reference from a reverence_wrapper
+  ///
+  /// \param e the failure value
+  /// \return a constructed failure reference
+  template <typename E>
+  RESULT_WARN_UNUSED
+  constexpr auto fail(std::reference_wrapper<E> e)
+    noexcept -> failure<E&>;
+
+  /// \brief Constructs a failure type from a series of arguments
+  ///
+  /// \tparam E the failure type
+  /// \param args the arguments to forward to E's constructor
+  /// \return a constructed failure type
+  template <typename E, typename...Args,
+            typename = typename std::enable_if<std::is_constructible<E,Args...>::value>::type>
+  RESULT_WARN_UNUSED
+  constexpr auto fail(Args&&...args)
+    noexcept(std::is_nothrow_constructible<E, Args...>::value)
+    -> failure<E>;
+
+  /// \brief Constructs a failure type from an initializer list and series of
+  ///        arguments
+  ///
+  /// \tparam E the failure type
+  /// \param args the arguments to forward to E's constructor
+  /// \return a constructed failure type
+  template <typename E, typename U, typename...Args,
+            typename = typename std::enable_if<std::is_constructible<E,std::initializer_list<U>,Args...>::value>::type>
+  RESULT_WARN_UNUSED
+  constexpr auto fail(std::initializer_list<U> ilist, Args&&...args)
+    noexcept(std::is_nothrow_constructible<E, std::initializer_list<U>, Args...>::value)
+    -> failure<E>;
+
+  /// \brief Swaps the contents of two failure values
+  ///
+  /// \param lhs the left failure
+  /// \param rhs the right failure
+  template <typename E>
+  auto swap(failure<E>& lhs, failure<E>& rhs)
+#if __cplusplus >= 201703L
+    noexcept(std::is_nothrow_swappable<E>::value) -> void;
+#else
+    noexcept(std::is_nothrow_move_constructible<E>::value) -> void;
+#endif
+
+  namespace detail {
+
+    //=========================================================================
+    // class : unit
+    //=========================================================================
+
+    /// \brief A standalone monostate object (effectively std::monostate). This
+    ///        exists to allow for `void` specializations
+    struct unit {};
+
+    //=========================================================================
+    // non-member functions : class : unit
+    //=========================================================================
+
+    constexpr auto operator==(unit, unit) noexcept -> bool { return true; }
+    constexpr auto operator!=(unit, unit) noexcept -> bool { return false; }
+    constexpr auto operator<(unit, unit) noexcept -> bool { return false; }
+    constexpr auto operator>(unit, unit) noexcept -> bool { return false; }
+    constexpr auto operator<=(unit, unit) noexcept -> bool { return true; }
+    constexpr auto operator>=(unit, unit) noexcept -> bool { return true; }
+
+    //=========================================================================
+    // class : detail::result_union<T, E, IsTrivial>
+    //=========================================================================
+
+    ///////////////////////////////////////////////////////////////////////////
+    /// \brief A basic utility that acts as a union containing the T and E
+    ///        types
+    ///
+    /// This is specialized on the case that both T and E are trivial, in which
+    /// case `result_union` is also trivial
+    ///
+    /// \tparam T the value type result to be returned
+    /// \tparam E the error type returned on failure
+    /// \tparam IsTrivial Whether or not both T and E are trivial
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T, typename E,
+              bool IsTrivial = std::is_trivially_destructible<T>::value &&
+                               std::is_trivially_destructible<E>::value>
+    struct result_union
+    {
+      //-----------------------------------------------------------------------
+      // Public Member Types
+      //-----------------------------------------------------------------------
+
+      using underlying_value_type = wrapped_result_type<T>;
+      using underlying_error_type = E;
+
+      //-----------------------------------------------------------------------
+      // Constructors / Assignment
+      //-----------------------------------------------------------------------
+
+      /// \brief Constructs an empty object
+      ///
+      /// This is for use with conversion constructors, since it allows a
+      /// temporary unused object to be set
+      result_union(unit) noexcept;
+
+      /// \brief Constructs the underlying value from the specified \p args
+      ///
+      /// \param args the arguments to forward to T's constructor
+      template <typename...Args>
+      constexpr result_union(in_place_t, Args&&...args)
+        noexcept(std::is_nothrow_constructible<T, Args...>::value);
+
+      /// \brief Constructs the underlying error from the specified \p args
+      ///
+      /// \param args the arguments to forward to E's constructor
+      template <typename...Args>
+      constexpr result_union(in_place_error_t, Args&&...args)
+        noexcept(std::is_nothrow_constructible<E, Args...>::value);
+
+      result_union(const result_union&) = default;
+      result_union(result_union&&) = default;
+
+      //-----------------------------------------------------------------------
+
+      auto operator=(const result_union&) -> result_union& = default;
+      auto operator=(result_union&&) -> result_union& = default;
+
+      //-----------------------------------------------------------------------
+      // Modifiers
+      //-----------------------------------------------------------------------
+
+      /// \brief A no-op for trivial types
+      auto destroy() const noexcept -> void;
+
+      //-----------------------------------------------------------------------
+      // Public Members
+      //-----------------------------------------------------------------------
+
+      union {
+        underlying_value_type m_value;
+        underlying_error_type m_error;
+        unit m_empty;
+      };
+      bool m_has_value;
+    };
+
+    //-------------------------------------------------------------------------
+
+    template <typename T, typename E>
+    struct result_union<T, E, false>
+    {
+      //-----------------------------------------------------------------------
+      // Public Member Types
+      //-----------------------------------------------------------------------
+
+      using underlying_value_type = wrapped_result_type<T>;
+      using underlying_error_type = E;
+
+      //-----------------------------------------------------------------------
+      // Constructors / Assignment / Destructor
+      //-----------------------------------------------------------------------
+
+      /// \brief Constructs an empty object
+      ///
+      /// This is for use with conversion constructors, since it allows a
+      /// temporary unused object to be set
+      result_union(unit) noexcept;
+
+      /// \brief Constructs the underlying value from the specified \p args
+      ///
+      /// \param args the arguments to forward to T's constructor
+      template <typename...Args>
+      constexpr result_union(in_place_t, Args&&...args)
+        noexcept(std::is_nothrow_constructible<T, Args...>::value);
+
+      /// \brief Constructs the underlying error from the specified \p args
+      ///
+      /// \param args the arguments to forward to E's constructor
+      template <typename...Args>
+      constexpr result_union(in_place_error_t, Args&&...args)
+        noexcept(std::is_nothrow_constructible<E, Args...>::value);
+
+      result_union(const result_union&) = default;
+      result_union(result_union&&) = default;
+
+      //-----------------------------------------------------------------------
+
+      /// \brief Destroys the underlying stored object
+      ~result_union()
+        noexcept(std::is_nothrow_destructible<T>::value &&
+                 std::is_nothrow_destructible<E>::value);
+
+      //-----------------------------------------------------------------------
+
+      auto operator=(const result_union&) -> result_union& = default;
+      auto operator=(result_union&&) -> result_union& = default;
+
+      //-----------------------------------------------------------------------
+      // Modifiers
+      //-----------------------------------------------------------------------
+
+      /// \brief Destroys the underlying stored object
+      auto destroy() -> void;
+
+      //-----------------------------------------------------------------------
+      // Public Members
+      //-----------------------------------------------------------------------
+
+      union {
+        underlying_value_type m_value;
+        underlying_error_type m_error;
+        unit m_empty;
+      };
+      bool m_has_value;
+    };
+
+    //=========================================================================
+    // class : result_construct_base<T, E>
+    //=========================================================================
+
+    ///////////////////////////////////////////////////////////////////////////
+    /// \brief Base class of assignment to enable construction and assignment
+    ///
+    /// This class is used with several pieces of construction to ensure
+    /// trivial constructibility and assignability:
+    ///
+    /// * `result_trivial_copy_ctor_base`
+    /// * `result_trivial_move_ctor_base`
+    /// * `result_copy_assign_base`
+    /// * `result_move_assign_base`
+    ///
+    /// \tparam T the value type
+    /// \tparam E the error type
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T, typename E>
+    struct result_construct_base
+    {
+      //-----------------------------------------------------------------------
+      // Constructors / Assignment
+      //-----------------------------------------------------------------------
+
+      /// \brief Constructs an empty object
+      ///
+      /// This is for use with conversion constructors, since it allows a
+      /// temporary unused object to be set
+      result_construct_base(unit) noexcept;
+
+      /// \brief Constructs the underlying value from the specified \p args
+      ///
+      /// \param args the arguments to forward to T's constructor
+      template <typename...Args>
+      constexpr result_construct_base(in_place_t, Args&&...args)
+        noexcept(std::is_nothrow_constructible<T, Args...>::value);
+
+      /// \brief Constructs the underlying error from the specified \p args
+      ///
+      /// \param args the arguments to forward to E's constructor
+      template <typename...Args>
+      constexpr result_construct_base(in_place_error_t, Args&&...args)
+        noexcept(std::is_nothrow_constructible<E, Args...>::value);
+
+      result_construct_base(const result_construct_base&) = default;
+      result_construct_base(result_construct_base&&) = default;
+
+      auto operator=(const result_construct_base&) -> result_construct_base& = default;
+      auto operator=(result_construct_base&&) -> result_construct_base& = default;
+
+      //-----------------------------------------------------------------------
+      // Construction / Assignment
+      //-----------------------------------------------------------------------
+
+      /// \brief Constructs the value type from \p args
+      ///
+      /// \note This is an implementation detail only meant to be used during
+      ///       construction
+      ///
+      /// \pre there is no contained value or error at the time of construction
+      ///
+      /// \param args the arguments to forward to T's constructor
+      template <typename...Args>
+      auto construct_value(Args&&...args)
+        noexcept(std::is_nothrow_constructible<T,Args...>::value) -> void;
+
+      /// \brief Constructs the error type from \p args
+      ///
+      /// \note This is an implementation detail only meant to be used during
+      ///       construction
+      ///
+      /// \pre there is no contained value or error at the time of construction
+      ///
+      /// \param args the arguments to forward to E's constructor
+      template <typename...Args>
+      auto construct_error(Args&&...args)
+        noexcept(std::is_nothrow_constructible<E,Args...>::value) -> void;
+
+      /// \brief Constructs the underlying error from the \p other result
+      ///
+      /// If \p other contains a value, then the T type will be
+      /// default-constructed.
+      ///
+      /// \note This is an implementation detail only meant to be used during
+      ///       construction of `result<void, E>` types
+      ///
+      /// \pre there is no contained value or error at the time of construction
+      ///
+      /// \param other the other result to construct
+      template <typename Result>
+      auto construct_error_from_result(Result&& other) -> void;
+
+      /// \brief Constructs the underlying type from a result object
+      ///
+      /// \note This is an implementation detail only meant to be used during
+      ///       construction
+      ///
+      /// \pre there is no contained value or error at the time of construction
+      ///
+      /// \param other the other result to construct
+      template <typename Result>
+      auto construct_from_result(Result&& other) -> void;
+
+      //-----------------------------------------------------------------------
+
+      template <typename Value>
+      auto assign_value(Value&& value)
+        noexcept(std::is_nothrow_assignable<T, Value>::value) -> void;
+
+      template <typename Error>
+      auto assign_error(Error&& error)
+        noexcept(std::is_nothrow_assignable<E, Error>::value) -> void;
+
+      template <typename Result>
+      auto assign_from_result(Result&& other) -> void;
+
+      //-----------------------------------------------------------------------
+
+      template <typename ReferenceWrapper>
+      auto construct_value_from_result_impl(std::true_type, ReferenceWrapper&& reference)
+        noexcept -> void;
+
+      template <typename Value>
+      auto construct_value_from_result_impl(std::false_type, Value&& value)
+        noexcept(std::is_nothrow_constructible<T,Value>::value) -> void;
+
+      template <typename Result>
+      auto assign_value_from_result_impl(std::true_type, Result&& other) -> void;
+
+      template <typename Result>
+      auto assign_value_from_result_impl(std::false_type, Result&& other) -> void;
+
+      //-----------------------------------------------------------------------
+      // Public Members
+      //-----------------------------------------------------------------------
+
+      using storage_type = result_union<T, E>;
+
+      storage_type storage;
+    };
+
+    //=========================================================================
+    // class : result_trivial_copy_ctor_base
+    //=========================================================================
+
+    template <typename T, typename E>
+    struct result_trivial_copy_ctor_base_impl : result_construct_base<T,E>
+    {
+      using base_type = result_construct_base<T,E>;
+      using base_type::base_type;
+
+      result_trivial_copy_ctor_base_impl(const result_trivial_copy_ctor_base_impl& other)
+        noexcept(std::is_nothrow_copy_constructible<T>::value &&
+                 std::is_nothrow_copy_constructible<E>::value);
+      result_trivial_copy_ctor_base_impl(result_trivial_copy_ctor_base_impl&& other) = default;
+
+      auto operator=(const result_trivial_copy_ctor_base_impl& other) -> result_trivial_copy_ctor_base_impl& = default;
+      auto operator=(result_trivial_copy_ctor_base_impl&& other) -> result_trivial_copy_ctor_base_impl& = default;
+    };
+
+    template <bool Condition, typename Base>
+    using conditionally_nest_type = typename std::conditional<
+      Condition,
+      typename Base::base_type,
+      Base
+    >::type;
+
+    template <typename T, typename E>
+    using result_trivial_copy_ctor_base = conditionally_nest_type<
+      std::is_trivially_copy_constructible<T>::value &&
+      std::is_trivially_copy_constructible<E>::value,
+      result_trivial_copy_ctor_base_impl<T,E>
+    >;
+
+    //=========================================================================
+    // class : result_trivial_move_ctor_base
+    //=========================================================================
+
+    template <typename T, typename E>
+    struct result_trivial_move_ctor_base_impl : result_trivial_copy_ctor_base<T,E>
+    {
+      using base_type = result_trivial_copy_ctor_base<T,E>;
+      using base_type::base_type;
+
+      result_trivial_move_ctor_base_impl(const result_trivial_move_ctor_base_impl& other) = default;
+      result_trivial_move_ctor_base_impl(result_trivial_move_ctor_base_impl&& other)
+        noexcept(std::is_nothrow_move_constructible<T>::value &&
+                 std::is_nothrow_move_constructible<E>::value);
+
+      auto operator=(const result_trivial_move_ctor_base_impl& other) -> result_trivial_move_ctor_base_impl& = default;
+      auto operator=(result_trivial_move_ctor_base_impl&& other) -> result_trivial_move_ctor_base_impl& = default;
+    };
+
+    template <typename T, typename E>
+    using result_trivial_move_ctor_base = conditionally_nest_type<
+      std::is_trivially_move_constructible<T>::value &&
+      std::is_trivially_move_constructible<E>::value,
+      result_trivial_move_ctor_base_impl<T,E>
+    >;
+
+    //=========================================================================
+    // class : result_trivial_copy_assign_base
+    //=========================================================================
+
+    template <typename T, typename E>
+    struct result_trivial_copy_assign_base_impl
+      : result_trivial_move_ctor_base<T, E>
+    {
+      using base_type = result_trivial_move_ctor_base<T,E>;
+      using base_type::base_type;
+
+      result_trivial_copy_assign_base_impl(const result_trivial_copy_assign_base_impl& other) = default;
+      result_trivial_copy_assign_base_impl(result_trivial_copy_assign_base_impl&& other) = default;
+
+      auto operator=(const result_trivial_copy_assign_base_impl& other)
+        noexcept(std::is_nothrow_copy_constructible<T>::value &&
+                 std::is_nothrow_copy_constructible<E>::value &&
+                 std::is_nothrow_copy_assignable<T>::value &&
+                 std::is_nothrow_copy_assignable<E>::value)
+        -> result_trivial_copy_assign_base_impl&;
+      auto operator=(result_trivial_copy_assign_base_impl&& other)
+        -> result_trivial_copy_assign_base_impl& = default;
+    };
+
+    template <typename T, typename E>
+    using result_trivial_copy_assign_base = conditionally_nest_type<
+      std::is_trivially_copy_constructible<T>::value &&
+      std::is_trivially_copy_constructible<E>::value &&
+      std::is_trivially_copy_assignable<T>::value &&
+      std::is_trivially_copy_assignable<E>::value &&
+      std::is_trivially_destructible<T>::value &&
+      std::is_trivially_destructible<E>::value,
+      result_trivial_copy_assign_base_impl<T,E>
+    >;
+
+    //=========================================================================
+    // class : result_trivial_move_assign_base
+    //=========================================================================
+
+    template <typename T, typename E>
+    struct result_trivial_move_assign_base_impl
+      : result_trivial_copy_assign_base<T, E>
+    {
+      using base_type = result_trivial_copy_assign_base<T,E>;
+      using base_type::base_type;
+
+      result_trivial_move_assign_base_impl(const result_trivial_move_assign_base_impl& other) = default;
+      result_trivial_move_assign_base_impl(result_trivial_move_assign_base_impl&& other) = default;
+
+      auto operator=(const result_trivial_move_assign_base_impl& other)
+        -> result_trivial_move_assign_base_impl& = default;
+      auto operator=(result_trivial_move_assign_base_impl&& other)
+        noexcept(std::is_nothrow_move_constructible<T>::value &&
+                 std::is_nothrow_move_constructible<E>::value &&
+                 std::is_nothrow_move_assignable<T>::value &&
+                 std::is_nothrow_move_assignable<E>::value)
+        -> result_trivial_move_assign_base_impl&;
+    };
+
+    template <typename T, typename E>
+    using result_trivial_move_assign_base = conditionally_nest_type<
+      std::is_trivially_move_constructible<T>::value &&
+      std::is_trivially_move_constructible<E>::value &&
+      std::is_trivially_move_assignable<T>::value &&
+      std::is_trivially_move_assignable<E>::value &&
+      std::is_trivially_destructible<T>::value &&
+      std::is_trivially_destructible<E>::value,
+      result_trivial_move_assign_base_impl<T,E>
+    >;
+
+    //=========================================================================
+    // class : disable_copy_ctor
+    //=========================================================================
+
+    template <typename T, typename E>
+    struct disable_copy_ctor : result_trivial_move_assign_base<T,E>
+    {
+      using base_type = result_trivial_move_assign_base<T,E>;
+      using base_type::base_type;
+
+      disable_copy_ctor(const disable_copy_ctor& other) = delete;
+      disable_copy_ctor(disable_copy_ctor&& other) = default;
+
+      auto operator=(const disable_copy_ctor& other)
+        -> disable_copy_ctor& = default;
+      auto operator=(disable_copy_ctor&& other)
+        -> disable_copy_ctor& = default;
+    };
+
+    template <typename T, typename E>
+    using result_copy_ctor_base = conditionally_nest_type<
+      std::is_copy_constructible<T>::value &&
+      std::is_copy_constructible<E>::value,
+      disable_copy_ctor<T,E>
+    >;
+
+    //=========================================================================
+    // class : disable_move_ctor
+    //=========================================================================
+
+    template <typename T, typename E>
+    struct disable_move_ctor : result_copy_ctor_base<T,E>
+    {
+      using base_type = result_copy_ctor_base<T,E>;
+      using base_type::base_type;
+
+      disable_move_ctor(const disable_move_ctor& other) = default;
+      disable_move_ctor(disable_move_ctor&& other) = delete;
+
+      auto operator=(const disable_move_ctor& other)
+        -> disable_move_ctor& = default;
+      auto operator=(disable_move_ctor&& other)
+        -> disable_move_ctor& = default;
+    };
+
+    template <typename T, typename E>
+    using result_move_ctor_base = conditionally_nest_type<
+      std::is_move_constructible<T>::value &&
+      std::is_move_constructible<E>::value,
+      disable_move_ctor<T,E>
+    >;
+
+    //=========================================================================
+    // class : disable_move_assignment
+    //=========================================================================
+
+    template <typename T, typename E>
+    struct disable_move_assignment
+      : result_move_ctor_base<T, E>
+    {
+      using base_type = result_move_ctor_base<T, E>;
+      using base_type::base_type;
+
+      disable_move_assignment(const disable_move_assignment& other) = default;
+      disable_move_assignment(disable_move_assignment&& other) = default;
+
+      auto operator=(const disable_move_assignment& other)
+        -> disable_move_assignment& = delete;
+      auto operator=(disable_move_assignment&& other)
+        -> disable_move_assignment& = default;
+    };
+
+    template <typename T, typename E>
+    using result_copy_assign_base = conditionally_nest_type<
+      std::is_nothrow_copy_constructible<T>::value &&
+      std::is_nothrow_copy_constructible<E>::value &&
+      std::is_copy_assignable<wrapped_result_type<T>>::value &&
+      std::is_copy_assignable<E>::value,
+      disable_move_assignment<T,E>
+    >;
+
+    //=========================================================================
+    // class : disable_copy_assignment
+    //=========================================================================
+
+    template <typename T, typename E>
+    struct disable_copy_assignment
+      : result_copy_assign_base<T, E>
+    {
+      using base_type = result_copy_assign_base<T, E>;
+      using base_type::base_type;
+
+      disable_copy_assignment(const disable_copy_assignment& other) = default;
+      disable_copy_assignment(disable_copy_assignment&& other) = default;
+
+      auto operator=(const disable_copy_assignment& other)
+        -> disable_copy_assignment& = default;
+      auto operator=(disable_copy_assignment&& other)
+        -> disable_copy_assignment& = delete;
+    };
+
+    template <typename T, typename E>
+    using result_move_assign_base = conditionally_nest_type<
+      std::is_nothrow_move_constructible<T>::value &&
+      std::is_nothrow_move_constructible<E>::value &&
+      std::is_move_assignable<wrapped_result_type<T>>::value &&
+      std::is_move_assignable<E>::value,
+      disable_copy_assignment<T,E>
+    >;
+
+    //=========================================================================
+    // alias : result_storage
+    //=========================================================================
+
+    template <typename T, typename E>
+    using result_storage = result_move_assign_base<T, E>;
+
+    //=========================================================================
+    // traits : result
+    //=========================================================================
+
+    template <typename T1, typename E1, typename T2, typename E2>
+    using result_is_convertible = std::integral_constant<bool,(
+      // T1 constructible from result<T2,E2>
+      std::is_constructible<T1, result<T2,E2>&>:: value ||
+      std::is_constructible<T1, const result<T2,E2>&>:: value ||
+      std::is_constructible<T1, result<T2,E2>&&>:: value ||
+      std::is_constructible<T1, const result<T2,E2>&&>:: value ||
+
+      // E1 constructible from result<T2,E2>
+      std::is_constructible<E1, result<T2,E2>&>:: value ||
+      std::is_constructible<E1, const result<T2,E2>&>:: value ||
+      std::is_constructible<E1, result<T2,E2>&&>:: value ||
+      std::is_constructible<E1, const result<T2,E2>&&>:: value ||
+
+      // result<T2,E2> convertible to T1
+      std::is_convertible<result<T2,E2>&, T1>:: value ||
+      std::is_convertible<const result<T2,E2>&, T1>:: value ||
+      std::is_convertible<result<T2,E2>&&, T1>::value ||
+      std::is_convertible<const result<T2,E2>&&, T1>::value ||
+
+      // result<T2,E2> convertible to E2
+      std::is_convertible<result<T2,E2>&, E1>:: value ||
+      std::is_convertible<const result<T2,E2>&, E1>:: value ||
+      std::is_convertible<result<T2,E2>&&, E1>::value ||
+      std::is_convertible<const result<T2,E2>&&, E1>::value
+    )>;
+
+    //-------------------------------------------------------------------------
+
+    template <typename T1, typename E1, typename T2, typename E2>
+    using result_is_copy_convertible = std::integral_constant<bool,(
+      !result_is_convertible<T1,E1,T2,E2>::value &&
+      std::is_constructible<T1, const T2&>::value &&
+      std::is_constructible<E1, const E2&>::value
+    )>;
+
+    template <typename T1, typename E1, typename T2, typename E2>
+    using result_is_implicit_copy_convertible = std::integral_constant<bool,(
+      result_is_copy_convertible<T1,E1,T2,E2>::value &&
+      std::is_convertible<const T2&, T1>::value &&
+      std::is_convertible<const E2&, E1>::value
+    )>;
+
+    template <typename T1, typename E1, typename T2, typename E2>
+    using result_is_explicit_copy_convertible = std::integral_constant<bool,(
+      result_is_copy_convertible<T1,E1,T2,E2>::value &&
+      (!std::is_convertible<const T2&, T1>::value ||
+       !std::is_convertible<const E2&, E1>::value)
+    )>;
+
+    //-------------------------------------------------------------------------
+
+    template <typename T1, typename E1, typename T2, typename E2>
+    using result_is_move_convertible = std::integral_constant<bool,(
+      !result_is_convertible<T1,E1,T2,E2>::value &&
+      std::is_constructible<T1, T2&&>::value &&
+      std::is_constructible<E1, E2&&>::value
+    )>;
+
+    template <typename T1, typename E1, typename T2, typename E2>
+    using result_is_implicit_move_convertible = std::integral_constant<bool,(
+      result_is_move_convertible<T1,E1,T2,E2>::value &&
+      std::is_convertible<T2&&, T1>::value &&
+      std::is_convertible<E2&&, E1>::value
+    )>;
+
+    template <typename T1, typename E1, typename T2, typename E2>
+    using result_is_explicit_move_convertible = std::integral_constant<bool,(
+      result_is_move_convertible<T1,E1,T2,E2>::value &&
+      (!std::is_convertible<T2&&, T1>::value ||
+       !std::is_convertible<E2&&, E1>::value)
+    )>;
+
+    //-------------------------------------------------------------------------
+
+    template <typename T, typename U>
+    using result_is_value_convertible = std::integral_constant<bool,(
+      std::is_constructible<T, U&&>::value &&
+      !std::is_same<typename std::decay<U>::type, in_place_t>::value &&
+      !std::is_same<typename std::decay<U>::type, in_place_error_t>::value &&
+      !is_result<typename std::decay<U>::type>::value
+    )>;
+
+    template <typename T, typename U>
+    using result_is_explicit_value_convertible = std::integral_constant<bool,(
+      result_is_value_convertible<T, U>::value &&
+      !std::is_convertible<U&&, T>::value
+    )>;
+
+    template <typename T, typename U>
+    using result_is_implicit_value_convertible = std::integral_constant<bool,(
+      result_is_value_convertible<T, U>::value &&
+      std::is_convertible<U&&, T>::value
+    )>;
+
+    //-------------------------------------------------------------------------
+
+    template <typename T1, typename E1, typename T2, typename E2>
+    using result_is_convert_assignable = std::integral_constant<bool,(
+      result_is_convertible<T1,E1,T2,E2>::value &&
+
+      std::is_assignable<T1&, result<T2,E2>&>::value &&
+      std::is_assignable<T1&, const result<T2,E2>&>::value &&
+      std::is_assignable<T1&, result<T2,E2>&&>::value &&
+      std::is_assignable<T1&, const result<T2,E2>&&>::value &&
+
+      std::is_assignable<E1&, result<T2,E2>&>::value &&
+      std::is_assignable<E1&, const result<T2,E2>&>::value &&
+      std::is_assignable<E1&, result<T2,E2>&&>::value &&
+      std::is_assignable<E1&, const result<T2,E2>&&>::value
+    )>;
+
+    template <typename T1, typename E1, typename T2, typename E2>
+    using result_is_copy_convert_assignable = std::integral_constant<bool,(
+      !result_is_convert_assignable<T1,E1,T2,E2>::value &&
+
+      std::is_nothrow_constructible<T1, const T2&>::value &&
+      std::is_assignable<wrapped_result_type<T1>&, const T2&>::value &&
+      std::is_nothrow_constructible<E1, const E2&>::value &&
+      std::is_assignable<E1&, const E2&>::value
+    )>;
+
+    template <typename T1, typename E1, typename T2, typename E2>
+    using result_is_move_convert_assignable = std::integral_constant<bool,(
+      !result_is_convert_assignable<T1,E1,T2,E2>::value &&
+
+      std::is_nothrow_constructible<T1, T2&&>::value &&
+      std::is_assignable<T1&, T2&&>::value &&
+      std::is_nothrow_constructible<E1, E2&&>::value &&
+      std::is_assignable<E1&, E2&&>::value
+    )>;
+
+    //-------------------------------------------------------------------------
+
+    template <typename T, typename U>
+    using result_is_value_assignable = std::integral_constant<bool,(
+      !is_result<typename std::decay<U>::type>::value &&
+      !is_failure<typename std::decay<U>::type>::value &&
+      std::is_nothrow_constructible<T,U>::value &&
+      std::is_assignable<wrapped_result_type<T>&,U>::value &&
+      (
+        !std::is_same<typename std::decay<U>::type,typename std::decay<T>::type>::value ||
+        !std::is_scalar<T>::value
+      )
+    )>;
+
+    template <typename E, typename E2>
+    using result_is_failure_assignable = std::integral_constant<bool,(
+      std::is_nothrow_constructible<E,E2>::value &&
+      std::is_assignable<E&,E2>::value
+    )>;
+
+    // Friending 'extract_error" below was causing some compilers to incorrectly
+    // identify `exp.m_storage.m_error` as being an access violation despite the
+    // friendship. Using a type name instead seems to be ubiquitous across
+    // compilers
+    struct result_error_extractor
+    {
+      template <typename T, typename E>
+      static constexpr auto get(const result<T,E>& exp) noexcept -> const E&;
+      template <typename T, typename E>
+      static constexpr auto get(result<T,E>& exp) noexcept -> E&;
+    };
+
+    template <typename T, typename E>
+    constexpr auto extract_error(const result<T,E>& exp) noexcept -> const E&;
+
+    template <typename E>
+    [[noreturn]]
+    auto throw_bad_result_access(E&& error) -> void;
+
+    template <typename String, typename E>
+    [[noreturn]]
+    auto throw_bad_result_access_message(String&& message, E&& error) -> void;
+
+  } // namespace detail
+
+  /////////////////////////////////////////////////////////////////////////////
+  /// \brief The class template `result` manages result results from APIs,
+  ///        while encoding possible failure conditions.
+  ///
+  /// A common use-case for result is the return value of a function that
+  /// may fail. As opposed to other approaches, such as `std::pair<T,bool>`
+  /// or `std::optional`, `result` more accurately conveys the intent of the
+  /// user along with the failure condition to the caller. This effectively
+  /// produces an orthogonal error handling mechanism that allows for exception
+  /// safety while also allowing discrete testability of the return type.
+  ///
+  /// `result<T,E>` types may contain a `T` value, which signifies that an
+  /// operation succeeded in producing the result value of type `T`. If an
+  /// `result` does not contain a `T` value, it will always contain an `E`
+  /// error condition instead.
+  ///
+  /// An `result<T,E>` can always be queried for a possible error case by
+  /// calling the `error()` function, even if it contains a value.
+  /// In the case that a `result<T,E>` contains a value object, this will
+  /// simply return an `E` object constructed through default aggregate
+  /// construction, as if through the expression `E{}`, which is assumed to be
+  /// a "valid" (no-error) state for an `E` type.
+  /// For example:
+  ///
+  /// * `std::error_code{}` produces a default-construct error-code, which is
+  ///   the "no error" state,
+  /// * integral (or enum) error codes produce a `0` value (no error), thanks to
+  ///   zero-initialization,
+  /// * `std::exception_ptr{}` produces a null-pointer,
+  /// * `std::string{}` produces an empty string `""`,
+  /// * etc.
+  ///
+  /// When a `result<T,E>` contains either a value or error, the storage for
+  /// that object is guaranteed to be allocated as part of the result
+  /// object's footprint, i.e. no dynamic memory allocation ever takes place.
+  /// Thus, a result object models an object, not a pointer, even though the
+  /// `operator*()` and `operator->()` are defined.
+  ///
+  /// When an object of type `result<T,E>` is contextually converted to
+  /// `bool`, the conversion returns `true` if the object contains a value and
+  /// `false` if it contains an error.
+  ///
+  /// `result` objects do not have a "valueless" state like `variant`s do.
+  /// Once a `result` has been constructed with a value or error, the
+  /// active underlying type can only be changed through assignment which may
+  /// is only enabled if construction is guaranteed to be *non-throwing*. This
+  /// ensures that a valueless state cannot occur naturally.
+  ///
+  /// Example Use:
+  /// \code
+  /// auto to_string(int x) -> result<std::string>
+  /// {
+  ///   try {
+  ///     return std::stoi(x);
+  ///   } catch (const std::invalid_argument&) {
+  ///     return fail(std::errc::invalid_argument);
+  ///   } catch (const std::std::out_of_range&) {
+  ///     return fail(std::errc::result_out_of_range);
+  ///   }
+  /// }
+  /// \endcode
+  ///
+  /// \note If using C++17 or above, `fail` can be replaced with
+  ///       `failure{...}` thanks to CTAD.
+  ///
+  /// \tparam T the underlying value type
+  /// \tparam E the underlying error type
+  ///////////////////////////////////////////////////////////////////////////
+  template <typename T, typename E>
+  class RESULT_NODISCARD result
+  {
+    // Type requirements
+
+    static_assert(
+      !std::is_abstract<T>::value,
+      "It is ill-formed for T to be abstract type"
+    );
+    static_assert(
+      !std::is_same<typename std::decay<T>::type, in_place_t>::value,
+      "It is ill-formed for T to be a (possibly CV-qualified) in_place_t type"
+    );
+    static_assert(
+      !is_result<typename std::decay<T>::type>::value,
+      "It is ill-formed for T to be a (possibly CV-qualified) 'result' type"
+    );
+    static_assert(
+      !is_failure<typename std::decay<T>::type>::value,
+      "It is ill-formed for T to be a (possibly CV-qualified) 'failure' type"
+    );
+    static_assert(
+      !std::is_rvalue_reference<T>::value,
+      "It is ill-formed for T to be an rvalue 'result type. "
+      "Only lvalue references are valid."
+    );
+
+    static_assert(
+      !std::is_abstract<E>::value,
+      "It is ill-formed for E to be abstract type"
+    );
+    static_assert(
+      !std::is_void<typename std::decay<E>::type>::value,
+      "It is ill-formed for E to be (possibly CV-qualified) void type"
+    );
+    static_assert(
+      !is_result<typename std::decay<E>::type>::value,
+      "It is ill-formed for E to be a (possibly CV-qualified) 'result' type"
+    );
+    static_assert(
+      !is_failure<typename std::decay<E>::type>::value,
+      "It is ill-formed for E to be a (possibly CV-qualified) 'failure' type"
+    );
+    static_assert(
+      !std::is_same<typename std::decay<E>::type, in_place_t>::value,
+      "It is ill-formed for E to be a (possibly CV-qualified) in_place_t type"
+    );
+    static_assert(
+      !std::is_reference<E>::value,
+      "It is ill-formed for E to be a reference type. "
+      "Only T types may be lvalue references"
+    );
+
+    // Friendship
+
+    friend detail::result_error_extractor;
+
+    template <typename T2, typename E2>
+    friend class result;
+
+    //-------------------------------------------------------------------------
+    // Public Member Types
+    //-------------------------------------------------------------------------
+  public:
+
+    using value_type = T; ///< The value type of this result
+    using error_type = E; ///< The error type of this result
+    using failure_type = failure<E>; ///< The failure type
+
+    template <typename U>
+    using rebind = result<U,E>; ///< Rebinds the result type
+
+    //-------------------------------------------------------------------------
+    // Constructor / Destructor / Assignment
+    //-------------------------------------------------------------------------
+  public:
+
+    /// \brief Default-constructs a result with the underlying value type
+    ///        active
+    ///
+    /// This constructor is only enabled if `T` is default-constructible
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// assert(cpp::result<std::string,int>{} == std::string{});
+    /// ```
+    template <typename U=T,
+              typename = typename std::enable_if<std::is_constructible<U>::value>::type>
+    constexpr result()
+      noexcept(std::is_nothrow_constructible<U>::value);
+
+    /// \brief Copy constructs this result
+    ///
+    /// If \p other contains a value, initializes the contained value as if
+    /// direct-initializing (but not direct-list-initializing) an object of
+    /// type `T` with the expression *other.
+    ///
+    /// If other contains an error, constructs an object that contains a copy
+    /// of that error.
+    ///
+    /// \note This constructor is defined as deleted if
+    ///       `std::is_copy_constructible<T>::value` or
+    ///       `std::is_copy_constructible<E>::value` is `false`
+    ///
+    /// \note This constructor is defined as trivial if both
+    ///       `std::is_trivially_copy_constructible<T>::value` and
+    ///       `std::is_trivially_copy_constructible<E>::value` are `true`
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// const auto r = cpp::result<int,int>{42};
+    /// const auto s = r;
+    ///
+    /// assert(r == s);
+    /// ```
+    ///
+    /// \param other the result to copy
+    constexpr result(const result& other) = default;
+
+    /// \brief Move constructs a result
+    ///
+    /// If other contains a value, initializes the contained value as if
+    /// direct-initializing (but not direct-list-initializing) an object
+    /// of type T with the expression `std::move(*other)` and does not make
+    /// other empty: a moved-from result still contains a value, but the
+    /// value itself is moved from.
+    ///
+    /// If other contains an error, move-constructs this result from that
+    /// error.
+    ///
+    /// \note This constructor is defined as deleted if
+    ///       `std::is_move_constructible<T>::value` or
+    ///       `std::is_move_constructible<E>::value` is `false`
+    ///
+    /// \note This constructor is defined as trivial if both
+    ///       `std::is_trivially_move_constructible<T>::value` and
+    ///       `std::is_trivially_move_constructible<E>::value` are `true`
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto r = cpp::result<std::string,int>{"hello world"};
+    /// auto s = std::move(r);
+    ///
+    /// assert(s == "hello world");
+    /// ```
+    ///
+    /// \param other the result to move
+    constexpr result(result&& other) = default;
+
+    /// \{
+    /// \brief Converting copy constructor
+    ///
+    /// If \p other contains a value, constructs a result object
+    /// that contains a value, initialized as if direct-initializing
+    /// (but not direct-list-initializing) an object of type `T` with the
+    /// expression `*other`.
+    ///
+    /// If \p other contains an error, constructs a result object that
+    /// contains an error, initialized as if direct-initializing
+    /// (but not direct-list-initializing) an object of type `E`.
+    ///
+    /// \note This constructor does not participate in overload resolution
+    ///       unless the following conditions are met:
+    ///       - `std::is_constructible_v<T, const U&>` is `true`
+    ///       - T is not constructible or convertible from any expression
+    ///         of type (possibly const) `result<T2,E2>`
+    ///       - E is not constructible or convertible from any expression
+    ///         of type (possible const) `result<T2,E2>`
+    ///
+    /// \note This constructor is explicit if and only if
+    ///       `std::is_convertible_v<const T2&, T>` or
+    ///       `std::is_convertible_v<const E2&, E>` is `false`
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// const auto r = cpp::result<int,int>{42};
+    /// const auto s = cpp::result<long,long>{r};
+    ///
+    /// assert(r == s);
+    /// ```
+    ///
+    /// \param other the other type to convert
+    template <typename T2, typename E2,
+              typename std::enable_if<detail::result_is_implicit_copy_convertible<T,E,T2,E2>::value,int>::type = 0>
+    result(const result<T2,E2>& other)
+      noexcept(std::is_nothrow_constructible<T,const T2&>::value &&
+               std::is_nothrow_constructible<E,const E2&>::value);
+    template <typename T2, typename E2,
+              typename std::enable_if<detail::result_is_explicit_copy_convertible<T,E,T2,E2>::value,int>::type = 0>
+    explicit result(const result<T2,E2>& other)
+      noexcept(std::is_nothrow_constructible<T,const T2&>::value &&
+               std::is_nothrow_constructible<E,const E2&>::value);
+    /// \}
+
+    /// \{
+    /// \brief Converting move constructor
+    ///
+    /// If \p other contains a value, constructs a result object
+    /// that contains a value, initialized as if direct-initializing
+    /// (but not direct-list-initializing) an object of type T with the
+    /// expression `std::move(*other)`.
+    ///
+    /// If \p other contains an error, constructs a result object that
+    /// contains an error, initialized as if direct-initializing
+    /// (but not direct-list-initializing) an object of type E&&.
+    ///
+    /// \note This constructor does not participate in overload resolution
+    ///       unless the following conditions are met:
+    ///       - `std::is_constructible_v<T, const U&>` is `true`
+    ///       - T is not constructible or convertible from any expression
+    ///         of type (possibly const) `result<T2,E2>`
+    ///       - E is not constructible or convertible from any expression
+    ///         of type (possible const) `result<T2,E2>`
+    ///
+    /// \note This constructor is explicit if and only if
+    ///       `std::is_convertible_v<const T2&, T>` or
+    ///       `std::is_convertible_v<const E2&, E>` is `false`
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto r = cpp::result<std::unique_ptr<Derived>,int>{
+    ///   std::make_unique<Derived>()
+    /// };
+    /// const auto s = cpp::result<std::unique_ptr<Base>,long>{
+    ///   std::move(r)
+    /// };
+    /// ```
+    ///
+    /// \param other the other type to convert
+    template <typename T2, typename E2,
+              typename std::enable_if<detail::result_is_implicit_move_convertible<T,E,T2,E2>::value,int>::type = 0>
+    result(result<T2,E2>&& other)
+      noexcept(std::is_nothrow_constructible<T,T2&&>::value &&
+               std::is_nothrow_constructible<E,E2&&>::value);
+    template <typename T2, typename E2,
+              typename std::enable_if<detail::result_is_explicit_move_convertible<T,E,T2,E2>::value,int>::type = 0>
+    explicit result(result<T2,E2>&& other)
+      noexcept(std::is_nothrow_constructible<T,T2&&>::value &&
+               std::is_nothrow_constructible<E,E2&&>::value);
+    /// \}
+
+    //-------------------------------------------------------------------------
+
+    /// \brief Constructs a result object that contains a value
+    ///
+    /// The value is initialized as if direct-initializing (but not
+    /// direct-list-initializing) an object of type `T` from the arguments
+    /// `std::forward<Args>(args)...`
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto r = cpp::result<std::string,int>{
+    ///   cpp::in_place, "Hello world"
+    /// };
+    /// ```
+    ///
+    /// \param args the arguments to pass to T's constructor
+    template <typename...Args,
+              typename = typename std::enable_if<std::is_constructible<T,Args...>::value>::type>
+    constexpr explicit result(in_place_t, Args&&... args)
+      noexcept(std::is_nothrow_constructible<T, Args...>::value);
+
+    /// \brief Constructs a result object that contains a value
+    ///
+    /// The value is initialized as if direct-initializing (but not
+    /// direct-list-initializing) an object of type `T` from the arguments
+    /// `std::forward<std::initializer_list<U>>(ilist)`,
+    /// `std::forward<Args>(args)...`
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto r = cpp::result<std::string,int>{
+    ///   cpp::in_place, {'H','e','l','l','o'}
+    /// };
+    /// ```
+    ///
+    /// \param ilist An initializer list of entries to forward
+    /// \param args  the arguments to pass to T's constructor
+    template <typename U, typename...Args,
+              typename = typename std::enable_if<std::is_constructible<T, std::initializer_list<U>&, Args...>::value>::type>
+    constexpr explicit result(in_place_t,
+                              std::initializer_list<U> ilist,
+                              Args&&...args)
+      noexcept(std::is_nothrow_constructible<T, std::initializer_list<U>, Args...>::value);
+
+    //-------------------------------------------------------------------------
+
+    /// \brief Constructs a result object that contains an error
+    ///
+    /// the value is initialized as if direct-initializing (but not
+    /// direct-list-initializing) an object of type `E` from the arguments
+    /// `std::forward<Args>(args)...`
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto r = cpp::result<int,std::string>{
+    ///   cpp::in_place_error, "Hello world"
+    /// };
+    /// ```
+    ///
+    /// \param args the arguments to pass to E's constructor
+    template <typename...Args,
+              typename = typename std::enable_if<std::is_constructible<E,Args...>::value>::type>
+    constexpr explicit result(in_place_error_t, Args&&... args)
+      noexcept(std::is_nothrow_constructible<E, Args...>::value);
+
+    /// \brief Constructs a result object that contains an error
+    ///
+    /// The value is initialized as if direct-initializing (but not
+    /// direct-list-initializing) an object of type `E` from the arguments
+    /// `std::forward<std::initializer_list<U>>(ilist)`,
+    /// `std::forward<Args>(args)...`
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto r = cpp::result<int,std::string>{
+    ///   cpp::in_place_error, {'H','e','l','l','o'}
+    /// };
+    /// ```
+    ///
+    /// \param ilist An initializer list of entries to forward
+    /// \param args  the arguments to pass to Es constructor
+    template <typename U, typename...Args,
+              typename = typename std::enable_if<std::is_constructible<E, std::initializer_list<U>&, Args...>::value>::type>
+    constexpr explicit result(in_place_error_t,
+                              std::initializer_list<U> ilist,
+                              Args&&...args)
+      noexcept(std::is_nothrow_constructible<E, std::initializer_list<U>, Args...>::value);
+
+    //-------------------------------------------------------------------------
+
+    /// \{
+    /// \brief Constructs the underlying error of this result
+    ///
+    /// \note This constructor only participates in overload resolution if
+    ///       `E` is constructible from \p e
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// cpp::result<int,int> r = cpp::fail(42);
+    ///
+    /// auto get_error_result() -> cpp::result<int,std::string> {
+    ///   return cpp::fail("hello world!");
+    /// }
+    /// ```
+    ///
+    /// \param e the failure error
+    template <typename E2,
+              typename = typename std::enable_if<std::is_constructible<E,const E2&>::value>::type>
+    constexpr /* implicit */ result(const failure<E2>& e)
+      noexcept(std::is_nothrow_constructible<E,const E2&>::value);
+    template <typename E2,
+              typename = typename std::enable_if<std::is_constructible<E,E2&&>::value>::type>
+    constexpr /* implicit */ result(failure<E2>&& e)
+      noexcept(std::is_nothrow_constructible<E,E2&&>::value);
+    /// \}
+
+    /// \{
+    /// \brief Constructs a result object that contains a value
+    ///
+    /// The value is initialized as if direct-initializing (but not
+    /// direct-list-initializing) an object of type T with the expression
+    /// value.
+    ///
+    /// \note This constructor is constexpr if the constructor of T
+    ///       selected by direct-initialization is constexpr
+    ///
+    /// \note This constructor does not participate in overload
+    ///       resolution unless `std::is_constructible_v<T, U&&>` is true
+    ///       and `decay_t<U>` is neither `in_place_t`, `in_place_error_t`,
+    ///       nor a `result` type.
+    ///
+    /// \note This constructor is explicit if and only if
+    ///       `std::is_convertible_v<U&&, T>` is `false`
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// cpp::result<int,int> r = 42;
+    ///
+    /// auto get_value() -> cpp::result<std::string,int> {
+    ///   return "hello world!"; // implicit conversion
+    /// }
+    /// ```
+    ///
+    /// \param value the value to copy
+    template <typename U,
+              typename std::enable_if<detail::result_is_explicit_value_convertible<T,U>::value,int>::type = 0>
+    constexpr explicit result(U&& value)
+      noexcept(std::is_nothrow_constructible<T,U>::value);
+    template <typename U,
+              typename std::enable_if<detail::result_is_implicit_value_convertible<T,U>::value,int>::type = 0>
+    constexpr /* implicit */ result(U&& value)
+      noexcept(std::is_nothrow_constructible<T,U>::value);
+    /// \}
+
+    //-------------------------------------------------------------------------
+
+    /// \brief Copy assigns the result stored in \p other
+    ///
+    /// \note This assignment operator only participates in overload resolution
+    ///       if the following conditions are met:
+    ///       - `std::is_nothrow_copy_constructible_v<T>` is `true`, and
+    ///       - `std::is_nothrow_copy_constructible_v<E>` is `true`
+    ///       this restriction guarantees that no '
+    ///
+    /// \note This assignment operator is defined as trivial if the following
+    ///       conditions are all `true`:
+    ///       - `std::is_trivially_copy_constructible<T>::value`
+    ///       - `std::is_trivially_copy_constructible<E>::value`
+    ///       - `std::is_trivially_copy_assignable<T>::value`
+    ///       - `std::is_trivially_copy_assignable<E>::value`
+    ///       - `std::is_trivially_destructible<T>::value`
+    ///       - `std::is_trivially_destructible<E>::value`
+    ///
+    /// \param other the other result to copy
+    auto operator=(const result& other) -> result& = default;
+
+    /// \brief Move assigns the result stored in \p other
+    ///
+    /// \note This assignment operator only participates in overload resolution
+    ///       if the following conditions are met:
+    ///       - `std::is_nothrow_copy_constructible_v<T>` is `true`, and
+    ///       - `std::is_nothrow_copy_constructible_v<E>` is `true`
+    ///       this restriction guarantees that no 'valueless_by_exception` state
+    ///       may occur.
+    ///
+    /// \note This assignment operator is defined as trivial if the following
+    ///       conditions are all `true`:
+    ///       - `std::is_trivially_move_constructible<T>::value`
+    ///       - `std::is_trivially_move_constructible<E>::value`
+    ///       - `std::is_trivially_move_assignable<T>::value`
+    ///       - `std::is_trivially_move_assignable<E>::value`
+    ///       - `std::is_trivially_destructible<T>::value`
+    ///       - `std::is_trivially_destructible<E>::value`
+    ///
+    /// \param other the other result to copy
+    auto operator=(result&& other) -> result& = default;
+
+    /// \brief Copy-converts the state of \p other
+    ///
+    /// If both `*this` and \p other contain either values or errors, the
+    /// underlying value is constructed as if through assignment.
+    ///
+    /// Otherwise if `*this` contains a value, but \p other contains an error,
+    /// then the contained value is destroyed by calling its destructor. `*this`
+    /// will no longer contain a value after the call, and will now contain `E`
+    /// constructed as if direct-initializing (but not direct-list-initializing)
+    /// an object with an argument of `const E2&`.
+    ///
+    /// If \p other contains a value and `*this` contains an error, then the
+    /// contained error is destroyed by calling its destructor. `*this` now
+    /// contains a value constructed as if direct-initializing (but not
+    /// direct-list-initializing) an object with an argument of `const T2&`.
+    ///
+    /// \note The function does not participate in overload resolution unless
+    ///       - `std::is_nothrow_constructible_v<T, const T2&>`,
+    ///         `std::is_assignable_v<T&, const T2&>`,
+    ///         `std::is_nothrow_constructible_v<E, const E2&>`,
+    ///         `std::is_assignable_v<E&, const E2&>` are all true.
+    ///       - T is not constructible, convertible, or assignable from any
+    ///         expression of type (possibly const) `result<T2,E2>`
+    ///
+    /// \param other the other result object to convert
+    /// \return reference to `(*this)`
+    template <typename T2, typename E2,
+              typename = typename std::enable_if<detail::result_is_copy_convert_assignable<T,E,T2,E2>::value>::type>
+    auto operator=(const result<T2,E2>& other)
+      noexcept(std::is_nothrow_assignable<T,const T2&>::value &&
+               std::is_nothrow_assignable<E,const E2&>::value) -> result&;
+
+    /// \brief Move-converts the state of \p other
+    ///
+    /// If both `*this` and \p other contain either values or errors, the
+    /// underlying value is constructed as if through move-assignment.
+    ///
+    /// Otherwise if `*this` contains a value, but \p other contains an error,
+    /// then the contained value is destroyed by calling its destructor. `*this`
+    /// will no longer contain a value after the call, and will now contain `E`
+    /// constructed as if direct-initializing (but not direct-list-initializing)
+    /// an object with an argument of `E2&&`.
+    ///
+    /// If \p other contains a value and `*this` contains an error, then the
+    /// contained error is destroyed by calling its destructor. `*this` now
+    /// contains a value constructed as if direct-initializing (but not
+    /// direct-list-initializing) an object with an argument of `T2&&`.
+    ///
+    /// \note The function does not participate in overload resolution unless
+    ///       - `std::is_nothrow_constructible_v<T, T2&&>`,
+    ///         `std::is_assignable_v<T&, T2&&>`,
+    ///         `std::is_nothrow_constructible_v<E, E2&&>`,
+    ///         `std::is_assignable_v<E&, E2&&>` are all true.
+    ///       - T is not constructible, convertible, or assignable from any
+    ///         expression of type (possibly const) `result<T2,E2>`
+    ///
+    /// \param other the other result object to convert
+    /// \return reference to `(*this)`
+    template <typename T2, typename E2,
+              typename = typename std::enable_if<detail::result_is_move_convert_assignable<T,E,T2,E2>::value>::type>
+    auto operator=(result<T2,E2>&& other)
+      noexcept(std::is_nothrow_assignable<T,T2&&>::value &&
+               std::is_nothrow_assignable<E,E2&&>::value) -> result&;
+
+    /// \brief Perfect-forwarded assignment
+    ///
+    /// Depending on whether `*this` contains a value before the call, the
+    /// contained value is either direct-initialized from std::forward<U>(value)
+    /// or assigned from std::forward<U>(value).
+    ///
+    /// \note The function does not participate in overload resolution unless
+    ///       - `std::decay_t<U>` is not a result type,
+    ///       - `std::decay_t<U>` is not a failure type
+    ///       - `std::is_nothrow_constructible_v<T, U>` is `true`
+    ///       - `std::is_assignable_v<T&, U>` is `true`
+    ///       - and at least one of the following is `true`:
+    ///           - `T` is not a scalar type;
+    ///           - `std::decay_t<U>` is not `T`.
+    ///
+    /// \param value to assign to the contained value
+    /// \return reference to `(*this)`
+    template <typename U,
+              typename = typename std::enable_if<detail::result_is_value_assignable<T,U>::value>::type>
+    auto operator=(U&& value)
+      noexcept(std::is_nothrow_assignable<T,U>::value) -> result&;
+
+    /// \{
+    /// \brief Perfect-forwarded assignment
+    ///
+    /// Depending on whether `*this` contains an error before the call, the
+    /// contained error is either direct-initialized via forwarding the error,
+    /// or assigned from forwarding the error
+    ///
+    /// \note The function does not participate in overload resolution unless
+    ///       - `std::is_nothrow_constructible_v<E, E2>` is `true`, and
+    ///       - `std::is_assignable_v<E&, E2>` is `true`
+    ///
+    /// \param other the failure value to assign to this
+    /// \return reference to `(*this)`
+    template <typename E2,
+              typename = typename std::enable_if<detail::result_is_failure_assignable<E,const E2&>::value>::type>
+    auto operator=(const failure<E2>& other)
+      noexcept(std::is_nothrow_assignable<E, const E2&>::value) -> result&;
+    template <typename E2,
+              typename = typename std::enable_if<detail::result_is_failure_assignable<E,E2&&>::value>::type>
+    auto operator=(failure<E2>&& other)
+      noexcept(std::is_nothrow_assignable<E, E2&&>::value) -> result&;
+    /// \}
+
+    //-------------------------------------------------------------------------
+    // Observers
+    //-------------------------------------------------------------------------
+  public:
+
+    /// \{
+    /// \brief Retrieves a pointer to the contained value
+    ///
+    /// This operator exists to give `result` an `optional`-like API for cases
+    /// where it's known that the `result` already contains a value.
+    ///
+    /// Care must be taken to ensure that this is only used in safe contexts
+    /// where a `T` value is active.
+    ///
+    /// \note The behavior is undefined if `*this` does not contain a value.
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto r = cpp::result<Widget,int>{
+    ///   make_widget()
+    /// };
+    ///
+    /// r->do_something();
+    /// ```
+    ///
+    /// \return a pointer to the contained value
+    RESULT_WARN_UNUSED
+    RESULT_CPP14_CONSTEXPR auto operator->()
+      noexcept -> typename std::remove_reference<T>::type*;
+    RESULT_WARN_UNUSED
+    constexpr auto operator->()
+      const noexcept -> typename std::remove_reference<typename std::add_const<T>::type>::type*;
+    /// \}
+
+    /// \{
+    /// \brief Retrieves a reference to the contained value
+    ///
+    /// This operator exists to give `result` an `optional`-like API for cases
+    /// where it's known that the `result` already contains a value.
+    ///
+    /// Care must be taken to ensure that this is only used in safe contexts
+    /// where a `T` value is active.
+    ///
+    /// \note The behaviour is undefined if `*this` does not contain a value
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto r = cpp::result<Widget,int>{
+    ///   make_widget()
+    /// };
+    ///
+    /// (*r).do_something();
+    ///
+    /// consume(*r);
+    /// ```
+    ///
+    /// \return a reference to the contained value
+    RESULT_WARN_UNUSED
+    RESULT_CPP14_CONSTEXPR auto operator*()
+      & noexcept -> typename std::add_lvalue_reference<T>::type;
+    RESULT_WARN_UNUSED
+    RESULT_CPP14_CONSTEXPR auto operator*()
+      && noexcept -> typename std::add_rvalue_reference<T>::type;
+    RESULT_WARN_UNUSED
+    constexpr auto operator*()
+      const& noexcept -> typename std::add_lvalue_reference<typename std::add_const<T>::type>::type;
+    RESULT_WARN_UNUSED
+    constexpr auto operator*()
+      const&& noexcept -> typename std::add_rvalue_reference<typename std::add_const<T>::type>::type;
+    /// \}
+
+    //-------------------------------------------------------------------------
+
+    /// \brief Contextually convertible to `true` if `*this` contains a value
+    ///
+    /// This function exists to allow for simple, terse checks for containing
+    /// a value.
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto get_result() -> cpp::result<int, int>;
+    /// auto r = get_result();
+    /// if (r) { ... }
+    ///
+    /// assert(static_cast<bool>(cpp::result<int,int>{42}));
+    ///
+    /// assert(!static_cast<bool>(cpp::result<int,int>{cpp::fail(42)}));
+    /// ```
+    ///
+    /// \return `true` if `*this` contains a value, `false` if `*this`
+    ///         does not contain a value
+    RESULT_WARN_UNUSED
+    constexpr explicit operator bool() const noexcept;
+
+    /// \brief Returns `true` if `*this` contains a value
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto get_result() -> cpp::result<int, int>;
+    /// auto r = get_result();
+    /// if (r.has_value()) { ... }
+    ///
+    /// assert(cpp::result<int,int>{42}.has_value());
+    ///
+    /// assert(!cpp::result<int,int>{cpp::fail(42)}.has_value());
+    /// ```
+    ///
+    /// \return `true` if `*this` contains a value, `false` if `*this`
+    ///         contains an error
+    RESULT_WARN_UNUSED
+    constexpr auto has_value() const noexcept -> bool;
+
+    /// \brief Returns `true` if `*this` contains an error
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto get_result() -> cpp::result<int, int>;
+    ///
+    /// auto r = get_result();
+    /// if (r.has_error()) { ... }
+    ///
+    /// assert(!cpp::result<int,int>{42}.has_error());
+    ///
+    /// assert(cpp::result<int,int>{cpp::fail(42)}.has_error());
+    /// ```
+    ///
+    /// \return `true` if `*this` contains an error, `false` if `*this`
+    ///          contains a value
+    RESULT_WARN_UNUSED
+    constexpr auto has_error() const noexcept -> bool;
+
+    //-------------------------------------------------------------------------
+
+    /// \{
+    /// \brief Returns a reference to the contained value
+    ///
+    /// This function provides checked (throwing) access to the underlying
+    /// value. The constness and refness of this result is propagated to the
+    /// underlying reference.
+    ///
+    /// If this contains an error, an exception is thrown containing the
+    /// underlying error. The error is consumed propagating the same constness
+    /// and refness of this result.
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// assert(cpp::result<int,int>{42}.value() == 42);
+    ///
+    /// auto r = cpp::result<std::unique_ptr<int>,int>{
+    ///   std::make_unique<int>(42)
+    /// };
+    /// auto s = std::move(r).value();
+    ///
+    /// try {
+    ///   auto r = cpp::result<int,int>{ cpp::fail(42) };
+    ///   auto v = r.value();
+    /// } catch (const cpp::bad_result_access<int>& e) {
+    ///   assert(e.error() == 42);
+    /// }
+    /// ```
+    ///
+    /// \throws bad_result_access<E> if `*this` does not contain a value.
+    ///
+    /// \return the value of `*this`
+    RESULT_WARN_UNUSED
+    RESULT_CPP14_CONSTEXPR auto value()
+      & -> typename std::add_lvalue_reference<T>::type;
+    RESULT_WARN_UNUSED
+    RESULT_CPP14_CONSTEXPR auto value()
+      && -> typename std::add_rvalue_reference<T>::type;
+    RESULT_WARN_UNUSED
+    constexpr auto value()
+      const & -> typename std::add_lvalue_reference<typename std::add_const<T>::type>::type;
+    RESULT_WARN_UNUSED
+    constexpr auto value()
+      const && -> typename std::add_rvalue_reference<typename std::add_const<T>::type>::type;
+    /// \}
+
+    /// \{
+    /// \brief Returns the contained error, if one exists, or a
+    ///        default-constructed error value
+    ///
+    /// The `error()` function will not throw any exceptions if `E` does not
+    /// throw any exceptions for the copy or move construction.
+    ///
+    /// This is to limit the possible scope for exceptions, and to allow the
+    /// error type to be treated as a "status"-like type, where the
+    /// default-constructed case is considered the "good" state.
+    ///
+    /// If this function is invoked on an rvalue of a result, the error is
+    /// returned via move-construction
+    ///
+    /// ### Requires
+    ///
+    /// * `std::is_default_constructible<E>::value` is `true`
+    /// * `std::is_copy_constructible<E>::value` or
+    ///   `std::is_move_constructible<E>::value` is `true`
+    /// * `E{}` represents the "good" (non-error) state
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto r = cpp::result<int,std::error_code>{ 42 };
+    /// assert(r.error() == std::error_code{});
+    ///
+    /// auto r = cpp::result<int,std::error_code>{
+    ///   cpp::fail(std::io_errc::stream)
+    /// };
+    ///
+    /// assert(r.error() == std::io_errc::stream);
+    /// ```
+    ///
+    /// \return the error or a default-constructed error value
+    RESULT_WARN_UNUSED
+    constexpr auto error() const &
+      noexcept(std::is_nothrow_constructible<E>::value &&
+               std::is_nothrow_copy_constructible<E>::value) -> E;
+    RESULT_WARN_UNUSED
+    RESULT_CPP14_CONSTEXPR auto error() &&
+      noexcept(std::is_nothrow_constructible<E>::value &&
+               std::is_nothrow_move_constructible<E>::value) -> E;
+    /// }
+
+    /// \{
+    /// \brief Asserts an expectation that this result contains an error,
+    ///        throwing a bad_result_access on failure
+    ///
+    /// If this function is invoked from an rvalue of `result`, then this will
+    /// consume the underlying error first, if there is one.
+    ///
+    /// \note This function exists as a means to allow for results to be marked
+    ///       `used` without requiring directly inspecting the underlying value.
+    ///       This is, in effect, equivalent to `assert(res.has_value())`,
+    ///       however it uses exceptions to ensure the stack can be unwound, and
+    ///       exceptions invoked.
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto start_service() -> cpp::result<void,int>;
+    ///
+    /// start_service().expect("Service failed to start!");
+    /// ```
+    ///
+    /// \param message the message to provide to this expectation
+    ///
+    /// \return the value of `*this`
+    template <typename String,
+            typename = typename std::enable_if<(
+                    std::is_convertible<String,const std::string&>::value &&
+                    std::is_copy_constructible<E>::value
+            )>::type>
+    RESULT_CPP14_CONSTEXPR auto expect(String&& message) & -> typename std::add_lvalue_reference<T>::type;
+    template <typename String,
+            typename = typename std::enable_if<(
+                    std::is_convertible<String,const std::string&>::value &&
+                    std::is_move_constructible<E>::value
+            )>::type>
+    RESULT_CPP14_CONSTEXPR auto expect(String&& message) && -> typename std::add_rvalue_reference<T>::type;
+    template <typename String,
+              typename = typename std::enable_if<(
+                std::is_convertible<String,const std::string&>::value &&
+                std::is_copy_constructible<E>::value
+              )>::type>
+    RESULT_CPP14_CONSTEXPR auto expect(String&& message) const & -> typename std::add_lvalue_reference<typename std::add_const<T>::type>::type;
+    template <typename String,
+            typename = typename std::enable_if<(
+                    std::is_convertible<String,const std::string&>::value &&
+                    std::is_copy_constructible<E>::value
+            )>::type>
+    RESULT_CPP14_CONSTEXPR auto expect(String&& message) const && -> typename std::add_rvalue_reference<typename std::add_const<T>::type>::type;
+    /// \}
+
+    //-------------------------------------------------------------------------
+    // Monadic Functionalities
+    //-------------------------------------------------------------------------
+  public:
+
+    /// \{
+    /// \brief Returns the contained value if `*this` has a value,
+    ///        otherwise returns \p default_value.
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto r = cpp::result<int,int>{42};
+    /// assert(r.value_or(0) == 42);
+    ///
+    /// auto r = cpp::result<int,int>{cpp::fail(42)};
+    /// assert(r.value_or(0) == 0);
+    /// ```
+    ///
+    /// \param default_value the value to use in case `*this` contains an error
+    /// \return the contained value or \p default_value
+    template <typename U>
+    RESULT_WARN_UNUSED
+    constexpr auto value_or(U&& default_value)
+      const & -> typename std::remove_reference<T>::type;
+    template <typename U>
+    RESULT_WARN_UNUSED
+    RESULT_CPP14_CONSTEXPR auto value_or(U&& default_value)
+      && -> typename std::remove_reference<T>::type;
+    /// \}
+
+    /// \{
+    /// \brief Returns the contained error if `*this` has an error,
+    ///        otherwise returns \p default_error.
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto r = cpp::result<int,int>{42};
+    /// assert(r.error_or(0) == cpp::fail(0));
+    ///
+    /// auto r = cpp::result<int,int>{cpp::fail(42)};
+    /// assert(r.error_or(0) == cpp::fail(42));
+    /// ```
+    ///
+    /// \param default_error the error to use in case `*this` is empty
+    /// \return the contained value or \p default_error
+    template <typename U>
+    RESULT_WARN_UNUSED
+    constexpr auto error_or(U&& default_error) const & -> error_type;
+    template <typename U>
+    RESULT_WARN_UNUSED
+    RESULT_CPP14_CONSTEXPR auto error_or(U&& default_error) && -> error_type;
+    /// \}
+
+    //-------------------------------------------------------------------------
+
+    /// \brief Returns a result containing \p value if this result contains
+    ///        a value, otherwise returns a result containing the current
+    ///        error.
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto r = cpp::result<int,int>{42};
+    /// assert(r.and_then(100) == 100);
+    ///
+    /// auto r = cpp::result<int,int>{cpp::fail(42)};
+    /// assert(r.and_then(100) == cpp::fail(42));
+    /// ```
+    ///
+    /// \param value the value to return as a result
+    /// \return a result of \p value if this contains a value
+    template <typename U>
+    RESULT_WARN_UNUSED
+    constexpr auto and_then(U&& value) const -> result<typename std::decay<U>::type,E>;
+
+    /// \{
+    /// \brief Invokes the function \p fn with the value of this result as
+    ///        the argument
+    ///
+    /// If this result contains an error, a result of the error is returned
+    ///
+    /// The function being called must return a `result` type or the program
+    /// is ill-formed
+    ///
+    /// If this is called on an rvalue of `result` which contains an error,
+    /// the returned `result` is constructed from an rvalue of that error.
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto to_string(int) -> cpp::result<std::string,int>;
+    /// auto r = cpp::result<int,int>{42};
+    /// assert(r.flat_map(to_string) == "42");
+    ///
+    /// auto r = cpp::result<int,int>{cpp::fail(42)};
+    /// assert(r.flat_map(to_string) == cpp::fail(42));
+    /// ```
+    ///
+    /// \param fn the function to invoke with this
+    /// \return The result of the function being called
+    template <typename Fn>
+    RESULT_WARN_UNUSED
+    constexpr auto flat_map(Fn&& fn) const & -> detail::invoke_result_t<Fn, const T&>;
+    template <typename Fn>
+    RESULT_WARN_UNUSED
+    RESULT_CPP14_CONSTEXPR auto flat_map(Fn&& fn) && -> detail::invoke_result_t<Fn, T&&>;
+    /// \}
+
+    /// \{
+    /// \brief Invokes the function \p fn with the value of this result as
+    ///        the argument
+    ///
+    /// If this result is an error, the result of this function is that
+    /// error. Otherwise this function wraps the result and returns it as an
+    /// result.
+    ///
+    /// If this is called on an rvalue of `result` which contains an error,
+    /// the returned `result` is constructed from an rvalue of that error.
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto to_string(int) -> std::string;
+    /// auto r = cpp::result<int,int>{42};
+    /// assert(r.map(to_string) == "42");
+    ///
+    /// auto r = cpp::result<int,int>{cpp::fail(42)};
+    /// assert(r.map(to_string) == cpp::fail(42));
+    /// ```
+    ///
+    /// \param fn the function to invoke with this
+    /// \return The result result of the function invoked
+    template <typename Fn>
+    RESULT_WARN_UNUSED
+    constexpr auto map(Fn&& fn) const & -> result<detail::invoke_result_t<Fn,const T&>,E>;
+    template <typename Fn>
+    RESULT_WARN_UNUSED
+    RESULT_CPP14_CONSTEXPR auto map(Fn&& fn) && -> result<detail::invoke_result_t<Fn,T&&>,E>;
+    /// \}
+
+    /// \{
+    /// \brief Invokes the function \p fn with the error of this result as
+    ///        the argument
+    ///
+    /// If this result contains a value, the result of this function is that
+    /// value. Otherwise the function is called with that error and returns the
+    /// result as a result.
+    ///
+    /// If this is called on an rvalue of `result` which contains a value,
+    /// the returned `result` is constructed from an rvalue of that value.
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto to_string(int) -> std::string;
+    /// auto r = cpp::result<int,int>{42};
+    /// assert(r.map_error(to_string) == 42);
+    ///
+    /// auto r = cpp::result<int,int>{cpp::fail(42)};
+    /// assert(r.map_error(to_string) == cpp::fail("42"));
+    ///
+    /// auto r = cpp::result<std::string,int>{};
+    /// auto s = r.map(std::string::size); // 's' contains 'result<size_t,int>'
+    /// ```
+    ///
+    /// \param fn the function to invoke with this
+    /// \return The result result of the function invoked
+    template <typename Fn>
+    RESULT_WARN_UNUSED
+    constexpr auto map_error(Fn&& fn)
+      const & -> result<T, detail::invoke_result_t<Fn,const E&>>;
+    template <typename Fn>
+    RESULT_WARN_UNUSED
+    RESULT_CPP14_CONSTEXPR auto map_error(Fn&& fn)
+      && -> result<T, detail::invoke_result_t<Fn,E&&>>;
+    /// \}
+
+    /// \{
+    /// \brief Invokes the function \p fn with the error of this result as
+    ///        the argument
+    ///
+    /// If this result contains a value, a result of the value is returned
+    ///
+    /// The function being called must return a `result` type or the program
+    /// is ill-formed
+    ///
+    /// If this is called on an rvalue of `result` which contains an error,
+    /// the returned `result` is constructed from an rvalue of that error.
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto to_string(int) -> cpp::result<int,std::string>;
+    /// auto r = cpp::result<int,int>{42};
+    /// assert(r.flat_map(to_string) == 42);
+    ///
+    /// auto r = cpp::result<int,int>{cpp::fail(42)};
+    /// assert(r.flat_map(to_string) == cpp::fail("42"));
+    /// ```
+    ///
+    /// \param fn the function to invoke with this
+    /// \return The result of the function being called
+    template <typename Fn>
+    RESULT_WARN_UNUSED
+    constexpr auto flat_map_error(Fn&& fn)
+      const & -> detail::invoke_result_t<Fn, const E&>;
+    template <typename Fn>
+    RESULT_WARN_UNUSED
+    RESULT_CPP14_CONSTEXPR auto flat_map_error(Fn&& fn)
+      && -> detail::invoke_result_t<Fn, E&&>;
+    /// \}
+
+    //-------------------------------------------------------------------------
+    // Private Members
+    //-------------------------------------------------------------------------
+  private:
+
+    detail::result_storage<T,E> m_storage;
+
+    //-------------------------------------------------------------------------
+    // Private Monadic Functions
+    //-------------------------------------------------------------------------
+  private:
+
+    /// \{
+    /// \brief Map implementations for void and non-void functions
+    ///
+    /// \param fn the function
+    template <typename Fn>
+    constexpr auto map_impl(std::true_type, Fn&& fn) const & -> result<void,E>;
+    template <typename Fn>
+    constexpr auto map_impl(std::false_type, Fn&& fn) const & -> result<detail::invoke_result_t<Fn,const T&>,E>;
+    template <typename Fn>
+    RESULT_CPP14_CONSTEXPR auto map_impl(std::true_type, Fn&& fn) && -> result<void,E>;
+    template <typename Fn>
+    RESULT_CPP14_CONSTEXPR auto map_impl(std::false_type, Fn&& fn) && -> result<detail::invoke_result_t<Fn,T&&>,E>;
+    /// \}
+  };
+
+  //===========================================================================
+  // class : result<void,E>
+  //===========================================================================
+
+  /////////////////////////////////////////////////////////////////////////////
+  /// \brief Partial specialization of `result<void, E>`
+  ///
+  /// \tparam E the underlying error type
+  /////////////////////////////////////////////////////////////////////////////
+  template <typename E>
+  class RESULT_NODISCARD result<void,E>
+  {
+    // Type requirements
+
+    static_assert(
+      !std::is_void<typename std::decay<E>::type>::value,
+      "It is ill-formed for E to be (possibly CV-qualified) void type"
+    );
+    static_assert(
+      !std::is_abstract<E>::value,
+      "It is ill-formed for E to be abstract type"
+    );
+    static_assert(
+      !is_failure<typename std::decay<E>::type>::value,
+      "It is ill-formed for E to be a (possibly CV-qualified) 'failure' type"
+    );
+    static_assert(
+      !std::is_reference<E>::value,
+      "It is ill-formed for E to be a reference type. "
+      "Only T types may be lvalue references"
+    );
+
+    // Friendship
+
+    friend detail::result_error_extractor;
+
+    template <typename T2, typename E2>
+    friend class result;
+
+    //-------------------------------------------------------------------------
+    // Public Member Types
+    //-------------------------------------------------------------------------
+  public:
+
+    using value_type = void; ///< The value type of this result
+    using error_type = E;    ///< The error type of this result
+    using failure_type = failure<E>; ///< The failure type
+
+    template <typename U>
+    using rebind = result<U,E>; ///< Rebinds the result type
+
+    //-------------------------------------------------------------------------
+    // Constructor / Assignment
+    //-------------------------------------------------------------------------
+  public:
+
+    /// \brief Constructs a `result` object in a value state
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto r = cpp::result<void,int>{};
+    /// ```
+    constexpr result() noexcept;
+
+    /// \brief Copy constructs this result
+    ///
+    /// If other contains an error, constructs an object that contains a copy
+    /// of that error.
+    ///
+    /// \note This constructor is defined as deleted if
+    ///       `std::is_copy_constructible<E>::value` is `false`
+    ///
+    /// \note This constructor is defined as trivial if both
+    ///       `std::is_trivially_copy_constructible<E>::value` are `true`
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// const auto r = cpp::result<void,int>{};
+    /// const auto s = r;
+    /// ```
+    ///
+    /// \param other the result to copy
+    constexpr result(const result& other) = default;
+
+    /// \brief Move constructs a result
+    ///
+    /// If other contains an error, move-constructs this result from that
+    /// error.
+    ///
+    /// \note This constructor is defined as deleted if
+    ///       `std::is_move_constructible<E>::value` is `false`
+    ///
+    /// \note This constructor is defined as trivial if both
+    ///       `std::is_trivially_move_constructible<E>::value` are `true`
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto r = cpp::result<void,std::string>{};
+    /// auto s = std::move(r);
+    /// ```
+    ///
+    /// \param other the result to move
+    constexpr result(result&& other) = default;
+
+    /// \brief Converting copy constructor
+    ///
+    /// If \p other contains a value, constructs a result object that is not
+    /// in an error state -- ignoring the value.
+    ///
+    /// If \p other contains an error, constructs a result object that
+    /// contains an error, initialized as if direct-initializing
+    /// (but not direct-list-initializing) an object of type `E`.
+    ///
+    /// \note This constructor does not participate in overload resolution
+    ///       unless the following conditions are met:
+    ///       - `std::is_constructible_v<E, const E2&>` is `true`
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// const auto r = cpp::result<int,int>{42};
+    /// const auto s = cpp::result<void,int>{r};
+    /// ```
+    ///
+    /// \param other the other type to convert
+    template <typename U, typename E2,
+              typename = typename std::enable_if<std::is_constructible<E,E2>::value>::type>
+    explicit result(const result<U,E2>& other)
+      noexcept(std::is_nothrow_constructible<E,const E2&>::value);
+
+    /// \brief Converting move constructor
+    ///
+    /// If \p other contains an error, constructs a result object that
+    /// contains an error, initialized as if direct-initializing
+    /// (but not direct-list-initializing) an object of type E&&.
+    ///
+    /// \note This constructor does not participate in overload resolution
+    ///       unless the following conditions are met:
+    ///       - `std::is_constructible_v<E, const E2&>` is `true`
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto r = cpp::result<int,std::string>{42};
+    /// auto s = cpp::result<void,std::string>{
+    ///   std::move(r)
+    /// };
+    /// ```
+    ///
+    /// \param other the other type to convert
+    template <typename U, typename E2,
+              typename = typename std::enable_if<std::is_constructible<E,E2>::value>::type>
+    explicit result(result<U,E2>&& other)
+      noexcept(std::is_nothrow_constructible<E,E2&&>::value);
+
+    //-------------------------------------------------------------------------
+
+    /// \brief Constructs a result object in a value state
+    ///
+    /// This constructor exists primarily for symmetry with the `result<T,E>`
+    /// constructor. Unlike the `T` overload, no variadic arguments may be
+    /// supplied.
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto r = cpp::result<void,std::string>{cpp::in_place};
+    /// ```
+    constexpr explicit result(in_place_t) noexcept;
+
+    /// \brief Constructs a result object that contains an error
+    ///
+    /// the value is initialized as if direct-initializing (but not
+    /// direct-list-initializing) an object of type `E` from the arguments
+    /// `std::forward<Args>(args)...`
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto r = cpp::result<void,std::string>{
+    ///   cpp::in_place_error, "Hello world"
+    /// };
+    /// ```
+    ///
+    /// \param args the arguments to pass to `E`'s constructor
+    template <typename...Args,
+              typename = typename std::enable_if<std::is_constructible<E,Args...>::value>::type>
+    constexpr explicit result(in_place_error_t, Args&&... args)
+      noexcept(std::is_nothrow_constructible<E, Args...>::value);
+
+    /// \brief Constructs a result object that contains an error
+    ///
+    /// The value is initialized as if direct-initializing (but not
+    /// direct-list-initializing) an object of type `E` from the arguments
+    /// `std::forward<std::initializer_list<U>>(ilist)`,
+    /// `std::forward<Args>(args)...`
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto r = cpp::result<void,std::string>{
+    ///   cpp::in_place_error, {'H','e','l','l','o'}
+    /// };
+    /// ```
+    ///
+    /// \param ilist An initializer list of entries to forward
+    /// \param args  the arguments to pass to Es constructor
+    template <typename U, typename...Args,
+              typename = typename std::enable_if<std::is_constructible<E, std::initializer_list<U>&, Args...>::value>::type>
+    constexpr explicit result(in_place_error_t,
+                              std::initializer_list<U> ilist,
+                              Args&&...args)
+      noexcept(std::is_nothrow_constructible<E, std::initializer_list<U>, Args...>::value);
+
+    //-------------------------------------------------------------------------
+
+    /// \{
+    /// \brief Constructs the underlying error of this result
+    ///
+    /// \note This constructor only participates in overload resolution if
+    ///       `E` is constructible from \p e
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// cpp::result<void,int> r = cpp::fail(42);
+    ///
+    /// auto get_error_result() -> cpp::result<void,std::string> {
+    ///   return cpp::fail("hello world!");
+    /// }
+    /// ```
+    ///
+    /// \param e the failure error
+    template <typename E2,
+              typename = typename std::enable_if<std::is_constructible<E,const E2&>::value>::type>
+    constexpr /* implicit */ result(const failure<E2>& e)
+      noexcept(std::is_nothrow_constructible<E,const E2&>::value);
+    template <typename E2,
+              typename = typename std::enable_if<std::is_constructible<E,E2&&>::value>::type>
+    constexpr /* implicit */ result(failure<E2>&& e)
+      noexcept(std::is_nothrow_constructible<E,E2&&>::value);
+    /// \}
+
+    //-------------------------------------------------------------------------
+
+    /// \brief Copy assigns the result stored in \p other
+    ///
+    /// \note The function does not participate in overload resolution unless
+    ///       - `std::is_nothrow_copy_constructible_v<E>` is `true`
+    ///       this restriction guarantees that no 'valueless_by_exception` state
+    ///       may occur.
+    ///
+    /// \note This assignment operator is defined as trivial if the following
+    ///       conditions are all `true`:
+    ///       - `std::is_trivially_copy_constructible<E>::value`
+    ///       - `std::is_trivially_copy_assignable<E>::value`
+    ///       - `std::is_trivially_destructible<E>::value`
+    ///
+    /// \param other the other result to copy
+    auto operator=(const result& other) -> result& = default;
+
+    /// \brief Move assigns the result stored in \p other
+    ///
+    /// \note The function does not participate in overload resolution unless
+    ///       - `std::is_nothrow_copy_constructible_v<E>` is `true`
+    ///       this restriction guarantees that no 'valueless_by_exception` state
+    ///       may occur.
+    ///
+    /// \note This assignment operator is defined as trivial if the following
+    ///       conditions are all `true`:
+    ///       - `std::is_trivially_move_constructible<E>::value`
+    ///       - `std::is_trivially_move_assignable<E>::value`
+    ///       - `std::is_trivially_destructible<E>::value`
+    ///
+    /// \param other the other result to copy
+    auto operator=(result&& other) -> result& = default;
+
+    /// \brief Copy-converts the state of \p other
+    ///
+    /// If both this and \p other contain an error, the underlying error is
+    /// assigned through copy-assignment.
+    ///
+    /// If \p other contains a value state, this result is constructed in a
+    /// value state.
+    ///
+    /// If \p other contans an error state, and this contains a value state,
+    /// the underlying error is constructed through copy-construction.
+    ///
+    /// \note The function does not participate in overload resolution unless
+    ///       - `std::is_nothrow_constructible_v<E, const E2&>`,
+    ///         `std::is_assignable_v<E&, const E2&>` are all `true`.
+    ///
+    /// \param other the other result object to convert
+    /// \return reference to `(*this)`
+    template <typename E2,
+              typename = typename std::enable_if<std::is_nothrow_constructible<E,const E2&>::value &&
+                                                 std::is_assignable<E&,const E2&>::value>::type>
+    auto operator=(const result<void,E2>& other)
+      noexcept(std::is_nothrow_assignable<E, const E2&>::value) -> result&;
+
+    /// \brief Move-converts the state of \p other
+    ///
+    /// If both this and \p other contain an error, the underlying error is
+    /// assigned through move-assignment.
+    ///
+    /// If \p other contains a value state, this result is constructed in a
+    /// value state.
+    ///
+    /// If \p other contans an error state, and this contains a value state,
+    /// the underlying error is constructed through move-construction.
+    ///
+    /// \note The function does not participate in overload resolution unless
+    ///       - `std::is_nothrow_constructible_v<E, E2&&>`,
+    ///         `std::is_assignable_v<E&, E2&&>` are all `true`.
+    ///
+    /// \param other the other result object to convert
+    /// \return reference to `(*this)`
+    template <typename E2,
+              typename = typename std::enable_if<std::is_nothrow_constructible<E,E2&&>::value &&
+                                                 std::is_assignable<E&,E2&&>::value>::type>
+    auto operator=(result<void,E2>&& other)
+      noexcept(std::is_nothrow_assignable<E, E2&&>::value) -> result&;
+
+    /// \{
+    /// \brief Perfect-forwarded assignment
+    ///
+    /// Depending on whether `*this` contains an error before the call, the
+    /// contained error is either direct-initialized via forwarding the error,
+    /// or assigned from forwarding the error
+    ///
+    /// \note The function does not participate in overload resolution unless
+    ///       - `std::is_nothrow_constructible_v<E, E2>` is `true`, and
+    ///       - `std::is_assignable_v<E&, E2>` is `true`
+    ///
+    /// \param other the failure value to assign to this
+    /// \return reference to `(*this)`
+    template <typename E2,
+              typename = typename std::enable_if<detail::result_is_failure_assignable<E,const E2&>::value>::type>
+    auto operator=(const failure<E2>& other)
+      noexcept(std::is_nothrow_assignable<E, const E2&>::value) -> result&;
+    template <typename E2,
+              typename = typename std::enable_if<detail::result_is_failure_assignable<E,E2&&>::value>::type>
+    auto operator=(failure<E2>&& other)
+      noexcept(std::is_nothrow_assignable<E, E2&&>::value) -> result&;
+    /// \}
+
+    //-------------------------------------------------------------------------
+    // Observers
+    //-------------------------------------------------------------------------
+  public:
+
+
+    /// \brief Contextually convertible to `true` if `*this` does not contain
+    ///        an error
+    ///
+    /// This function exists to allow for simple, terse checks for containing
+    /// a value.
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto get_result() -> cpp::result<void, int>;
+    /// auto r = get_result();
+    /// if (r) { ... }
+    ///
+    /// assert(static_cast<bool>(cpp::result<void,int>{}));
+    ///
+    /// assert(!static_cast<bool>(cpp::result<void,int>{cpp::fail(42)}));
+    /// ```
+    ///
+    /// \return `true` if `*this` contains a value, `false` if `*this`
+    ///         does not contain a value
+    RESULT_WARN_UNUSED
+    constexpr explicit operator bool() const noexcept;
+
+    /// \copydoc result<T,E>::has_value
+    RESULT_WARN_UNUSED
+    constexpr auto has_value() const noexcept -> bool;
+
+    /// \copydoc result<T,E>::has_error
+    RESULT_WARN_UNUSED
+    constexpr auto has_error() const noexcept -> bool;
+
+    //-------------------------------------------------------------------------
+
+    /// \{
+    /// \brief Throws an exception if `(*this)` is in an error state
+    ///
+    /// This function exists for symmetry with `cpp::result<T,E>` objects where
+    /// `T` contains a value.
+    ///
+    /// If this contains an error, an exception is thrown containing the
+    /// underlying error. The error is consumed propagating the same constness
+    /// and refness of this result.
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// cpp::result<void,int>{}.value(); // no exception
+    ///
+    /// auto r = cpp::result<void,std::unique_ptr<int>>{
+    ///   cpp::fail(std::make_unique<int>(42))
+    /// };
+    /// std::move(r).value(); // throws bad_result_access<std::unique_ptr<int>>
+    ///
+    /// try {
+    ///   auto r = cpp::result<void,int>{ cpp::fail(42) }.value();
+    /// } catch (const cpp::bad_result_access<int>& e) {
+    ///   assert(e.error() == 42);
+    /// }
+    /// ```
+    ///
+    /// \throws bad_result_access<E> if `*this` does not contain a value.
+    RESULT_CPP14_CONSTEXPR auto value() && -> void;
+    RESULT_CPP14_CONSTEXPR auto value() const & -> void;
+    /// \}
+
+    /// \{
+    /// \copydoc result<T,E>::error
+    RESULT_WARN_UNUSED
+    constexpr auto error() const &
+      noexcept(std::is_nothrow_constructible<E>::value &&
+               std::is_nothrow_copy_constructible<E>::value) -> E;
+    RESULT_WARN_UNUSED
+    RESULT_CPP14_CONSTEXPR auto error() &&
+      noexcept(std::is_nothrow_constructible<E>::value &&
+               std::is_nothrow_copy_constructible<E>::value) -> E;
+    /// \}
+
+    /// \{
+    /// \copydoc result<T,E>::expect
+    template <typename String,
+              typename = typename std::enable_if<(
+                std::is_convertible<String,const std::string&>::value &&
+                std::is_copy_constructible<E>::value
+              )>::type>
+    RESULT_CPP14_CONSTEXPR auto expect(String&& message) const & -> void;
+    template <typename String,
+              typename = typename std::enable_if<(
+                std::is_convertible<String,const std::string&>::value &&
+                std::is_move_constructible<E>::value
+              )>::type>
+    RESULT_CPP14_CONSTEXPR auto expect(String&& message) && -> void;
+    /// \}
+
+    //-------------------------------------------------------------------------
+    // Monadic Functionalities
+    //-------------------------------------------------------------------------
+  public:
+
+    /// \{
+    /// \copydoc result<T,E>::error_or
+    template <typename U>
+    RESULT_WARN_UNUSED
+    constexpr auto error_or(U&& default_error) const & -> error_type;
+    template <typename U>
+    RESULT_WARN_UNUSED
+    RESULT_CPP14_CONSTEXPR auto error_or(U&& default_error) && -> error_type;
+    /// \}
+
+    //-------------------------------------------------------------------------
+
+    /// \copydoc result<T,E>::and_then
+    template <typename U>
+    RESULT_WARN_UNUSED
+    constexpr auto and_then(U&& value) const -> result<typename std::decay<U>::type,E>;
+
+    /// \{
+    /// \brief Invokes the function \p fn if `(*this)` contains no value
+    ///
+    /// If this result contains an error, a result of the error is returned
+    ///
+    /// The function being called must return a `result` type or the program
+    /// is ill-formed
+    ///
+    /// If this is called on an rvalue of `result` which contains an error,
+    /// the returned `result` is constructed from an rvalue of that error.
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto generate_int() -> cpp::result<int,int> { return 42; }
+    /// auto r = cpp::result<void,int>{};
+    /// assert(r.flat_map(generate_int) == 42);
+    ///
+    /// auto r = cpp::result<void,int>{cpp::fail(42)};
+    /// assert(r.flat_map(generate_int) == cpp::fail(42));
+    /// ```
+    ///
+    /// \param fn the function to invoke with this
+    /// \return The result of the function being called
+    template <typename Fn>
+    RESULT_WARN_UNUSED
+    constexpr auto flat_map(Fn&& fn) const & -> detail::invoke_result_t<Fn>;
+    template <typename Fn>
+    RESULT_WARN_UNUSED
+    RESULT_CPP14_CONSTEXPR auto flat_map(Fn&& fn) && -> detail::invoke_result_t<Fn>;
+    /// \}
+
+    /// \{
+    /// \brief Invokes the function \p fn if `(*this)` contains no value
+    ///
+    /// If this result is an error, the result of this function is that
+    /// error. Otherwise this function wraps the result and returns it as an
+    /// result.
+    ///
+    /// If this is called on an rvalue of `result` which contains an error,
+    /// the returned `result` is constructed from an rvalue of that error.
+    ///
+    /// ### Examples
+    ///
+    /// Basic Usage:
+    ///
+    /// ```cpp
+    /// auto generate_int() -> int { return 42; }
+    /// auto r = cpp::result<void,int>{};
+    /// assert(r.map(generate_int) == 42);
+    ///
+    /// auto r = cpp::result<void,int>{cpp::fail(42)};
+    /// assert(r.map(generate_int) == cpp::fail(42));
+    /// ```
+    ///
+    /// \param fn the function to invoke with this
+    /// \return The result result of the function invoked
+    template <typename Fn>
+    RESULT_WARN_UNUSED
+    constexpr auto map(Fn&& fn) const & -> result<detail::invoke_result_t<Fn>,E>;
+    template <typename Fn>
+    RESULT_WARN_UNUSED
+    RESULT_CPP14_CONSTEXPR auto map(Fn&& fn) && -> result<detail::invoke_result_t<Fn>,E>;
+    /// \}
+
+    /// \{
+    /// \copydoc result<T,E>::map_error
+    template <typename Fn>
+    constexpr auto map_error(Fn&& fn) const & -> result<void, detail::invoke_result_t<Fn,const E&>>;
+    template <typename Fn>
+    RESULT_CPP14_CONSTEXPR
+    auto map_error(Fn&& fn) && -> result<void, detail::invoke_result_t<Fn,E&&>>;
+    /// \}
+
+
+    /// \{
+    /// \copydoc result<T,E>::flat_map_error
+    template <typename Fn>
+    RESULT_WARN_UNUSED
+    constexpr auto flat_map_error(Fn&& fn) const & -> detail::invoke_result_t<Fn, const E&>;
+    template <typename Fn>
+    RESULT_WARN_UNUSED
+    RESULT_CPP14_CONSTEXPR auto flat_map_error(Fn&& fn) && -> detail::invoke_result_t<Fn, E&&>;
+    /// \}
+
+    //-------------------------------------------------------------------------
+    // Private Members
+    //-------------------------------------------------------------------------
+  private:
+
+    detail::result_storage<detail::unit,E> m_storage;
+
+    //-------------------------------------------------------------------------
+    // Private Monadic Functions
+    //-------------------------------------------------------------------------
+  private:
+
+    /// \{
+    /// \brief Map implementations for void and non-void functions
+    ///
+    /// \param fn the function
+    template <typename Fn>
+    constexpr auto map_impl(std::true_type, Fn&& fn) const & -> result<void,E>;
+    template <typename Fn>
+    constexpr auto map_impl(std::false_type, Fn&& fn) const & -> result<detail::invoke_result_t<Fn>,E>;
+    template <typename Fn>
+    RESULT_CPP14_CONSTEXPR auto map_impl(std::true_type, Fn&& fn) && -> result<void,E>;
+    template <typename Fn>
+    RESULT_CPP14_CONSTEXPR auto map_impl(std::false_type, Fn&& fn) && -> result<detail::invoke_result_t<Fn>,E>;
+    /// \}
+  };
+
+  //===========================================================================
+  // non-member functions : class : result
+  //===========================================================================
+
+  //---------------------------------------------------------------------------
+  // Comparison
+  //---------------------------------------------------------------------------
+
+  template <typename T1, typename E1, typename T2, typename E2>
+  constexpr auto operator==(const result<T1,E1>& lhs, const result<T2,E2>& rhs)
+    noexcept -> bool;
+  template <typename T1, typename E1, typename T2, typename E2>
+  constexpr auto operator!=(const result<T1,E1>& lhs, const result<T2,E2>& rhs)
+    noexcept -> bool;
+  template <typename T1, typename E1, typename T2, typename E2>
+  constexpr auto operator>=(const result<T1,E1>& lhs, const result<T2,E2>& rhs)
+    noexcept -> bool;
+  template <typename T1, typename E1, typename T2, typename E2>
+  constexpr auto operator<=(const result<T1,E1>& lhs, const result<T2,E2>& rhs)
+    noexcept -> bool;
+  template <typename T1, typename E1, typename T2, typename E2>
+  constexpr auto operator>(const result<T1,E1>& lhs, const result<T2,E2>& rhs)
+    noexcept -> bool;
+  template <typename T1, typename E1, typename T2, typename E2>
+  constexpr auto operator<(const result<T1,E1>& lhs, const result<T2,E2>& rhs)
+    noexcept -> bool;
+
+  //---------------------------------------------------------------------------
+
+  template <typename E1, typename E2>
+  constexpr auto operator==(const result<void,E1>& lhs, const result<void,E2>& rhs)
+    noexcept -> bool;
+  template <typename E1, typename E2>
+  constexpr auto operator!=(const result<void,E1>& lhs, const result<void,E2>& rhs)
+    noexcept -> bool;
+  template <typename E1, typename E2>
+  constexpr auto operator>=(const result<void,E1>& lhs, const result<void,E2>& rhs)
+    noexcept -> bool;
+  template <typename E1, typename E2>
+  constexpr auto operator<=(const result<void,E1>& lhs, const result<void,E2>& rhs)
+    noexcept -> bool;
+  template <typename E1, typename E2>
+  constexpr auto operator>(const result<void,E1>& lhs, const result<void,E2>& rhs)
+    noexcept -> bool;
+  template <typename E1, typename E2>
+  constexpr auto operator<(const result<void,E1>& lhs, const result<void,E2>& rhs)
+    noexcept -> bool;
+
+  //---------------------------------------------------------------------------
+
+  template <typename T, typename E, typename U,
+            typename = typename std::enable_if<!std::is_same<T,void>::value>::type>
+  constexpr auto operator==(const result<T,E>& exp, const U& value)
+    noexcept -> bool;
+  template <typename T, typename U, typename E,
+            typename = typename std::enable_if<!std::is_same<U,void>::value>::type>
+  constexpr auto operator==(const T& value, const result<U,E>& exp)
+    noexcept -> bool;
+  template <typename T, typename E, typename U,
+            typename = typename std::enable_if<!std::is_same<T,void>::value>::type>
+  constexpr auto operator!=(const result<T,E>& exp, const U& value)
+    noexcept -> bool;
+  template <typename T, typename U, typename E,
+            typename = typename std::enable_if<!std::is_same<U,void>::value>::type>
+  constexpr auto operator!=(const T& value, const result<U,E>& exp)
+    noexcept -> bool;
+  template <typename T, typename E, typename U,
+            typename = typename std::enable_if<!std::is_same<T,void>::value>::type>
+  constexpr auto operator<=(const result<T,E>& exp, const U& value)
+    noexcept -> bool;
+  template <typename T, typename U, typename E,
+            typename = typename std::enable_if<!std::is_same<U,void>::value>::type>
+  constexpr auto operator<=(const T& value, const result<U,E>& exp)
+    noexcept -> bool;
+  template <typename T, typename E, typename U,
+            typename = typename std::enable_if<!std::is_same<T,void>::value>::type>
+  constexpr auto operator>=(const result<T,E>& exp, const U& value)
+    noexcept -> bool;
+  template <typename T, typename U, typename E,
+            typename = typename std::enable_if<!std::is_same<U,void>::value>::type>
+  constexpr auto operator>=(const T& value, const result<U,E>& exp)
+    noexcept -> bool;
+  template <typename T, typename E, typename U,
+            typename = typename std::enable_if<!std::is_same<T,void>::value>::type>
+  constexpr auto operator<(const result<T,E>& exp, const U& value)
+    noexcept -> bool;
+  template <typename T, typename U, typename E,
+            typename = typename std::enable_if<!std::is_same<U,void>::value>::type>
+  constexpr auto operator<(const T& value, const result<U,E>& exp)
+    noexcept -> bool;
+  template <typename T, typename E, typename U,
+            typename = typename std::enable_if<!std::is_same<T,void>::value>::type>
+  constexpr auto operator>(const result<T,E>& exp, const U& value)
+    noexcept -> bool;
+  template <typename T, typename U, typename E,
+            typename = typename std::enable_if<!std::is_same<U,void>::value>::type>
+  constexpr auto operator>(const T& value, const result<U,E>& exp)
+    noexcept -> bool;
+
+  //---------------------------------------------------------------------------
+
+  template <typename T, typename E, typename U>
+  constexpr auto operator==(const result<T,E>& exp, const failure<U>& value)
+    noexcept -> bool;
+  template <typename T, typename U, typename E>
+  constexpr auto operator==(const failure<T>& value, const result<E,U>& exp)
+    noexcept -> bool;
+  template <typename T, typename E, typename U>
+  constexpr auto operator!=(const result<T,E>& exp, const failure<U>& value)
+    noexcept -> bool;
+  template <typename T, typename U, typename E>
+  constexpr auto operator!=(const failure<T>& value, const result<E,U>& exp)
+    noexcept -> bool;
+  template <typename T, typename E, typename U>
+  constexpr auto operator<=(const result<T,E>& exp, const failure<U>& value)
+    noexcept -> bool;
+  template <typename T, typename U, typename E>
+  constexpr auto operator<=(const failure<T>& value, const result<E,U>& exp)
+    noexcept -> bool;
+  template <typename T, typename E, typename U>
+  constexpr auto operator>=(const result<T,E>& exp, const failure<U>& value)
+    noexcept -> bool;
+  template <typename T, typename U, typename E>
+  constexpr auto operator>=(const failure<T>& value, const result<E,U>& exp)
+    noexcept -> bool;
+  template <typename T, typename E, typename U>
+  constexpr auto operator<(const result<T,E>& exp, const failure<U>& value)
+    noexcept -> bool;
+  template <typename T, typename U, typename E>
+  constexpr auto operator<(const failure<T>& value, const result<E,U>& exp)
+    noexcept -> bool;
+  template <typename T, typename E, typename U>
+  constexpr auto operator>(const result<T,E>& exp, const failure<U>& value)
+    noexcept -> bool;
+  template <typename T, typename U, typename E>
+  constexpr auto operator>(const failure<T>& value, const result<E,U>& exp)
+    noexcept -> bool;
+
+  //---------------------------------------------------------------------------
+  // Utilities
+  //---------------------------------------------------------------------------
+
+  /// \{
+  /// \brief Swaps the contents of \p lhs with \p rhs
+  ///
+  /// \param lhs the left result
+  /// \param rhs the right result
+  template <typename T, typename E>
+  auto swap(result<T,E>& lhs, result<T,E>& rhs)
+#if __cplusplus >= 201703L
+    noexcept(std::is_nothrow_move_constructible<result<T,E>>::value &&
+             std::is_nothrow_move_assignable<result<T,E>>::value &&
+             std::is_nothrow_swappable<T>::value &&
+             std::is_nothrow_swappable<E>::value)
+#else
+    noexcept(std::is_nothrow_move_constructible<result<T,E>>::value &&
+             std::is_nothrow_move_assignable<result<T,E>>::value)
+#endif
+    -> void;
+  template <typename E>
+  auto swap(result<void,E>& lhs, result<void,E>& rhs)
+#if __cplusplus >= 201703L
+    noexcept(std::is_nothrow_move_constructible<result<void,E>>::value &&
+             std::is_nothrow_move_assignable<result<void,E>>::value &&
+             std::is_nothrow_swappable<E>::value)
+#else
+    noexcept(std::is_nothrow_move_constructible<result<void,E>>::value &&
+             std::is_nothrow_move_assignable<result<void,E>>::value)
+#endif
+     -> void;
+  /// \}
+
+} // inline namespace bitwizeshift
+} // namespace EXPECTED_NAMESPACE
+
+namespace std {
+
+  template <typename T, typename E>
+  struct hash<::RESULT_NS_IMPL::result<T,E>>
+  {
+    auto operator()(const RESULT_NS_IMPL::result<T,E>& x) const -> std::size_t
+    {
+      if (x.has_value()) {
+        return std::hash<T>{}(*x) + 1; // add '1' to differentiate from error case
+      }
+      return std::hash<E>{}(::RESULT_NS_IMPL::detail::extract_error(x));
+    }
+  };
+
+  template <typename E>
+  struct hash<::RESULT_NS_IMPL::result<void,E>>
+  {
+    auto operator()(const RESULT_NS_IMPL::result<void,E>& x) const -> std::size_t
+    {
+      if (x.has_value()) {
+        return 0;
+      }
+      return std::hash<E>{}(::RESULT_NS_IMPL::detail::extract_error(x));
+    }
+  };
+
+} // namespace std
+
+#if !defined(RESULT_DISABLE_EXCEPTIONS)
+
+//=============================================================================
+// class : bad_result_access
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+// Constructors
+//-----------------------------------------------------------------------------
+
+template <typename E>
+template <typename E2, typename>
+inline RESULT_INLINE_VISIBILITY
+RESULT_NS_IMPL::bad_result_access<E>::bad_result_access(E2&& error)
+  : logic_error{"error attempting to access value from result containing error"},
+    m_error(detail::forward<E2>(error))
+{
+
+}
+
+template <typename E>
+template <typename E2, typename>
+inline RESULT_INLINE_VISIBILITY
+RESULT_NS_IMPL::bad_result_access<E>::bad_result_access(
+  const char* what_arg,
+  E2&& error
+) : logic_error{what_arg},
+    m_error(detail::forward<E2>(error))
+{
+
+}
+
+template <typename E>
+template <typename E2, typename>
+inline RESULT_INLINE_VISIBILITY
+RESULT_NS_IMPL::bad_result_access<E>::bad_result_access(
+  const std::string& what_arg,
+  E2&& error
+) : logic_error{what_arg},
+    m_error(detail::forward<E2>(error))
+{
+
+}
+
+//-----------------------------------------------------------------------------
+// Observers
+//-----------------------------------------------------------------------------
+
+template <typename E>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::bad_result_access<E>::error()
+  & noexcept -> E&
+{
+  return m_error;
+}
+
+template <typename E>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::bad_result_access<E>::error()
+  && noexcept -> E&&
+{
+  return static_cast<E&&>(m_error);
+}
+
+template <typename E>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::bad_result_access<E>::error()
+  const & noexcept -> const E&
+{
+  return m_error;
+}
+
+template <typename E>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::bad_result_access<E>::error()
+  const && noexcept -> const E&&
+{
+  return static_cast<const E&&>(m_error);
+}
+
+#endif
+
+//=============================================================================
+// class : failure
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+// Constructors
+//-----------------------------------------------------------------------------
+
+template <typename E>
+template <typename...Args, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+RESULT_NS_IMPL::failure<E>::failure(in_place_t, Args&&...args)
+  noexcept(std::is_nothrow_constructible<E, Args...>::value)
+  : m_failure(detail::forward<Args>(args)...)
+{
+
+}
+
+template <typename E>
+template <typename U, typename...Args, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+RESULT_NS_IMPL::failure<E>::failure(
+  in_place_t,
+  std::initializer_list<U> ilist,
+  Args&&...args
+) noexcept(std::is_nothrow_constructible<E, std::initializer_list<U>, Args...>::value)
+  : m_failure(ilist, detail::forward<Args>(args)...)
+{
+
+}
+
+template <typename E>
+template <typename E2,
+          typename std::enable_if<RESULT_NS_IMPL::detail::failure_is_explicit_value_convertible<E,E2>::value,int>::type>
+inline RESULT_INLINE_VISIBILITY constexpr
+RESULT_NS_IMPL::failure<E>::failure(E2&& error)
+  noexcept(std::is_nothrow_constructible<E,E2>::value)
+  : m_failure(detail::forward<E2>(error))
+{
+
+}
+
+template <typename E>
+template <typename E2,
+          typename std::enable_if<RESULT_NS_IMPL::detail::failure_is_implicit_value_convertible<E,E2>::value,int>::type>
+inline RESULT_INLINE_VISIBILITY constexpr
+RESULT_NS_IMPL::failure<E>::failure(E2&& error)
+  noexcept(std::is_nothrow_constructible<E,E2>::value)
+  : m_failure(detail::forward<E2>(error))
+{
+
+}
+
+template <typename E>
+template <typename E2, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+RESULT_NS_IMPL::failure<E>::failure(const failure<E2>& other)
+  noexcept(std::is_nothrow_constructible<E,const E2&>::value)
+  : m_failure(other.error())
+{
+
+}
+
+template <typename E>
+template <typename E2, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+RESULT_NS_IMPL::failure<E>::failure(failure<E2>&& other)
+  noexcept(std::is_nothrow_constructible<E,E2&&>::value)
+  : m_failure(static_cast<failure<E2>&&>(other).error())
+{
+
+}
+
+//-----------------------------------------------------------------------------
+
+template <typename E>
+template <typename E2, typename>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::failure<E>::operator=(E2&& error)
+  noexcept(
+    std::is_nothrow_assignable<E,E2>::value ||
+    std::is_lvalue_reference<E>::value
+  ) -> failure&
+{
+  m_failure = detail::forward<E2>(error);
+
+  return (*this);
+}
+
+template <typename E>
+template <typename E2, typename>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::failure<E>::operator=(const failure<E2>& other)
+  noexcept(std::is_nothrow_assignable<E,const E2&>::value)
+  -> failure&
+{
+  m_failure = other.error();
+
+  return (*this);
+}
+
+template <typename E>
+template <typename E2, typename>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::failure<E>::operator=(failure<E2>&& other)
+  noexcept(std::is_nothrow_assignable<E,E2&&>::value)
+  -> failure&
+{
+  m_failure = static_cast<failure<E2>&&>(other).error();
+
+  return (*this);
+}
+
+//-----------------------------------------------------------------------------
+// Observers
+//-----------------------------------------------------------------------------
+
+template <typename E>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::failure<E>::error()
+  & noexcept -> typename std::add_lvalue_reference<E>::type
+{
+  return m_failure;
+}
+
+template <typename E>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::failure<E>::error()
+  && noexcept -> typename std::add_rvalue_reference<E>::type
+{
+  using reference = typename std::add_rvalue_reference<E>::type;
+
+  return static_cast<reference>(m_failure);
+}
+
+template <typename E>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::failure<E>::error()
+  const & noexcept
+  -> typename std::add_lvalue_reference<typename std::add_const<E>::type>::type
+{
+  return m_failure;
+}
+
+template <typename E>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::failure<E>::error()
+  const && noexcept
+  -> typename std::add_rvalue_reference<typename std::add_const<E>::type>::type
+{
+  using reference = typename std::add_rvalue_reference<typename std::add_const<E>::type>::type;
+
+  return static_cast<reference>(m_failure);
+}
+
+//=============================================================================
+// non-member functions : class : failure
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+// Comparison
+//-----------------------------------------------------------------------------
+
+template <typename E1, typename E2>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator==(const failure<E1>& lhs, const failure<E2>& rhs)
+  noexcept -> bool
+{
+  return lhs.error() == rhs.error();
+}
+
+template <typename E1, typename E2>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator!=(const failure<E1>& lhs, const failure<E2>& rhs)
+  noexcept -> bool
+{
+  return lhs.error() != rhs.error();
+}
+
+template <typename E1, typename E2>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator<(const failure<E1>& lhs, const failure<E2>& rhs)
+  noexcept -> bool
+{
+  return lhs.error() < rhs.error();
+}
+
+template <typename E1, typename E2>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator>(const failure<E1>& lhs, const failure<E2>& rhs)
+  noexcept -> bool
+{
+  return lhs.error() > rhs.error();
+}
+
+template <typename E1, typename E2>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator<=(const failure<E1>& lhs, const failure<E2>& rhs)
+  noexcept -> bool
+{
+  return lhs.error() <= rhs.error();
+}
+
+template <typename E1, typename E2>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator>=(const failure<E1>& lhs, const failure<E2>& rhs)
+  noexcept -> bool
+{
+  return lhs.error() >= rhs.error();
+}
+
+//-----------------------------------------------------------------------------
+// Utilities
+//-----------------------------------------------------------------------------
+
+template <typename E>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::fail(E&& e)
+  noexcept(std::is_nothrow_constructible<typename std::decay<E>::type,E>::value)
+  -> failure<typename std::decay<E>::type>
+{
+  using result_type = failure<typename std::decay<E>::type>;
+
+  return result_type(
+    detail::forward<E>(e)
+  );
+}
+
+template <typename E>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::fail(std::reference_wrapper<E> e)
+  noexcept -> failure<E&>
+{
+  using result_type = failure<E&>;
+
+  return result_type{e.get()};
+}
+
+template <typename E, typename...Args, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::fail(Args&&...args)
+  noexcept(std::is_nothrow_constructible<E, Args...>::value)
+  -> failure<E>
+{
+  return failure<E>(in_place, detail::forward<Args>(args)...);
+}
+
+template <typename E, typename U, typename...Args, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::fail(std::initializer_list<U> ilist, Args&&...args)
+  noexcept(std::is_nothrow_constructible<E, std::initializer_list<U>, Args...>::value)
+  -> failure<E>
+{
+  return failure<E>(in_place, ilist, detail::forward<Args>(args)...);
+}
+
+template <typename E>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::swap(failure<E>& lhs, failure<E>& rhs)
+#if __cplusplus >= 201703L
+  noexcept(std::is_nothrow_swappable<E>::value) -> void
+#else
+  noexcept(std::is_nothrow_move_constructible<E>::value)
+   -> void
+#endif
+{
+  using std::swap;
+
+  swap(lhs.error(), rhs.error());
+}
+
+//=============================================================================
+// class : detail::result_union<T, E, IsTrivial>
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+// Constructors / Assignment
+//-----------------------------------------------------------------------------
+
+template <typename T, typename E, bool IsTrivial>
+inline RESULT_INLINE_VISIBILITY
+RESULT_NS_IMPL::detail::result_union<T, E, IsTrivial>
+  ::result_union(unit)
+  noexcept
+  : m_empty{}
+{
+  // m_has_value intentionally not set
+}
+
+template <typename T, typename E, bool IsTrivial>
+template <typename...Args>
+inline RESULT_INLINE_VISIBILITY constexpr
+RESULT_NS_IMPL::detail::result_union<T,E,IsTrivial>
+  ::result_union(in_place_t, Args&&...args)
+  noexcept(std::is_nothrow_constructible<T, Args...>::value)
+  : m_value(detail::forward<Args>(args)...),
+    m_has_value{true}
+{
+}
+
+template <typename T, typename E, bool IsTrivial>
+template <typename...Args>
+inline RESULT_INLINE_VISIBILITY constexpr
+RESULT_NS_IMPL::detail::result_union<T,E,IsTrivial>
+  ::result_union(in_place_error_t, Args&&...args)
+  noexcept(std::is_nothrow_constructible<E, Args...>::value)
+  : m_error(detail::forward<Args>(args)...),
+    m_has_value{false}
+{
+}
+
+//-----------------------------------------------------------------------------
+// Modifiers
+//-----------------------------------------------------------------------------
+
+template <typename T, typename E, bool IsTrivial>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::detail::result_union<T, E, IsTrivial>::destroy()
+  const noexcept -> void
+{
+  // do nothing
+}
+
+//=============================================================================
+// class : detail::result_union<T, E, false>
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+// Constructors / Destructor / Assignment
+//-----------------------------------------------------------------------------
+
+template <typename T, typename E>
+inline RESULT_INLINE_VISIBILITY
+RESULT_NS_IMPL::detail::result_union<T, E, false>
+  ::result_union(unit)
+  noexcept
+  : m_empty{}
+{
+  // m_has_value intentionally not set
+}
+
+template <typename T, typename E>
+template <typename...Args>
+inline RESULT_INLINE_VISIBILITY constexpr
+RESULT_NS_IMPL::detail::result_union<T,E,false>
+  ::result_union(in_place_t, Args&&...args)
+  noexcept(std::is_nothrow_constructible<T, Args...>::value)
+  : m_value(detail::forward<Args>(args)...),
+    m_has_value{true}
+{
+}
+
+template <typename T, typename E>
+template <typename...Args>
+inline RESULT_INLINE_VISIBILITY constexpr
+RESULT_NS_IMPL::detail::result_union<T,E,false>
+  ::result_union(in_place_error_t, Args&&...args)
+  noexcept(std::is_nothrow_constructible<E, Args...>::value)
+  : m_error(detail::forward<Args>(args)...),
+    m_has_value{false}
+{
+}
+
+//-----------------------------------------------------------------------------
+
+template <typename T, typename E>
+inline RESULT_INLINE_VISIBILITY
+RESULT_NS_IMPL::detail::result_union<T,E,false>
+  ::~result_union()
+  noexcept(std::is_nothrow_destructible<T>::value && std::is_nothrow_destructible<E>::value)
+{
+  destroy();
+}
+
+//-----------------------------------------------------------------------------
+// Modifiers
+//-----------------------------------------------------------------------------
+
+template <typename T, typename E>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::detail::result_union<T, E, false>::destroy()
+  -> void
+{
+  if (m_has_value) {
+    m_value.~underlying_value_type();
+  } else {
+    m_error.~underlying_error_type();
+  }
+}
+
+//=============================================================================
+// class : result_construct_base<T, E>
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+// Constructors / Assignment
+//-----------------------------------------------------------------------------
+
+template <typename T, typename E>
+inline RESULT_INLINE_VISIBILITY
+RESULT_NS_IMPL::detail::result_construct_base<T,E>::result_construct_base(unit)
+  noexcept
+  : storage{unit{}}
+{
+}
+
+template <typename T, typename E>
+template <typename...Args>
+inline constexpr RESULT_INLINE_VISIBILITY
+RESULT_NS_IMPL::detail::result_construct_base<T,E>::result_construct_base(
+  in_place_t,
+  Args&&...args
+) noexcept(std::is_nothrow_constructible<T, Args...>::value)
+  : storage{in_place, detail::forward<Args>(args)...}
+{
+}
+
+template <typename T, typename E>
+template <typename...Args>
+inline constexpr RESULT_INLINE_VISIBILITY
+RESULT_NS_IMPL::detail::result_construct_base<T,E>::result_construct_base(
+  in_place_error_t,
+  Args&&...args
+) noexcept(std::is_nothrow_constructible<E, Args...>::value)
+  : storage(in_place_error, detail::forward<Args>(args)...)
+{
+}
+
+//-----------------------------------------------------------------------------
+// Construction / Assignment
+//-----------------------------------------------------------------------------
+
+template <typename T, typename E>
+template <typename...Args>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::detail::result_construct_base<T,E>::construct_value(Args&&...args)
+  noexcept(std::is_nothrow_constructible<T,Args...>::value)
+  -> void
+{
+  using value_type = typename storage_type::underlying_value_type;
+
+  auto* p = static_cast<void*>(std::addressof(storage.m_value));
+  new (p) value_type(detail::forward<Args>(args)...);
+  storage.m_has_value = true;
+}
+
+template <typename T, typename E>
+template <typename...Args>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::detail::result_construct_base<T,E>::construct_error(Args&&...args)
+  noexcept(std::is_nothrow_constructible<E,Args...>::value)
+  -> void
+{
+  using error_type = typename storage_type::underlying_error_type;
+
+  auto* p = static_cast<void*>(std::addressof(storage.m_error));
+  new (p) error_type(detail::forward<Args>(args)...);
+  storage.m_has_value = false;
+}
+
+template <typename T, typename E>
+template <typename Result>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::detail::result_construct_base<T,E>::construct_error_from_result(
+  Result&& other
+) -> void
+{
+  if (other.storage.m_has_value) {
+    construct_value();
+  } else {
+    construct_error(detail::forward<Result>(other).storage.m_error);
+  }
+}
+
+
+template <typename T, typename E>
+template <typename Result>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::detail::result_construct_base<T,E>::construct_from_result(
+  Result&& other
+) -> void
+{
+  if (other.storage.m_has_value) {
+    construct_value_from_result_impl(
+      std::is_lvalue_reference<T>{},
+      detail::forward<Result>(other).storage.m_value
+    );
+  } else {
+    construct_error(detail::forward<Result>(other).storage.m_error);
+  }
+}
+
+template <typename T, typename E>
+template <typename Value>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::detail::result_construct_base<T,E>::assign_value(Value&& value)
+  noexcept(std::is_nothrow_assignable<T,Value>::value)
+  -> void
+{
+  if (!storage.m_has_value) {
+    storage.destroy();
+    construct_value(detail::forward<Value>(value));
+  } else {
+    storage.m_value = detail::forward<Value>(value);
+  }
+}
+
+template <typename T, typename E>
+template <typename Error>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::detail::result_construct_base<T,E>::assign_error(Error&& error)
+  noexcept(std::is_nothrow_assignable<E,Error>::value)
+  -> void
+{
+  if (storage.m_has_value) {
+    storage.destroy();
+    construct_error(detail::forward<Error>(error));
+  } else {
+    storage.m_error = detail::forward<Error>(error);
+  }
+}
+
+template <typename T, typename E>
+template <typename Result>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::detail::result_construct_base<T,E>::assign_from_result(Result&& other)
+  -> void
+{
+  if (other.storage.m_has_value != storage.m_has_value) {
+    storage.destroy();
+    construct_from_result(detail::forward<Result>(other));
+  } else if (storage.m_has_value) {
+    assign_value_from_result_impl(
+      std::is_lvalue_reference<T>{},
+      detail::forward<Result>(other)
+    );
+  } else {
+    storage.m_error = detail::forward<Result>(other).storage.m_error;
+  }
+}
+
+template <typename T, typename E>
+template <typename ReferenceWrapper>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::detail::result_construct_base<T,E>::construct_value_from_result_impl(
+  std::true_type,
+  ReferenceWrapper&& reference
+) noexcept -> void
+{
+  using value_type = typename storage_type::underlying_value_type;
+
+  auto* p = static_cast<void*>(std::addressof(storage.m_value));
+  new (p) value_type(reference.get());
+  storage.m_has_value = true;
+}
+
+template <typename T, typename E>
+template <typename Value>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::detail::result_construct_base<T,E>::construct_value_from_result_impl(
+  std::false_type,
+  Value&& value
+) noexcept(std::is_nothrow_constructible<T,Value>::value) -> void
+{
+  using value_type = typename storage_type::underlying_value_type;
+
+  auto* p = static_cast<void*>(std::addressof(storage.m_value));
+  new (p) value_type(detail::forward<Value>(value));
+  storage.m_has_value = true;
+}
+
+template <typename T, typename E>
+template <typename Result>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::detail::result_construct_base<T,E>::assign_value_from_result_impl(
+  std::true_type,
+  Result&& other
+) -> void
+{
+  // T is a reference; unwrap it
+  storage.m_value = other.storage.m_value.get();
+}
+
+template <typename T, typename E>
+template <typename Result>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::detail::result_construct_base<T,E>::assign_value_from_result_impl(
+  std::false_type,
+  Result&& other
+) -> void
+{
+  storage.m_value = detail::forward<Result>(other).storage.m_value;
+}
+
+
+//=============================================================================
+// class : result_trivial_copy_ctor_base_impl
+//=============================================================================
+
+template <typename T, typename E>
+inline RESULT_INLINE_VISIBILITY
+RESULT_NS_IMPL::detail::result_trivial_copy_ctor_base_impl<T,E>
+  ::result_trivial_copy_ctor_base_impl(const result_trivial_copy_ctor_base_impl& other)
+  noexcept(std::is_nothrow_copy_constructible<T>::value &&
+           std::is_nothrow_copy_constructible<E>::value)
+  : base_type(unit{})
+{
+  using ctor_base = result_construct_base<T,E>;
+
+  ctor_base::construct_from_result(static_cast<const ctor_base&>(other));
+}
+
+//=============================================================================
+// class : result_trivial_move_ctor_base
+//=============================================================================
+
+template <typename T, typename E>
+inline RESULT_INLINE_VISIBILITY
+RESULT_NS_IMPL::detail::result_trivial_move_ctor_base_impl<T, E>
+  ::result_trivial_move_ctor_base_impl(result_trivial_move_ctor_base_impl&& other)
+  noexcept(std::is_nothrow_move_constructible<T>::value &&
+           std::is_nothrow_move_constructible<E>::value)
+  : base_type(unit{})
+{
+  using ctor_base = result_construct_base<T,E>;
+
+  ctor_base::construct_from_result(static_cast<ctor_base&&>(other));
+}
+
+//=============================================================================
+// class : result_copy_assign_base
+//=============================================================================
+
+template <typename T, typename E>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::detail::result_trivial_copy_assign_base_impl<T, E>
+  ::operator=(const result_trivial_copy_assign_base_impl& other)
+  noexcept(std::is_nothrow_copy_constructible<T>::value &&
+           std::is_nothrow_copy_constructible<E>::value &&
+           std::is_nothrow_copy_assignable<T>::value &&
+           std::is_nothrow_copy_assignable<E>::value)
+  -> result_trivial_copy_assign_base_impl&
+{
+  using ctor_base = result_construct_base<T,E>;
+
+  ctor_base::assign_from_result(static_cast<const ctor_base&>(other));
+  return (*this);
+}
+
+//=========================================================================
+// class : result_move_assign_base
+//=========================================================================
+
+template <typename T, typename E>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::detail::result_trivial_move_assign_base_impl<T, E>
+  ::operator=(result_trivial_move_assign_base_impl&& other)
+  noexcept(std::is_nothrow_move_constructible<T>::value &&
+           std::is_nothrow_move_constructible<E>::value &&
+           std::is_nothrow_move_assignable<T>::value &&
+           std::is_nothrow_move_assignable<E>::value)
+  -> result_trivial_move_assign_base_impl&
+{
+  using ctor_base = result_construct_base<T,E>;
+
+  ctor_base::assign_from_result(static_cast<ctor_base&&>(other));
+  return (*this);
+}
+
+template <typename T, typename E>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::detail::result_error_extractor::get(const result<T,E>& exp)
+  noexcept -> const E&
+{
+  return exp.m_storage.storage.m_error;
+}
+
+template <typename T, typename E>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::detail::result_error_extractor::get(result<T,E>& exp)
+  noexcept -> E&
+{
+  return exp.m_storage.storage.m_error;
+}
+
+template <typename T, typename E>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::detail::extract_error(const result<T,E>& exp) noexcept -> const E&
+{
+  return result_error_extractor::get(exp);
+}
+
+template <typename E>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::detail::throw_bad_result_access(E&& error) -> void
+{
+#if defined(RESULT_DISABLE_EXCEPTIONS)
+  std::fprintf(
+    stderr,
+    "error attempting to access value from result containing error\n"
+  );
+  std::abort();
+#else
+  using exception_type = bad_result_access<
+    typename std::remove_const<
+      typename std::remove_reference<E>::type
+    >::type
+  >;
+
+  throw exception_type{
+    detail::forward<E>(error)
+  };
+#endif
+}
+
+template <typename String, typename E>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::detail::throw_bad_result_access_message(
+  String&& message,
+  E&& error
+) -> void
+{
+#if defined(RESULT_DISABLE_EXCEPTIONS)
+  const auto message_string = std::string{
+    detail::forward<String>(message)
+  };
+  std::fprintf(stderr, "%s\n", message_string.c_str());
+  std::abort();
+#else
+  using exception_type = bad_result_access<
+    typename std::remove_const<
+      typename std::remove_reference<E>::type
+    >::type
+  >;
+
+  throw exception_type{
+    detail::forward<String>(message),
+    detail::forward<E>(error)
+  };
+#endif
+}
+
+//=============================================================================
+// class : result<T,E>
+//=============================================================================
+
+template <typename T, typename E>
+template <typename U, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+RESULT_NS_IMPL::result<T, E>::result()
+  noexcept(std::is_nothrow_constructible<U>::value)
+  : m_storage(in_place)
+{
+
+}
+
+template <typename T, typename E>
+template <typename T2, typename E2,
+          typename std::enable_if<RESULT_NS_IMPL::detail::result_is_implicit_copy_convertible<T,E,T2,E2>::value,int>::type>
+inline RESULT_INLINE_VISIBILITY
+RESULT_NS_IMPL::result<T, E>::result(const result<T2,E2>& other)
+  noexcept(std::is_nothrow_constructible<T,const T2&>::value &&
+           std::is_nothrow_constructible<E,const E2&>::value)
+  : m_storage(detail::unit{})
+{
+  m_storage.construct_from_result(
+    static_cast<const result<T2,E2>&>(other).m_storage
+  );
+}
+
+template <typename T, typename E>
+template <typename T2, typename E2,
+          typename std::enable_if<RESULT_NS_IMPL::detail::result_is_explicit_copy_convertible<T,E,T2,E2>::value,int>::type>
+inline RESULT_INLINE_VISIBILITY
+RESULT_NS_IMPL::result<T, E>::result(const result<T2,E2>& other)
+  noexcept(std::is_nothrow_constructible<T,const T2&>::value &&
+           std::is_nothrow_constructible<E,const E2&>::value)
+  : m_storage(detail::unit{})
+{
+  m_storage.construct_from_result(
+    static_cast<const result<T2,E2>&>(other).m_storage
+  );
+}
+
+template <typename T, typename E>
+template <typename T2, typename E2,
+          typename std::enable_if<RESULT_NS_IMPL::detail::result_is_implicit_move_convertible<T,E,T2,E2>::value,int>::type>
+inline RESULT_INLINE_VISIBILITY
+RESULT_NS_IMPL::result<T, E>::result(result<T2,E2>&& other)
+  noexcept(std::is_nothrow_constructible<T,T2&&>::value &&
+           std::is_nothrow_constructible<E,E2&&>::value)
+  : m_storage(detail::unit{})
+{
+  m_storage.construct_from_result(
+    static_cast<result<T2,E2>&&>(other).m_storage
+  );
+}
+
+template <typename T, typename E>
+template <typename T2, typename E2,
+          typename std::enable_if<RESULT_NS_IMPL::detail::result_is_explicit_move_convertible<T,E,T2,E2>::value,int>::type>
+inline RESULT_INLINE_VISIBILITY
+RESULT_NS_IMPL::result<T, E>::result(result<T2,E2>&& other)
+  noexcept(std::is_nothrow_constructible<T,T2&&>::value &&
+           std::is_nothrow_constructible<E,E2&&>::value)
+  : m_storage(detail::unit{})
+{
+  m_storage.construct_from_result(
+    static_cast<result<T2,E2>&&>(other).m_storage
+  );
+}
+
+//-----------------------------------------------------------------------------
+
+template <typename T, typename E>
+template <typename...Args, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+RESULT_NS_IMPL::result<T, E>::result(in_place_t, Args&&...args)
+  noexcept(std::is_nothrow_constructible<T, Args...>::value)
+  : m_storage(in_place, detail::forward<Args>(args)...)
+{
+
+}
+
+template <typename T, typename E>
+template <typename U, typename...Args, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+RESULT_NS_IMPL::result<T, E>::result(
+  in_place_t,
+  std::initializer_list<U> ilist,
+  Args&&...args
+) noexcept(std::is_nothrow_constructible<T, std::initializer_list<U>, Args...>::value)
+  : m_storage(in_place, ilist, detail::forward<Args>(args)...)
+{
+
+}
+
+//-----------------------------------------------------------------------------
+
+template <typename T, typename E>
+template <typename...Args, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+RESULT_NS_IMPL::result<T, E>::result(in_place_error_t, Args&&...args)
+  noexcept(std::is_nothrow_constructible<E, Args...>::value)
+  : m_storage(in_place_error, detail::forward<Args>(args)...)
+{
+
+}
+
+template <typename T, typename E>
+template <typename U, typename...Args, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+RESULT_NS_IMPL::result<T, E>::result(
+  in_place_error_t,
+  std::initializer_list<U> ilist,
+  Args&&...args
+) noexcept(std::is_nothrow_constructible<E, std::initializer_list<U>, Args...>::value)
+  : m_storage(in_place_error, ilist, detail::forward<Args>(args)...)
+{
+
+}
+
+//-------------------------------------------------------------------------
+
+template <typename T, typename E>
+template <typename E2, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+RESULT_NS_IMPL::result<T, E>::result(const failure<E2>& e)
+  noexcept(std::is_nothrow_constructible<E,const E2&>::value)
+  : m_storage(in_place_error, e.error())
+{
+
+}
+
+template <typename T, typename E>
+template <typename E2, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+RESULT_NS_IMPL::result<T, E>::result(failure<E2>&& e)
+  noexcept(std::is_nothrow_constructible<E,E2&&>::value)
+  : m_storage(in_place_error, static_cast<E2&&>(e.error()))
+{
+
+}
+
+template <typename T, typename E>
+template <typename U,
+          typename std::enable_if<RESULT_NS_IMPL::detail::result_is_explicit_value_convertible<T,U>::value,int>::type>
+inline RESULT_INLINE_VISIBILITY constexpr
+RESULT_NS_IMPL::result<T, E>::result(U&& value)
+  noexcept(std::is_nothrow_constructible<T,U>::value)
+  : m_storage(in_place, detail::forward<U>(value))
+{
+
+}
+
+template <typename T, typename E>
+template <typename U,
+          typename std::enable_if<RESULT_NS_IMPL::detail::result_is_implicit_value_convertible<T,U>::value,int>::type>
+inline RESULT_INLINE_VISIBILITY constexpr
+RESULT_NS_IMPL::result<T, E>::result(U&& value)
+  noexcept(std::is_nothrow_constructible<T,U>::value)
+  : m_storage(in_place, detail::forward<U>(value))
+{
+
+}
+
+//-----------------------------------------------------------------------------
+
+template <typename T, typename E>
+template <typename T2, typename E2, typename>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::result<T, E>::operator=(const result<T2,E2>& other)
+  noexcept(std::is_nothrow_assignable<T, const T2&>::value &&
+           std::is_nothrow_assignable<E, const E2&>::value)
+  -> result&
+{
+  m_storage.assign_from_result(
+    static_cast<const result<T2,E2>&>(other).m_storage
+  );
+  return (*this);
+}
+
+template <typename T, typename E>
+template <typename T2, typename E2, typename>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::result<T, E>::operator=(result<T2,E2>&& other)
+  noexcept(std::is_nothrow_assignable<T, T2&&>::value &&
+           std::is_nothrow_assignable<E, E2&&>::value)
+  -> result&
+{
+  m_storage.assign_from_result(
+    static_cast<result<T2,E2>&&>(other).m_storage
+  );
+  return (*this);
+}
+
+template <typename T, typename E>
+template <typename U, typename>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::result<T, E>::operator=(U&& value)
+  noexcept(std::is_nothrow_assignable<T, U>::value)
+  -> result&
+{
+  m_storage.assign_value(detail::forward<U>(value));
+  return (*this);
+}
+
+template <typename T, typename E>
+template <typename E2, typename>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::result<T, E>::operator=(const failure<E2>& other)
+  noexcept(std::is_nothrow_assignable<E, const E2&>::value)
+  -> result&
+{
+  m_storage.assign_error(other.error());
+  return (*this);
+}
+
+template <typename T, typename E>
+template <typename E2, typename>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::result<T, E>::operator=(failure<E2>&& other)
+  noexcept(std::is_nothrow_assignable<E, E2&&>::value)
+  -> result&
+{
+  m_storage.assign_error(static_cast<E2&&>(other.error()));
+  return (*this);
+}
+
+//-----------------------------------------------------------------------------
+// Observers
+//-----------------------------------------------------------------------------
+
+template <typename T, typename E>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<T, E>::operator->()
+  noexcept -> typename std::remove_reference<T>::type*
+{
+  // Prior to C++17, std::addressof was not `constexpr`.
+  // Since `addressof` fixes a relatively obscure issue where users define a
+  // custom `operator&`, the pre-C++17 implementation has been defined to be
+  // `&(**this)` so that it may exist in constexpr contexts.
+#if __cplusplus >= 201703L
+  return std::addressof(**this);
+#else
+  return &(**this);
+#endif
+}
+
+template <typename T, typename E>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::result<T, E>::operator->()
+  const noexcept -> typename std::remove_reference<typename std::add_const<T>::type>::type*
+{
+#if __cplusplus >= 201703L
+  return std::addressof(**this);
+#else
+  return &(**this);
+#endif
+}
+
+template <typename T, typename E>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<T, E>::operator*()
+  & noexcept -> typename std::add_lvalue_reference<T>::type
+{
+  return m_storage.storage.m_value;
+}
+
+template <typename T, typename E>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<T, E>::operator*()
+  && noexcept -> typename std::add_rvalue_reference<T>::type
+{
+  using reference = typename std::add_rvalue_reference<T>::type;
+
+  return static_cast<reference>(m_storage.storage.m_value);
+}
+
+template <typename T, typename E>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::result<T, E>::operator*()
+  const& noexcept -> typename std::add_lvalue_reference<typename std::add_const<T>::type>::type
+{
+  return m_storage.storage.m_value;
+}
+
+template <typename T, typename E>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::result<T, E>::operator*()
+  const&& noexcept -> typename std::add_rvalue_reference<typename std::add_const<T>::type>::type
+{
+  using reference = typename std::add_rvalue_reference<typename std::add_const<T>::type>::type;
+
+  return static_cast<reference>(m_storage.storage.m_value);
+}
+
+//-----------------------------------------------------------------------------
+
+template <typename T, typename E>
+inline RESULT_INLINE_VISIBILITY constexpr
+RESULT_NS_IMPL::result<T,E>::operator bool()
+  const noexcept
+{
+  return m_storage.storage.m_has_value;
+}
+
+template <typename T, typename E>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::result<T,E>::has_value()
+  const noexcept -> bool
+{
+  return m_storage.storage.m_has_value;
+}
+
+template <typename T, typename E>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::result<T,E>::has_error()
+  const noexcept -> bool
+{
+  return !m_storage.storage.m_has_value;
+}
+
+//-----------------------------------------------------------------------------
+
+// The `has_value()` expression below is incorrectly identified as an unused
+// value, which results in the `-Wunused-value` warning. This is suppressed
+// to prevent false-positives
+#if defined(__clang__)
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wunused-value"
+#elif defined(__GNUC__)
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wunused-value"
+#elif defined(_MSC_VER)
+// Older MSVC versions incorrectly warn on returning a reference to a temporary.
+// This has been suppressed
+# pragma warning(push)
+# pragma warning(disable:4172)
+#endif
+
+template <typename T, typename E>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<T,E>::value()
+  & -> typename std::add_lvalue_reference<T>::type
+{
+  return (has_value() ||
+    (detail::throw_bad_result_access(m_storage.storage.m_error), false),
+    m_storage.storage.m_value
+  );
+}
+
+template <typename T, typename E>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<T,E>::value()
+  && -> typename std::add_rvalue_reference<T>::type
+{
+  using reference = typename std::add_rvalue_reference<T>::type;
+
+  return (has_value() ||
+    (detail::throw_bad_result_access(static_cast<E&&>(m_storage.storage.m_error)), true),
+    static_cast<reference>(m_storage.storage.m_value)
+  );
+}
+
+template <typename T, typename E>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::result<T,E>::value()
+  const & -> typename std::add_lvalue_reference<typename std::add_const<T>::type>::type
+{
+  return (has_value() ||
+    (detail::throw_bad_result_access(m_storage.storage.m_error), true),
+    m_storage.storage.m_value
+  );
+}
+
+template <typename T, typename E>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::result<T,E>::value()
+  const && -> typename std::add_rvalue_reference<typename std::add_const<T>::type>::type
+{
+  using reference = typename std::add_rvalue_reference<typename std::add_const<T>::type>::type;
+
+  return (has_value() ||
+    (detail::throw_bad_result_access(static_cast<const E&&>(m_storage.storage.m_error)), true),
+    (static_cast<reference>(m_storage.storage.m_value))
+  );
+}
+
+#if defined(__clang__)
+# pragma clang diagnostic pop
+#elif defined(__GNUC__)
+# pragma GCC diagnostic pop
+#elif defined(_MSC_VER)
+# pragma warning(pop)
+#endif
+
+template <typename T, typename E>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::result<T,E>::error() const &
+  noexcept(std::is_nothrow_constructible<E>::value &&
+           std::is_nothrow_copy_constructible<E>::value) -> E
+{
+  static_assert(
+    std::is_default_constructible<E>::value,
+    "E must be default-constructible if 'error()' checks are used. "
+    "This is to allow for default-constructed error states to represent the "
+    "'good' state"
+  );
+
+  return m_storage.storage.m_has_value
+    ? E{}
+    : m_storage.storage.m_error;
+}
+
+template <typename T, typename E>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<T,E>::error() &&
+  noexcept(std::is_nothrow_constructible<E>::value &&
+           std::is_nothrow_move_constructible<E>::value) -> E
+{
+  static_assert(
+    std::is_default_constructible<E>::value,
+    "E must be default-constructible if 'error()' checks are used. "
+    "This is to allow for default-constructed error states to represent the "
+    "'good' state"
+  );
+
+  return m_storage.storage.m_has_value
+    ? E{}
+    : static_cast<E&&>(m_storage.storage.m_error);
+}
+
+//-----------------------------------------------------------------------------
+
+template <typename T, typename E>
+template <typename String, typename>
+inline RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<T,E>::expect(String&& message)
+  & -> typename std::add_lvalue_reference<T>::type
+{
+  return (has_value() ||
+          (detail::throw_bad_result_access_message(
+                  detail::forward<String>(message),
+                  m_storage.storage.m_error
+          ), true),
+          m_storage.storage.m_value
+  );
+}
+
+template <typename T, typename E>
+template <typename String, typename>
+inline RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<T,E>::expect(String&& message)
+  && -> typename std::add_rvalue_reference<T>::type
+{
+  using reference = typename std::add_rvalue_reference<T>::type;
+
+  return (has_value() ||
+          (detail::throw_bad_result_access_message(
+                  detail::forward<String>(message),
+                  static_cast<E&&>(m_storage.storage.m_error)
+          ), true),
+          static_cast<reference>(m_storage.storage.m_value)
+  );
+}
+
+template <typename T, typename E>
+template <typename String, typename>
+inline RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<T,E>::expect(String&& message)
+  const & -> typename std::add_lvalue_reference<typename std::add_const<T>::type>::type
+{
+    return (has_value() ||
+            (detail::throw_bad_result_access_message(
+                    detail::forward<String>(message),
+                    m_storage.storage.m_error
+            ), true),
+            m_storage.storage.m_value
+    );
+}
+
+template <typename T, typename E>
+template <typename String, typename>
+inline RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<T,E>::expect(String&& message)
+  const && -> typename std::add_rvalue_reference<typename std::add_const<T>::type>::type
+{
+    using reference = typename std::add_rvalue_reference<typename std::add_const<T>::type>::type;
+
+    return (has_value() ||
+            (detail::throw_bad_result_access_message(
+                    detail::forward<String>(message),
+                    static_cast<const E&&>(m_storage.storage.m_error)
+            ), true),
+            (static_cast<reference>(m_storage.storage.m_value))
+    );
+}
+
+//-----------------------------------------------------------------------------
+// Monadic Functionalities
+//-----------------------------------------------------------------------------
+
+template <typename T, typename E>
+template <typename U>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::result<T, E>::value_or(U&& default_value)
+  const& -> typename std::remove_reference<T>::type
+{
+  return m_storage.storage.m_has_value
+    ? m_storage.storage.m_value
+    : detail::forward<U>(default_value);
+}
+
+template <typename T, typename E>
+template <typename U>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<T, E>::value_or(U&& default_value)
+  && -> typename std::remove_reference<T>::type
+{
+  return m_storage.storage.m_has_value
+    ? static_cast<T&&>(**this)
+    : detail::forward<U>(default_value);
+}
+
+template <typename T, typename E>
+template <typename U>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::result<T, E>::error_or(U&& default_error)
+  const& -> error_type
+{
+  return m_storage.storage.m_has_value
+    ? detail::forward<U>(default_error)
+    : m_storage.storage.m_error;
+}
+
+template <typename T, typename E>
+template <typename U>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<T, E>::error_or(U&& default_error)
+  && -> error_type
+{
+  return m_storage.storage.m_has_value
+    ? detail::forward<U>(default_error)
+    : static_cast<E&&>(m_storage.storage.m_error);
+}
+
+template <typename T, typename E>
+template <typename U>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::result<T, E>::and_then(U&& value)
+  const -> result<typename std::decay<U>::type,E>
+{
+  return map([&value](const T&){
+    return detail::forward<U>(value);
+  });
+}
+
+//-----------------------------------------------------------------------------
+
+template <typename T, typename E>
+template <typename Fn>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::result<T, E>::flat_map(Fn&& fn)
+  const & -> detail::invoke_result_t<Fn, const T&>
+{
+  using result_type = detail::invoke_result_t<Fn, const T&>;
+
+  static_assert(
+    is_result<result_type>::value,
+    "flat_map must return a result type or the program is ill-formed"
+  );
+
+  return has_value()
+    ? detail::invoke(detail::forward<Fn>(fn), m_storage.storage.m_value)
+    : result_type(in_place_error, m_storage.storage.m_error);
+}
+
+template <typename T, typename E>
+template <typename Fn>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<T, E>::flat_map(Fn&& fn)
+  && -> detail::invoke_result_t<Fn, T&&>
+{
+  using result_type = detail::invoke_result_t<Fn, T&&>;
+
+  static_assert(
+    is_result<result_type>::value,
+    "flat_map must return a result type or the program is ill-formed"
+  );
+
+  return has_value()
+    ? detail::invoke(detail::forward<Fn>(fn), static_cast<T&&>(m_storage.storage.m_value))
+    : result_type(in_place_error, static_cast<E&&>(m_storage.storage.m_error));
+}
+
+template <typename T, typename E>
+template <typename Fn>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::result<T, E>::map(Fn&& fn)
+  const & -> result<detail::invoke_result_t<Fn,const T&>,E>
+{
+  using result_type = detail::invoke_result_t<Fn,const T&>;
+
+  return map_impl(std::is_void<result_type>{}, detail::forward<Fn>(fn));
+}
+
+template <typename T, typename E>
+template <typename Fn>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<T, E>::map(Fn&& fn)
+  && -> result<detail::invoke_result_t<Fn,T&&>,E>
+{
+  using result_type = detail::invoke_result_t<Fn,T&&>;
+
+  return static_cast<result<T,E>&&>(*this).map_impl(
+    std::is_void<result_type>{},
+    detail::forward<Fn>(fn)
+  );
+}
+
+//-----------------------------------------------------------------------------
+
+template <typename T, typename E>
+template <typename Fn>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::result<T, E>::map_error(Fn&& fn)
+  const & -> result<T, detail::invoke_result_t<Fn,const E&>>
+{
+  using result_type = result<T, detail::invoke_result_t<Fn, const E&>>;
+
+  return has_error()
+    ? result_type(in_place_error, detail::invoke(
+      detail::forward<Fn>(fn), m_storage.storage.m_error
+    ))
+    : result_type(in_place, m_storage.storage.m_value);
+}
+
+template <typename T, typename E>
+template <typename Fn>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<T, E>::map_error(Fn&& fn)
+  && -> result<T, detail::invoke_result_t<Fn,E&&>>
+{
+  using result_type = result<T, detail::invoke_result_t<Fn, E&&>>;
+
+  return has_error()
+    ? result_type(in_place_error, detail::invoke(
+      detail::forward<Fn>(fn), static_cast<E&&>(m_storage.storage.m_error)
+    ))
+    : result_type(static_cast<T&&>(m_storage.storage.m_value));
+}
+
+template <typename T, typename E>
+template <typename Fn>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::result<T, E>::flat_map_error(Fn&& fn)
+  const & -> detail::invoke_result_t<Fn, const E&>
+{
+  using result_type = detail::invoke_result_t<Fn, const E&>;
+
+  static_assert(
+    is_result<result_type>::value,
+    "flat_map_error must return a result type or the program is ill-formed"
+  );
+
+  return has_value()
+    ? result_type(in_place, m_storage.storage.m_value)
+    : detail::invoke(detail::forward<Fn>(fn), m_storage.storage.m_error);
+}
+
+template <typename T, typename E>
+template <typename Fn>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<T, E>::flat_map_error(Fn&& fn)
+  && -> detail::invoke_result_t<Fn, E&&>
+{
+  using result_type = detail::invoke_result_t<Fn, E&&>;
+
+  static_assert(
+    is_result<result_type>::value,
+    "flat_map_error must return a result type or the program is ill-formed"
+  );
+
+  return has_value()
+    ? result_type(in_place, static_cast<T&&>(m_storage.storage.m_value))
+    : detail::invoke(detail::forward<Fn>(fn), static_cast<E&&>(m_storage.storage.m_error));
+}
+
+//-----------------------------------------------------------------------------
+// Private Monadic Functions
+//-----------------------------------------------------------------------------
+
+template <typename T, typename E>
+template <typename Fn>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::result<T, E>::map_impl(std::true_type, Fn&& fn)
+  const & -> result<void,E>
+{
+  using result_type = result<void, E>;
+
+  return has_value()
+    ? (detail::invoke(detail::forward<Fn>(fn), m_storage.storage.m_value), result_type{})
+    : result_type(in_place_error, m_storage.storage.m_error);
+}
+
+template <typename T, typename E>
+template <typename Fn>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::result<T, E>::map_impl(std::false_type, Fn&& fn)
+  const & -> result<detail::invoke_result_t<Fn,const T&>,E>
+{
+  using invoke_result_type = detail::invoke_result_t<Fn,const T&>;
+  using result_type = result<invoke_result_type, E>;
+
+  return has_value()
+    ? result_type(in_place, detail::invoke(
+      detail::forward<Fn>(fn), m_storage.storage.m_value
+    ))
+    : result_type(in_place_error, m_storage.storage.m_error);
+}
+
+template <typename T, typename E>
+template <typename Fn>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<T, E>::map_impl(std::true_type, Fn&& fn)
+  && -> result<void,E>
+{
+  using result_type = result<void, E>;
+
+  return has_value()
+    ? (detail::invoke(
+        detail::forward<Fn>(fn), static_cast<T&&>(m_storage.storage.m_value)
+      ), result_type{})
+    : result_type(in_place_error, static_cast<E&&>(m_storage.storage.m_error));
+}
+
+template <typename T, typename E>
+template <typename Fn>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<T, E>::map_impl(std::false_type, Fn&& fn)
+  && -> result<detail::invoke_result_t<Fn,T&&>,E>
+{
+  using invoke_result_type = detail::invoke_result_t<Fn,T&&>;
+  using result_type = result<invoke_result_type, E>;
+
+  return has_value()
+    ? result_type(in_place, detail::invoke(
+      detail::forward<Fn>(fn), static_cast<T&&>(m_storage.storage.m_value)
+    ))
+    : result_type(in_place_error, static_cast<E&&>(m_storage.storage.m_error));
+}
+
+//=============================================================================
+// class : result<void,E>
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+// Constructor / Assignment
+//-----------------------------------------------------------------------------
+
+template <typename E>
+inline RESULT_INLINE_VISIBILITY constexpr
+RESULT_NS_IMPL::result<void, E>::result()
+  noexcept
+  : m_storage(in_place)
+{
+
+}
+
+template <typename E>
+template <typename U, typename E2, typename>
+inline RESULT_INLINE_VISIBILITY
+RESULT_NS_IMPL::result<void, E>::result(const result<U,E2>& other)
+  noexcept(std::is_nothrow_constructible<E,const E2&>::value)
+  : m_storage(detail::unit{})
+{
+  m_storage.construct_error_from_result(
+    static_cast<const result<U,E2>&>(other).m_storage
+  );
+}
+
+template <typename E>
+template <typename U, typename E2, typename>
+inline RESULT_INLINE_VISIBILITY
+RESULT_NS_IMPL::result<void, E>::result(result<U,E2>&& other)
+  noexcept(std::is_nothrow_constructible<E,E2&&>::value)
+  : m_storage(detail::unit{})
+{
+  m_storage.construct_error_from_result(
+    static_cast<result<U,E2>&&>(other).m_storage
+  );
+}
+
+
+//-----------------------------------------------------------------------------
+
+template <typename E>
+inline RESULT_INLINE_VISIBILITY constexpr
+RESULT_NS_IMPL::result<void, E>::result(in_place_t)
+  noexcept
+  : m_storage(in_place)
+{
+
+}
+
+template <typename E>
+template <typename...Args, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+RESULT_NS_IMPL::result<void, E>::result(in_place_error_t, Args&&...args)
+  noexcept(std::is_nothrow_constructible<E, Args...>::value)
+  : m_storage(in_place_error, detail::forward<Args>(args)...)
+{
+
+}
+
+template <typename E>
+template <typename U, typename...Args, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+RESULT_NS_IMPL::result<void, E>::result(in_place_error_t,
+                                        std::initializer_list<U> ilist,
+                                        Args&&...args)
+  noexcept(std::is_nothrow_constructible<E, std::initializer_list<U>, Args...>::value)
+  : m_storage(in_place_error, ilist, detail::forward<Args>(args)...)
+{
+
+}
+
+//-----------------------------------------------------------------------------
+
+template <typename E>
+template <typename E2, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+RESULT_NS_IMPL::result<void, E>::result(const failure<E2>& e)
+  noexcept(std::is_nothrow_constructible<E,const E2&>::value)
+  : m_storage(in_place_error, e.error())
+{
+
+}
+
+template <typename E>
+template <typename E2, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+RESULT_NS_IMPL::result<void, E>::result(failure<E2>&& e)
+  noexcept(std::is_nothrow_constructible<E,E2&&>::value)
+  : m_storage(in_place_error, static_cast<E2&&>(e.error()))
+{
+
+}
+
+//-----------------------------------------------------------------------------
+
+template <typename E>
+template <typename E2, typename>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::result<void, E>::operator=(const result<void,E2>& other)
+  noexcept(std::is_nothrow_assignable<E, const E2&>::value)
+  -> result&
+{
+  m_storage.assign_from_result(other.m_storage);
+  return (*this);
+}
+
+template <typename E>
+template <typename E2, typename>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::result<void, E>::operator=(result<void,E2>&& other)
+  noexcept(std::is_nothrow_assignable<E, E2&&>::value)
+  -> result&
+{
+  m_storage.assign_from_result(static_cast<result<void,E2>&&>(other).m_storage);
+  return (*this);
+}
+
+template <typename E>
+template <typename E2, typename>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::result<void, E>::operator=(const failure<E2>& other)
+  noexcept(std::is_nothrow_assignable<E, const E2&>::value)
+  -> result&
+{
+  m_storage.assign_error(other.error());
+  return (*this);
+}
+
+template <typename E>
+template <typename E2, typename>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::result<void, E>::operator=(failure<E2>&& other)
+  noexcept(std::is_nothrow_assignable<E, E2&&>::value)
+  -> result&
+{
+  m_storage.assign_error(static_cast<E2&&>(other.error()));
+  return (*this);
+}
+
+//-----------------------------------------------------------------------------
+// Observers
+//-----------------------------------------------------------------------------
+
+template <typename E>
+inline RESULT_INLINE_VISIBILITY constexpr
+RESULT_NS_IMPL::result<void, E>::operator bool()
+  const noexcept
+{
+  return has_value();
+}
+
+template <typename E>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::result<void, E>::has_value()
+  const noexcept -> bool
+{
+  return m_storage.storage.m_has_value;
+}
+
+template <typename E>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::result<void, E>::has_error()
+  const noexcept -> bool
+{
+  return !has_value();
+}
+
+//-----------------------------------------------------------------------------
+
+template <typename E>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<void, E>::value()
+  const & -> void
+{
+  static_cast<void>(
+    has_value() ||
+    (detail::throw_bad_result_access(m_storage.storage.m_error), true)
+  );
+}
+
+template <typename E>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<void, E>::value()
+  && -> void
+{
+  static_cast<void>(
+    has_value() ||
+    (detail::throw_bad_result_access(static_cast<E&&>(m_storage.storage.m_error)), true)
+  );
+}
+
+template <typename E>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::result<void, E>::error()
+  const &
+  noexcept(std::is_nothrow_constructible<E>::value &&
+           std::is_nothrow_copy_constructible<E>::value) -> E
+{
+  return has_value() ? E{} : m_storage.storage.m_error;
+}
+
+template <typename E>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<void, E>::error()
+  && noexcept(std::is_nothrow_constructible<E>::value &&
+              std::is_nothrow_copy_constructible<E>::value) -> E
+{
+  return has_value() ? E{} : static_cast<E&&>(m_storage.storage.m_error);
+}
+
+//-----------------------------------------------------------------------------
+
+template <typename E>
+template <typename String, typename>
+inline RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<void,E>::expect(String&& message)
+  const & -> void
+{
+  if (has_error()) {
+    detail::throw_bad_result_access_message(
+      detail::forward<String>(message),
+      m_storage.storage.m_error
+    );
+  }
+}
+
+template <typename E>
+template <typename String, typename>
+inline RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<void,E>::expect(String&& message)
+  && -> void
+{
+  if (has_error()) {
+    detail::throw_bad_result_access_message(
+      detail::forward<String>(message),
+      static_cast<E&&>(m_storage.storage.m_error)
+    );
+  }
+}
+
+//-----------------------------------------------------------------------------
+// Monadic Functionalities
+//-----------------------------------------------------------------------------
+
+template <typename E>
+template <typename U>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::result<void, E>::error_or(U&& default_error)
+  const & -> error_type
+{
+  return has_value()
+    ? detail::forward<U>(default_error)
+    : m_storage.storage.m_error;
+}
+
+template <typename E>
+template <typename U>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<void, E>::error_or(U&& default_error)
+  && -> error_type
+{
+  return has_value()
+    ? detail::forward<U>(default_error)
+    : static_cast<E&&>(m_storage.storage.m_error);
+}
+
+template <typename E>
+template <typename U>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::result<void, E>::and_then(U&& value)
+  const -> result<typename std::decay<U>::type,E>
+{
+  return map([&value]{
+    return detail::forward<U>(value);
+  });
+}
+
+//-----------------------------------------------------------------------------
+
+template <typename E>
+template <typename Fn>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::result<void, E>::flat_map(Fn&& fn)
+  const & -> detail::invoke_result_t<Fn>
+{
+  using result_type = detail::invoke_result_t<Fn>;
+
+  static_assert(
+    is_result<result_type>::value,
+    "flat_map must return a result type or the program is ill-formed"
+  );
+
+  return has_value()
+    ? detail::invoke(detail::forward<Fn>(fn))
+    : result_type(in_place_error, m_storage.storage.m_error);
+}
+
+template <typename E>
+template <typename Fn>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<void, E>::flat_map(Fn&& fn)
+  && -> detail::invoke_result_t<Fn>
+{
+  using result_type = detail::invoke_result_t<Fn>;
+
+  static_assert(
+    is_result<result_type>::value,
+    "flat_map must return a result type or the program is ill-formed"
+  );
+
+  return has_value()
+    ? detail::invoke(detail::forward<Fn>(fn))
+    : result_type(in_place_error, static_cast<E&&>(m_storage.storage.m_error));
+}
+
+template <typename E>
+template <typename Fn>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::result<void, E>::map(Fn&& fn)
+  const & -> result<detail::invoke_result_t<Fn>,E>
+{
+  using result_type = detail::invoke_result_t<Fn>;
+
+  return map_impl(std::is_void<result_type>{}, detail::forward<Fn>(fn));
+}
+
+template <typename E>
+template <typename Fn>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<void, E>::map(Fn&& fn)
+  && -> result<detail::invoke_result_t<Fn>,E>
+{
+  using result_type = detail::invoke_result_t<Fn>;
+
+  return static_cast<result<void,E>&&>(*this).map_impl(
+    std::is_void<result_type>{},
+    detail::forward<Fn>(fn)
+  );
+}
+
+//-----------------------------------------------------------------------------
+
+template <typename E>
+template <typename Fn>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::result<void, E>::map_error(Fn&& fn)
+  const & -> result<void, detail::invoke_result_t<Fn,const E&>>
+{
+  using result_type = result<void, detail::invoke_result_t<Fn, const E&>>;
+
+  return has_value()
+    ? result_type{}
+    : result_type(in_place_error, detail::invoke(
+      detail::forward<Fn>(fn), m_storage.storage.m_error
+    ));
+}
+
+template <typename E>
+template <typename Fn>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<void, E>::map_error(Fn&& fn)
+  && -> result<void, detail::invoke_result_t<Fn,E&&>>
+{
+  using result_type = result<void, detail::invoke_result_t<Fn, E&&>>;
+
+  return has_value()
+    ? result_type{}
+    : result_type(in_place_error,
+      detail::invoke(detail::forward<Fn>(fn), static_cast<E&&>(m_storage.storage.m_error)
+    ));
+}
+
+template <typename E>
+template <typename Fn>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::result<void, E>::flat_map_error(Fn&& fn)
+  const & -> detail::invoke_result_t<Fn,const E&>
+{
+  using result_type = detail::invoke_result_t<Fn,const E&>;
+
+  static_assert(
+    is_result<result_type>::value,
+    "flat_map_error must return a result type or the program is ill-formed"
+  );
+  static_assert(
+    std::is_default_constructible<typename result_type::value_type>::value,
+    "flat_map_error for result<void,E> requires the new T type to be default-"
+    "constructible"
+  );
+
+  return has_value()
+    ? result_type{}
+    : detail::invoke(detail::forward<Fn>(fn), m_storage.storage.m_error);
+}
+
+template <typename E>
+template <typename Fn>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<void, E>::flat_map_error(Fn&& fn)
+  && -> detail::invoke_result_t<Fn,E&&>
+{
+  using result_type = detail::invoke_result_t<Fn,E&&>;
+
+  static_assert(
+    is_result<result_type>::value,
+    "flat_map_error must return a result type or the program is ill-formed"
+  );
+  static_assert(
+    std::is_default_constructible<typename result_type::value_type>::value,
+    "flat_map_error for result<void,E> requires the new T type to be default-"
+    "constructible"
+  );
+
+  return has_value()
+    ? result_type{}
+    : detail::invoke(detail::forward<Fn>(fn), static_cast<E&&>(m_storage.storage.m_error));
+}
+
+//-----------------------------------------------------------------------------
+// Private Monadic Functions
+//-----------------------------------------------------------------------------
+
+template <typename E>
+template <typename Fn>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::result<void, E>::map_impl(std::true_type, Fn&& fn)
+  const & -> result<void,E>
+{
+  using result_type = result<void, E>;
+
+  return has_value()
+    ? (detail::invoke(detail::forward<Fn>(fn)), result_type{})
+    : result_type(in_place_error, m_storage.storage.m_error);
+}
+
+template <typename E>
+template <typename Fn>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::result<void, E>::map_impl(std::false_type, Fn&& fn)
+  const & -> result<detail::invoke_result_t<Fn>,E>
+{
+  using invoke_result_type = detail::invoke_result_t<Fn>;
+  using result_type = result<invoke_result_type, E>;
+
+  return has_value()
+    ? result_type(in_place, detail::invoke(detail::forward<Fn>(fn)))
+    : result_type(in_place_error, m_storage.storage.m_error);
+}
+
+template <typename E>
+template <typename Fn>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<void, E>::map_impl(std::true_type, Fn&& fn)
+  && -> result<void,E>
+{
+  using result_type = result<void, E>;
+
+  return has_value()
+    ? (detail::invoke(detail::forward<Fn>(fn)), result_type{})
+    : result_type(in_place_error, static_cast<E&&>(m_storage.storage.m_error));
+}
+
+template <typename E>
+template <typename Fn>
+inline RESULT_INLINE_VISIBILITY RESULT_CPP14_CONSTEXPR
+auto RESULT_NS_IMPL::result<void, E>::map_impl(std::false_type, Fn&& fn)
+  && -> result<detail::invoke_result_t<Fn>,E>
+{
+  using invoke_result_type = detail::invoke_result_t<Fn>;
+  using result_type = result<invoke_result_type, E>;
+
+  return has_value()
+    ? result_type(in_place, detail::invoke(detail::forward<Fn>(fn)))
+    : result_type(in_place_error, static_cast<E&&>(m_storage.storage.m_error));
+}
+
+//=============================================================================
+// non-member functions : class : result
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+// Comparison
+//-----------------------------------------------------------------------------
+
+template <typename T1, typename E1, typename T2, typename E2>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator==(const result<T1,E1>& lhs,
+                                const result<T2,E2>& rhs)
+  noexcept -> bool
+{
+  return (lhs.has_value() == rhs.has_value())
+    ? (
+        lhs.has_value()
+        ? *lhs == *rhs
+        : detail::extract_error(lhs) == detail::extract_error(rhs)
+      )
+    : false;
+}
+
+template <typename T1, typename E1, typename T2, typename E2>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator!=(const result<T1,E1>& lhs,
+                                const result<T2,E2>& rhs)
+  noexcept -> bool
+{
+  return (lhs.has_value() == rhs.has_value())
+    ? (
+        lhs.has_value()
+        ? *lhs != *rhs
+        : detail::extract_error(lhs) != detail::extract_error(rhs)
+      )
+    : true;
+}
+
+template <typename T1, typename E1, typename T2, typename E2>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator>=(const result<T1,E1>& lhs,
+                                const result<T2,E2>& rhs)
+  noexcept -> bool
+{
+  return (lhs.has_value() == rhs.has_value())
+    ? (
+        lhs.has_value()
+        ? *lhs >= *rhs
+        : detail::extract_error(lhs) >= detail::extract_error(rhs)
+      )
+    : static_cast<int>(static_cast<bool>(lhs)) >= static_cast<int>(static_cast<bool>(rhs));
+}
+
+template <typename T1, typename E1, typename T2, typename E2>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator<=(const result<T1,E1>& lhs,
+                                const result<T2,E2>& rhs)
+  noexcept -> bool
+{
+  return (lhs.has_value() == rhs.has_value())
+    ? (
+        lhs.has_value()
+        ? *lhs <= *rhs
+        : detail::extract_error(lhs) <= detail::extract_error(rhs)
+      )
+    : static_cast<int>(static_cast<bool>(lhs)) <= static_cast<int>(static_cast<bool>(rhs));
+}
+
+template <typename T1, typename E1, typename T2, typename E2>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator>(const result<T1,E1>& lhs,
+                                 const result<T2,E2>& rhs)
+  noexcept -> bool
+{
+  return (lhs.has_value() == rhs.has_value())
+    ? (
+        lhs.has_value()
+        ? *lhs > *rhs
+        : detail::extract_error(lhs) > detail::extract_error(rhs)
+      )
+    : static_cast<int>(static_cast<bool>(lhs)) > static_cast<int>(static_cast<bool>(rhs));
+}
+
+template <typename T1, typename E1, typename T2, typename E2>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator<(const result<T1,E1>& lhs,
+                                 const result<T2,E2>& rhs)
+  noexcept -> bool
+{
+  return (lhs.has_value() == rhs.has_value())
+    ? (
+        lhs.has_value()
+        ? *lhs < *rhs
+        : detail::extract_error(lhs) < detail::extract_error(rhs)
+      )
+    : static_cast<int>(static_cast<bool>(lhs)) < static_cast<int>(static_cast<bool>(rhs));
+}
+
+
+//-----------------------------------------------------------------------------
+
+template <typename E1, typename E2>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator==(const result<void,E1>& lhs,
+                                const result<void,E2>& rhs)
+  noexcept -> bool
+{
+  return lhs.has_value() == rhs.has_value()
+    ? (
+        lhs.has_value()
+        ? true
+        : detail::extract_error(lhs) == detail::extract_error(rhs)
+      )
+    : false;
+}
+
+template <typename E1, typename E2>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator!=(const result<void,E1>& lhs,
+                                const result<void,E2>& rhs)
+  noexcept -> bool
+{
+  return lhs.has_value() == rhs.has_value()
+    ? (
+        lhs.has_value()
+        ? false
+        : detail::extract_error(lhs) != detail::extract_error(rhs)
+      )
+    : true;
+}
+
+template <typename E1, typename E2>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator>=(const result<void,E1>& lhs,
+                                const result<void,E2>& rhs)
+  noexcept -> bool
+{
+  return lhs.has_value() == rhs.has_value()
+    ? (
+        lhs.has_value()
+        ? true
+        : detail::extract_error(lhs) >= detail::extract_error(rhs)
+      )
+    : static_cast<int>(static_cast<bool>(lhs)) >= static_cast<int>(static_cast<bool>(rhs));
+}
+
+template <typename E1, typename E2>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator<=(const result<void,E1>& lhs,
+                                const result<void,E2>& rhs)
+  noexcept -> bool
+{
+  return lhs.has_value() == rhs.has_value()
+    ? (
+        lhs.has_value()
+        ? true
+        : detail::extract_error(lhs) <= detail::extract_error(rhs)
+      )
+    : static_cast<int>(static_cast<bool>(lhs)) <= static_cast<int>(static_cast<bool>(rhs));
+}
+
+template <typename E1, typename E2>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator>(const result<void,E1>& lhs,
+                               const result<void,E2>& rhs)
+  noexcept -> bool
+{
+  return lhs.has_value() == rhs.has_value()
+    ? (
+        lhs.has_value()
+        ? false
+        : detail::extract_error(lhs) > detail::extract_error(rhs)
+      )
+    : static_cast<int>(static_cast<bool>(lhs)) > static_cast<int>(static_cast<bool>(rhs));
+}
+
+template <typename E1, typename E2>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator<(const result<void,E1>& lhs,
+                               const result<void,E2>& rhs)
+  noexcept -> bool
+{
+  return lhs.has_value() == rhs.has_value()
+    ? (
+        lhs.has_value()
+        ? false
+        : detail::extract_error(lhs) < detail::extract_error(rhs)
+      )
+    : static_cast<int>(static_cast<bool>(lhs)) < static_cast<int>(static_cast<bool>(rhs));
+}
+
+
+//-----------------------------------------------------------------------------
+
+template <typename T, typename E, typename U, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator==(const result<T,E>& exp, const U& value)
+  noexcept -> bool
+{
+  return (exp.has_value() && *exp == value);
+}
+
+template <typename T, typename U, typename E, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator==(const T& value, const result<U,E>& exp)
+  noexcept -> bool
+{
+  return (exp.has_value() && *exp == value);
+}
+
+template <typename T, typename E, typename U, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator!=(const result<T,E>& exp, const U& value)
+  noexcept -> bool
+{
+  return exp.has_value() ? *exp != value : true;
+}
+
+template <typename T, typename U, typename E, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator!=(const T& value, const result<U,E>& exp)
+  noexcept -> bool
+{
+  return exp.has_value() ? value != *exp : true;
+}
+
+template <typename T, typename E, typename U, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator<=(const result<T,E>& exp, const U& value)
+  noexcept -> bool
+{
+  return exp.has_value() ? *exp <= value : false;
+}
+
+template <typename T, typename U, typename E, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator<=(const T& value, const result<U,E>& exp)
+  noexcept -> bool
+{
+  return exp.has_value() ? value <= *exp : true;
+}
+
+template <typename T, typename E, typename U, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator>=(const result<T,E>& exp, const U& value)
+  noexcept -> bool
+{
+  return exp.has_value() ? *exp >= value : true;
+}
+
+template <typename T, typename U, typename E, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator>=(const T& value, const result<U,E>& exp)
+  noexcept -> bool
+{
+  return exp.has_value() ? value >= *exp : false;
+}
+
+template <typename T, typename E, typename U, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator<(const result<T,E>& exp, const U& value)
+  noexcept -> bool
+{
+  return exp.has_value() ? *exp < value : false;
+}
+
+template <typename T, typename U, typename E, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator<(const T& value, const result<U,E>& exp)
+  noexcept -> bool
+{
+  return exp.has_value() ? value < *exp : true;
+}
+
+template <typename T, typename E, typename U, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator>(const result<T,E>& exp, const U& value)
+  noexcept -> bool
+{
+  return exp.has_value() ? *exp > value : false;
+}
+
+template <typename T, typename U, typename E, typename>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator>(const T& value, const result<U,E>& exp)
+  noexcept -> bool
+{
+  return exp.has_value() ? value > *exp : true;
+}
+
+//-----------------------------------------------------------------------------
+
+template <typename T, typename E, typename U>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator==(const result<T,E>& exp, const failure<U>& error)
+  noexcept -> bool
+{
+  return exp.has_error() ? detail::extract_error(exp) == error.error() : false;
+}
+
+template <typename T, typename U, typename E>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator==(const failure<T>& error, const result<E,U>& exp)
+  noexcept -> bool
+{
+  return exp.has_error() ? error.error() == detail::extract_error(exp) : false;
+}
+
+template <typename T, typename E, typename U>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator!=(const result<T,E>& exp, const failure<U>& error)
+  noexcept -> bool
+{
+  return exp.has_error() ? detail::extract_error(exp) != error.error() : true;
+}
+
+template <typename T, typename U, typename E>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator!=(const failure<T>& error, const result<E,U>& exp)
+  noexcept -> bool
+{
+  return exp.has_error() ? error.error() != detail::extract_error(exp) : true;
+}
+
+template <typename T, typename E, typename U>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator<=(const result<T,E>& exp, const failure<U>& error)
+  noexcept -> bool
+{
+  return exp.has_error() ? detail::extract_error(exp) <= error.error() : true;
+}
+
+template <typename T, typename U, typename E>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator<=(const failure<T>& error, const result<E,U>& exp)
+  noexcept -> bool
+{
+  return exp.has_error() ? error.error() <= detail::extract_error(exp) : false;
+}
+
+template <typename T, typename E, typename U>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator>=(const result<T,E>& exp, const failure<U>& error)
+  noexcept -> bool
+{
+  return exp.has_error() ? detail::extract_error(exp) >= error.error() : false;
+}
+
+template <typename T, typename U, typename E>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator>=(const failure<T>& error, const result<E,U>& exp)
+  noexcept -> bool
+{
+  return exp.has_error() ? error.error() >= detail::extract_error(exp) : true;
+}
+
+template <typename T, typename E, typename U>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator<(const result<T,E>& exp, const failure<U>& error)
+  noexcept -> bool
+{
+  return exp.has_error() ? detail::extract_error(exp) < error.error() : true;
+}
+
+template <typename T, typename U, typename E>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator<(const failure<T>& error, const result<E,U>& exp)
+  noexcept -> bool
+{
+  return exp.has_error() ? error.error() < detail::extract_error(exp) : false;
+}
+
+template <typename T, typename E, typename U>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator>(const result<T,E>& exp, const failure<U>& error)
+  noexcept -> bool
+{
+  return exp.has_error() ? detail::extract_error(exp) > error.error() : false;
+}
+
+template <typename T, typename U, typename E>
+inline RESULT_INLINE_VISIBILITY constexpr
+auto RESULT_NS_IMPL::operator>(const failure<T>& error, const result<E,U>& exp)
+  noexcept -> bool
+{
+  return exp.has_error() ? error.error() > detail::extract_error(exp) : true;
+}
+
+//-----------------------------------------------------------------------------
+// Utilities
+//-----------------------------------------------------------------------------
+
+template <typename T, typename E>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::swap(result<T,E>& lhs, result<T,E>& rhs)
+#if __cplusplus >= 201703L
+  noexcept(std::is_nothrow_move_constructible<result<T,E>>::value &&
+           std::is_nothrow_move_assignable<result<T,E>>::value &&
+           std::is_nothrow_swappable<T>::value &&
+           std::is_nothrow_swappable<E>::value)
+#else
+  noexcept(std::is_nothrow_move_constructible<result<T,E>>::value &&
+           std::is_nothrow_move_assignable<result<T,E>>::value)
+#endif
+  -> void
+{
+  using std::swap;
+
+  if (lhs.has_value() == rhs.has_value()) {
+    if (lhs.has_value()) {
+      swap(*lhs, *rhs);
+    } else {
+      auto& lhs_error = detail::result_error_extractor::get(lhs);
+      auto& rhs_error = detail::result_error_extractor::get(rhs);
+
+      swap(lhs_error, rhs_error);
+    }
+    // If both `result`s contain values, do nothing
+  } else {
+    auto temp = static_cast<result<T,E>&&>(lhs);
+    lhs = static_cast<result<T,E>&&>(rhs);
+    rhs = static_cast<result<T,E>&&>(temp);
+  }
+}
+
+template <typename E>
+inline RESULT_INLINE_VISIBILITY
+auto RESULT_NS_IMPL::swap(result<void,E>& lhs, result<void,E>& rhs)
+#if __cplusplus >= 201703L
+  noexcept(std::is_nothrow_move_constructible<result<void,E>>::value &&
+           std::is_nothrow_move_assignable<result<void,E>>::value &&
+           std::is_nothrow_swappable<E>::value)
+#else
+  noexcept(std::is_nothrow_move_constructible<result<void,E>>::value &&
+           std::is_nothrow_move_assignable<result<void,E>>::value)
+#endif
+   -> void
+{
+  using std::swap;
+
+  if (lhs.has_value() == rhs.has_value()) {
+    if (lhs.has_error()) {
+      auto& lhs_error = detail::result_error_extractor::get(lhs);
+      auto& rhs_error = detail::result_error_extractor::get(rhs);
+
+      swap(lhs_error, rhs_error);
+    }
+    // If both `result`s contain values, do nothing
+  } else {
+    auto temp = static_cast<result<void,E>&&>(lhs);
+    lhs = static_cast<result<void,E>&&>(rhs);
+    rhs = static_cast<result<void,E>&&>(temp);
+  }
+}
+
+#if defined(__clang__)
+# pragma clang diagnostic pop
+#endif
+
+#undef RESULT_NAMESPACE_INTERNAL
+#undef RESULT_NS_IMPL
+#undef RESULT_CPP14_CONSTEXPR
+#undef RESULT_CPP17_INLINE
+#undef RESULT_INLINE_VISIBILITY
+#undef RESULT_NODISCARD
+#undef RESULT_WARN_UNUSED
+
+#endif /* RESULT_RESULT_HPP */
\ No newline at end of file
diff --git a/loader/include/Geode/utils/Result.hpp b/loader/include/Geode/utils/Result.hpp
index 56c800b4..4fd2f43b 100644
--- a/loader/include/Geode/utils/Result.hpp
+++ b/loader/include/Geode/utils/Result.hpp
@@ -1,322 +1,234 @@
 #pragma once
 
 #include "../DefaultInclude.hpp"
+#include "../external/result/result.hpp"
 
+#include <fmt/format.h>
 #include <string>
 #include <string_view>
+#include <type_traits>
 #include <variant>
-#include <fmt/format.h>
 
-// clang-format off
+// clang-format on
 
 namespace geode {
-    namespace {
-        struct AnyType {
-            explicit AnyType() = delete;
-        };
-
-        template <class V, class RV>
-        concept ConvertibleToResult =
-            std::is_convertible_v<std::remove_reference_t<V>, std::remove_reference_t<RV>> ||
-            std::is_same_v<std::remove_reference_t<V>, std::remove_reference_t<RV>>;
-
+    namespace impl {
         using DefaultValue = std::monostate;
         using DefaultError = std::string;
+        template <class T>
+        using WrappedResult = std::conditional_t<
+            std::is_lvalue_reference_v<T>, std::reference_wrapper<std::remove_reference_t<T>>,
+            std::remove_const_t<T>>;
 
-        template<class T, class E>
-        struct Storage {
-            std::variant<T, E> m_value;
+        template <class E = impl::DefaultError>
+        class [[nodiscard]] Failure {
+        public:
+            WrappedResult<E> m_error;
 
-            bool holdsOk() const {
-                return std::holds_alternative<T>(m_value);
+            Failure() = default;
+
+            template <class E2>
+                requires(std::is_constructible_v<E, E2 const&>)
+            explicit constexpr Failure(E2 const& e) : m_error(e) {}
+
+            template <class E2>
+                requires(std::is_constructible_v<E, E2 &&>)
+            explicit constexpr Failure(E2&& e) : m_error(std::forward<E>(e)) {}
+
+            E& error() & noexcept {
+                return m_error;
             }
 
-            T getOk() const requires std::is_copy_constructible_v<T> {
-                return std::get<T>(m_value);
+            E const& error() const& noexcept {
+                return m_error;
             }
 
-            T&& getOk() requires(!std::is_copy_constructible_v<T>) {
-                return std::move(std::get<T>(m_value));
+            E&& error() && noexcept {
+                return static_cast<E&&>(m_error);
             }
 
-            E getErr() const requires std::is_copy_constructible_v<E> {
-                return std::get<E>(m_value);
+            E const&& error() const&& noexcept {
+                return static_cast<E&&>(m_error);
             }
-
-            E&& getErr() requires(!std::is_copy_constructible_v<E>) {
-                return std::move(std::get<E>(m_value));
-            }
-
-            template<class T2, class E2>
-                requires
-                    std::is_convertible_v<T2, T> &&
-                    std::is_convertible_v<E2, E>
-            Storage(Storage<T2, E2> const& other)
-                requires
-                    std::is_copy_constructible_v<T> &&
-                    std::is_copy_constructible_v<E>
-            {
-                if (other.holdsOk()) {
-                    m_value = other.getOk();
-                } else {
-                    m_value = other.getErr();
-                }
-            }
-            
-            Storage(T const& value)
-                requires std::is_copy_constructible_v<T>
-              : m_value(value) {}
-
-            Storage(T&& value)
-                requires std::is_move_constructible_v<T>
-              : m_value(std::forward<T>(value)) {}
-
-            Storage(E const& value, std::monostate)
-                requires std::is_copy_constructible_v<E>
-              : m_value(value) {}
-
-            Storage(E&& value, std::monostate)
-                requires std::is_move_constructible_v<E>
-              : m_value(std::forward<E>(value)) {}
         };
 
-        template<class T>
-        struct Storage<T, T> {
-            bool m_holdsOk;
-            T m_value;
+        template <class T = impl::DefaultValue>
+        class [[nodiscard]] Success {
+        public:
+            WrappedResult<T> m_value;
 
-            bool holdsOk() const {
-                return m_holdsOk;
-            }
+            Success() = default;
 
-            T getOk() const requires std::is_copy_constructible_v<T> {
+            template <class T2>
+                requires(std::is_constructible_v<T, T2 const&>)
+            explicit constexpr Success(T2 const& v) : m_value(v) {}
+
+            template <class T2>
+                requires(std::is_constructible_v<T, T2 &&>)
+            explicit constexpr Success(T2&& v) : m_value(std::forward<T>(v)) {}
+
+            T& value() & noexcept {
                 return m_value;
             }
 
-            T&& getOk() requires(!std::is_copy_constructible_v<T>) {
-                return std::move(m_value);
-            }
-
-            T getErr() const requires std::is_copy_constructible_v<T> {
+            T const& value() const& noexcept {
                 return m_value;
             }
 
-            T&& getErr() requires(!std::is_copy_constructible_v<T>) {
-                return std::move(m_value);
+            T&& value() && noexcept {
+                return static_cast<T&&>(m_value);
             }
 
-            template<class T2, class E2>
-                requires
-                    std::is_convertible_v<T2, T> &&
-                    std::is_convertible_v<E2, T>
-            Storage(Storage<T2, E2> const& other)
-                requires
-                    std::is_copy_constructible_v<T> &&
-                    std::is_copy_constructible_v<T>
-               : m_value(other.holdsOk() ? other.getOk() : other.getErr()),
-                 m_holdsOk(other.holdsOk()) {}
-            
-            Storage(T const& value)
-                requires std::is_copy_constructible_v<T>
-              : m_value(value),
-                m_holdsOk(true) {}
-
-            Storage(T&& value)
-                requires std::is_move_constructible_v<T>
-              : m_value(std::forward<T>(value)),
-                m_holdsOk(true) {}
-
-            Storage(T const& value, std::monostate)
-                requires std::is_copy_constructible_v<T>
-              : m_value(value),
-                m_holdsOk(false) {}
-
-            Storage(T&& value, std::monostate)
-                requires std::is_move_constructible_v<T>
-              : m_value(std::forward<T>(value)),
-                m_holdsOk(false) {}
+            T const&& value() const&& noexcept {
+                return static_cast<T&&>(m_value);
+            }
         };
     }
 
-    template <class T = DefaultValue, class E = DefaultError>
-    class [[nodiscard]] Result final {
+    template <class T = impl::DefaultValue, class E = impl::DefaultError>
+    class [[nodiscard]] Result : public cpp::result<T, E> {
     public:
-        using value_type = std::remove_reference_t<T>;
-        using error_type = std::remove_reference_t<E>;
+        using Base = cpp::result<T, E>;
+        using ValueType = typename Base::value_type;
+        using ErrorType = typename Base::error_type;
 
-        // for some reason doing requires causes errors with pch...
-        static_assert(
-            std::is_copy_constructible_v<value_type> || std::is_move_constructible_v<value_type>,
-            "T must be copiable or movable!"
-        );
-        static_assert(
-            std::is_copy_constructible_v<error_type> || std::is_move_constructible_v<error_type>,
-            "E must be copiable or movable!"
-        );
+        using Base::result;
 
-    protected:
-        Storage<value_type, error_type> m_value;
+        template <class U>
+            requires(cpp::detail::result_is_implicit_value_convertible<T, U>::value)
+        constexpr Result(U&& value) = delete;
 
-    public:
-        Storage<value_type, error_type> const& _Raw_Storage() const {
-            return m_value;
+        template <class E2>
+            requires(std::is_constructible_v<E, E2 const&>)
+        constexpr Result(impl::Failure<E2> const& e) : Base(cpp::failure<E>(e.error())) {}
+
+        template <class E2>
+            requires(std::is_constructible_v<E, E2 &&>)
+        constexpr Result(impl::Failure<E2>&& e) : Base(cpp::failure<E>(e.error())) {}
+
+        template <class T2>
+            requires(std::is_constructible_v<T, T2 const&>)
+        constexpr Result(impl::Success<T2> const& s) : Base(s.value()) {}
+
+        template <class T2>
+            requires(std::is_constructible_v<T, T2 &&>)
+        constexpr Result(impl::Success<T2>&& s) : Base(s.value()) {}
+
+        [[nodiscard]] constexpr explicit operator bool() const noexcept {
+            return this->operator bool();
         }
 
-        bool isOk() const {
-            return m_value.holdsOk();
+        [[nodiscard]] constexpr bool isOk() const noexcept {
+            return this->has_value();
         }
 
-        bool isErr() const {
-            return !m_value.holdsOk();
+        [[nodiscard]] constexpr bool isErr() const noexcept {
+            return this->has_error();
         }
 
-        template<class ... Args>
-        Result<T, std::string> expect(const char* str, Args&&... args) {
-            if (isErr()) {
-                return Result<T, std::string>(fmt::format(
-                    str,
-                    std::forward<Args>(args)...,
-                    fmt::arg("error", unwrapErr())
-                ), std::monostate());
-            } else {
+        [[nodiscard]] constexpr decltype(auto) unwrap() & {
+            return this->value();
+        }
+
+        [[nodiscard]] constexpr decltype(auto) unwrap() const& {
+            return this->value();
+        }
+
+        [[nodiscard]] constexpr decltype(auto) unwrap() && {
+            return this->value();
+        }
+
+        [[nodiscard]] constexpr decltype(auto) unwrap() const&& {
+            return this->value();
+        }
+
+        [[nodiscard]] constexpr decltype(auto) unwrapErr() & {
+            return this->error();
+        }
+
+        [[nodiscard]] constexpr decltype(auto) unwrapErr() const& {
+            return this->error();
+        }
+
+        [[nodiscard]] constexpr decltype(auto) unwrapErr() && {
+            return this->error();
+        }
+
+        [[nodiscard]] constexpr decltype(auto) unwrapErr() const&& {
+            return this->error();
+        }
+
+        template <class... Args>
+        [[nodiscard]] Result<T, std::string> expect(std::string const& format, Args&&... args)
+            const {
+            if (this->isErr()) {
+                return impl::Failure<std::string>(fmt::format(
+                    fmt::runtime(format), std::forward<Args>(args)...,
+                    fmt::arg("error", this->unwrapErr())
+                ));
+            }
+            else {
                 return *this;
             }
         }
 
-        explicit Result(value_type const& value)
-            requires std::is_copy_constructible_v<value_type>
-          : m_value(value) {}
-
-        explicit Result(value_type&& value)
-            requires std::is_move_constructible_v<value_type>
-          : m_value(std::forward<value_type>(value)) {}
-
-        explicit Result(error_type const& value, std::monostate)
-            requires std::is_copy_constructible_v<error_type>
-          : m_value(value, std::monostate()) {}
-
-        explicit Result(error_type&& value, std::monostate)
-            requires std::is_move_constructible_v<error_type>
-          : m_value(std::forward<error_type>(value), std::monostate()) {}
-
-        Result(Result<T, E> const& other)
-            requires
-                std::is_copy_constructible_v<value_type> &&
-                std::is_copy_constructible_v<error_type>
-            = default;
-
-        Result(Result<T, E>&& other)
-            requires(
-                !std::is_copy_constructible_v<value_type> ||
-                !std::is_copy_constructible_v<error_type>
-            ) = default;
-
-        template<class T2, class E2>
-            requires
-                std::is_convertible_v<T2, T> &&
-                std::is_convertible_v<E2, E>
-        Result(Result<T2, E2> const& other)
-            requires
-                std::is_copy_constructible_v<value_type> &&
-                std::is_copy_constructible_v<error_type>
-          : m_value(other._Raw_Storage()) {}
-
-        template <class T2>
-            requires ConvertibleToResult<T2, T>
-        Result(Result<T2, AnyType> const& other)
-            requires
-                std::is_copy_constructible_v<value_type> &&
-                std::is_copy_constructible_v<error_type>
-          : Result(value_type(other.unwrap())) {}
-
-        template <class E2>
-            requires ConvertibleToResult<E2, E>
-        Result(Result<AnyType, E2> const& other)
-            requires
-                std::is_copy_constructible_v<value_type> &&
-                std::is_copy_constructible_v<error_type>
-          : m_value(std::forward<E2>(other.unwrapErr()), std::monostate()) {}
-
-        template <class T2>
-            requires ConvertibleToResult<T2, T>
-        Result(Result<T2, AnyType>&& other)
-            requires(
-                !std::is_copy_constructible_v<value_type> ||
-                !std::is_copy_constructible_v<error_type>
-            )
-          : m_value(other.unwrap()) {}
-
-        template <class E2>
-            requires ConvertibleToResult<E2, E>
-        Result(Result<AnyType, E2>&& other)
-            requires(
-                !std::is_copy_constructible_v<value_type> ||
-                !std::is_copy_constructible_v<error_type>
-            )
-          : Result(std::forward<error_type>(other.unwrapErr()), std::monostate()) {}
-
-        value_type unwrap() const requires std::is_copy_constructible_v<value_type> {
-            return m_value.getOk();
+        template <class U>
+        [[nodiscard]] constexpr decltype(auto) unwrapOr(U&& val) && {
+            return this->value_or(std::forward<U>(val));
         }
 
-        value_type&& unwrap() requires(!std::is_copy_constructible_v<value_type>) {
-            return std::forward<value_type>(m_value.getOk());
+        template <class U>
+        [[nodiscard]] constexpr decltype(auto) unwrapOr(U&& val) const& {
+            return this->value_or(std::forward<U>(val));
         }
 
-        error_type unwrapErr() const requires std::is_copy_constructible_v<error_type> {
-            return m_value.getErr();
+        template <class U>
+        [[nodiscard]] constexpr decltype(auto) errorOr(U&& val) && {
+            return this->error_or(std::forward<U>(val));
         }
 
-        error_type&& unwrapErr() requires(!std::is_copy_constructible_v<error_type>) {
-            return std::forward<error_type>(m_value.getErr());
-        }
-
-        explicit operator bool() const requires(
-            !std::is_same_v<T, bool> &&
-            !std::is_same_v<E, bool>
-        ) {
-            return this->isOk();
+        template <class U>
+        [[nodiscard]] constexpr decltype(auto) errorOr(U&& val) const& {
+            return this->error_or(std::forward<U>(val));
         }
     };
 
-    template <class T = DefaultValue, class E = AnyType>
-        requires std::is_copy_constructible_v<T>
-    Result<T, E> Ok(T value = T()) {
-        return Result<T, E>(value);
+    template <class T = impl::DefaultValue>
+    constexpr impl::Success<T> Ok() {
+        return impl::Success<T>();
     }
 
-    template <class T = DefaultValue, class E = AnyType>
-        requires(!std::is_copy_constructible_v<T>)
-    Result<T, E> Ok(T&& value) {
-        return Result<T, E>(std::forward<T>(value));
+    template <class T>
+    constexpr impl::Success<T> Ok(T&& value) {
+        return impl::Success<T>(std::forward<T>(value));
     }
 
-    template <class E = DefaultError, class T = AnyType>
-        requires std::is_copy_constructible_v<E>
-    Result<T, E> Err(E error) {
-        return Result<T, E>(error, std::monostate());
+    template <class E>
+    constexpr impl::Failure<E> Err(E&& error) {
+        return impl::Failure<E>(std::forward<E>(error));
     }
 
-    template <class E = DefaultError, class T = AnyType>
-        requires(!std::is_copy_constructible_v<E>)
-    Result<T, E> Err(E&& error) {
-        return Result<T, E>(std::forward<E>(error), std::monostate());
+    template <class... Args>
+    inline impl::Failure<std::string> Err(std::string const& format, Args&&... args) {
+        return impl::Failure<std::string>(
+            fmt::format(fmt::runtime(format), std::forward<Args>(args)...)
+        );
     }
 
-    #define GEODE_UNWRAP_INTO(into, ...)                                            \
+#define GEODE_UNWRAP_INTO(into, ...)                                            \
+    auto GEODE_CONCAT(unwrap_res_, __LINE__) = (__VA_ARGS__);                   \
+    if (GEODE_CONCAT(unwrap_res_, __LINE__).isErr()) {                          \
+        return Err(std::move(GEODE_CONCAT(unwrap_res_, __LINE__).unwrapErr())); \
+    }                                                                           \
+    into = std::move(GEODE_CONCAT(unwrap_res_, __LINE__).unwrap())
+
+#define GEODE_UNWRAP(...)                                                           \
+    {                                                                               \
         auto GEODE_CONCAT(unwrap_res_, __LINE__) = (__VA_ARGS__);                   \
         if (GEODE_CONCAT(unwrap_res_, __LINE__).isErr()) {                          \
             return Err(std::move(GEODE_CONCAT(unwrap_res_, __LINE__).unwrapErr())); \
         }                                                                           \
-        into = std::move(GEODE_CONCAT(unwrap_res_, __LINE__).unwrap())
-
-    #define GEODE_UNWRAP(...)                                                           \
-        {                                                                               \
-            auto GEODE_CONCAT(unwrap_res_, __LINE__) = (__VA_ARGS__);                   \
-            if (GEODE_CONCAT(unwrap_res_, __LINE__).isErr()) {                          \
-                return Err(std::move(GEODE_CONCAT(unwrap_res_, __LINE__).unwrapErr())); \
-            }                                                                           \
-        }
+    }
 }
 
 // clang-format on
diff --git a/loader/src/loader/Hook.cpp b/loader/src/loader/Hook.cpp
index 47693bb4..3e61e80d 100644
--- a/loader/src/loader/Hook.cpp
+++ b/loader/src/loader/Hook.cpp
@@ -78,7 +78,7 @@ Result<Hook*> Mod::addHook(Hook* hook) {
     else {
         internalHooks().push_back({ hook, this });
     }
-    return Ok<Hook*>(hook);
+    return Ok(hook);
 }
 
 bool InternalLoader::loadHooks() {
diff --git a/loader/src/loader/ModInfo.cpp b/loader/src/loader/ModInfo.cpp
index a5f2bc4e..c2c9f1e9 100644
--- a/loader/src/loader/ModInfo.cpp
+++ b/loader/src/loader/ModInfo.cpp
@@ -123,7 +123,7 @@ Result<ModInfo> ModInfo::create(ModJson const& json) {
     if (schema < Loader::minModVersion()) {
         return Err(
             "[mod.json] is built for an older version (" + schema.toString() +
-            ") of Geode (current: " + Loader::minModVersion().toString() +
+            ") of Geode (current: " + Loader::getVersion().toString() +
             "). Please update the mod to the latest version, "
             "and if the problem persists, contact the developer "
             "to update it."
@@ -132,7 +132,7 @@ Result<ModInfo> ModInfo::create(ModJson const& json) {
     if (schema > Loader::maxModVersion()) {
         return Err(
             "[mod.json] is built for a newer version (" + schema.toString() +
-            ") of Geode (current: " + Loader::maxModVersion().toString() +
+            ") of Geode (current: " + Loader::getVersion().toString() +
             "). You need to update Geode in order to use "
             "this mod."
         );
diff --git a/loader/src/loader/Patch.cpp b/loader/src/loader/Patch.cpp
index 99a1b4be..e5175db8 100644
--- a/loader/src/loader/Patch.cpp
+++ b/loader/src/loader/Patch.cpp
@@ -28,7 +28,7 @@ Result<Patch*> Mod::patch(void* address, byte_array data) {
         return Err("Unable to enable patch at " + std::to_string(p->getAddress()));
     }
     m_patches.push_back(p);
-    return Ok<Patch*>(p);
+    return Ok(p);
 }
 
 Result<> Mod::unpatch(Patch* patch) {
diff --git a/loader/src/platform/mac/Cocos2d.cpp b/loader/src/platform/mac/Cocos2d.cpp
index 1eabd25c..16af07d2 100644
--- a/loader/src/platform/mac/Cocos2d.cpp
+++ b/loader/src/platform/mac/Cocos2d.cpp
@@ -5,10 +5,6 @@
 #include <cocos2d.h>
 using namespace cocos2d;
 
-void CCFileUtils::removeAllPaths() {
-    m_searchPathArray.clear();
-}
-
 CCObject* CCObject::copy()
 {
     return copyWithZone(0);
diff --git a/loader/src/ui/nodes/Notification.cpp b/loader/src/ui/nodes/Notification.cpp
index 92f6ffeb..ff53d95a 100644
--- a/loader/src/ui/nodes/Notification.cpp
+++ b/loader/src/ui/nodes/Notification.cpp
@@ -1,20 +1,19 @@
 #include <Geode/binding/LoadingCircle.hpp>
-#include <Geode/ui/Notification.hpp>
 #include <Geode/loader/Mod.hpp>
+#include <Geode/ui/Notification.hpp>
 
 USE_GEODE_NAMESPACE();
 
-constexpr auto NOTIFICATION_FADEIN  = .3f;
+constexpr auto NOTIFICATION_FADEIN = .3f;
 constexpr auto NOTIFICATION_FADEOUT = 1.f;
 
 Ref<CCArray> Notification::s_queue = CCArray::create();
 
 bool Notification::init(std::string const& text, CCSprite* icon, float time) {
-    if (!CCNodeRGBA::init())
-        return false;
-    
+    if (!CCNodeRGBA::init()) return false;
+
     m_time = time;
-    
+
     m_bg = CCScale9Sprite::create("square02b_small.png", { 0, 0, 40, 40 });
     m_bg->setColor({ 0, 0, 0 });
     this->addChild(m_bg);
@@ -48,7 +47,8 @@ void Notification::updateLayout() {
     if (m_icon) {
         m_icon->setPosition({ size.height / 2, size.height / 2 });
         m_label->setPosition(size / 2 + CCSize { spaceForIcon / 2, .0f });
-    } else {
+    }
+    else {
         m_label->setPosition(size / 2);
     }
 }
@@ -73,9 +73,7 @@ CCSprite* Notification::createIcon(NotificationIcon icon) {
 
         case NotificationIcon::Loading: {
             auto icon = CCSprite::create("loadingCircle.png");
-            icon->runAction(CCRepeatForever::create(
-                CCRotateBy::create(1.f, 360.f)
-            ));
+            icon->runAction(CCRepeatForever::create(CCRotateBy::create(1.f, 360.f)));
             icon->setBlendFunc({ GL_ONE, GL_ONE });
             return icon;
         } break;
@@ -94,11 +92,7 @@ CCSprite* Notification::createIcon(NotificationIcon icon) {
     }
 }
 
-Notification* Notification::create(
-    std::string const& text,
-    NotificationIcon icon,
-    float time
-) {
+Notification* Notification::create(std::string const& text, NotificationIcon icon, float time) {
     return Notification::create(text, createIcon(icon), time);
 }
 
@@ -125,7 +119,8 @@ void Notification::setIcon(cocos2d::CCSprite* icon) {
     if (m_icon) {
         m_icon->removeFromParent();
     }
-    if (m_icon = icon) {
+    m_icon = icon;
+    if (icon) {
         m_bg->addChild(icon);
     }
     this->updateLayout();
@@ -171,8 +166,7 @@ void Notification::show() {
         CCCallFunc::create(this, callfunc_selector(Notification::animateIn)),
         // wait for fade-in to finish
         CCDelayTime::create(NOTIFICATION_FADEIN),
-        CCCallFunc::create(this, callfunc_selector(Notification::wait)),
-        nullptr
+        CCCallFunc::create(this, callfunc_selector(Notification::wait)), nullptr
     ));
 }
 
@@ -181,8 +175,7 @@ void Notification::wait() {
     if (m_time) {
         this->runAction(CCSequence::create(
             CCDelayTime::create(m_time),
-            CCCallFunc::create(this, callfunc_selector(Notification::hide)),
-            nullptr
+            CCCallFunc::create(this, callfunc_selector(Notification::hide)), nullptr
         ));
     }
 }
@@ -193,8 +186,6 @@ void Notification::hide() {
         CCCallFunc::create(this, callfunc_selector(Notification::animateOut)),
         // wait for fade-out to finish
         CCDelayTime::create(NOTIFICATION_FADEOUT),
-        CCCallFunc::create(this, callfunc_selector(Notification::showNextNotification)),
-        nullptr
+        CCCallFunc::create(this, callfunc_selector(Notification::showNextNotification)), nullptr
     ));
 }
-
diff --git a/loader/src/utils/file.cpp b/loader/src/utils/file.cpp
index 03c0a237..63456092 100644
--- a/loader/src/utils/file.cpp
+++ b/loader/src/utils/file.cpp
@@ -1,11 +1,11 @@
-#include <Geode/utils/file.hpp>
-#include <Geode/utils/string.hpp>
-#include <Geode/utils/map.hpp>
-#include <Geode/loader/Log.hpp>
-#include <fstream>
 #include <../support/zip_support/ZipUtils.h>
 #include <../support/zip_support/ioapi.h>
 #include <../support/zip_support/unzip.h>
+#include <Geode/loader/Log.hpp>
+#include <Geode/utils/file.hpp>
+#include <Geode/utils/map.hpp>
+#include <Geode/utils/string.hpp>
+#include <fstream>
 
 USE_GEODE_NAMESPACE();
 using namespace geode::utils::file;
@@ -147,9 +147,7 @@ public:
         unz_file_info64 fileInfo;
 
         // Read first file
-        if (unzGoToFirstFile64(
-            m_zip, &fileInfo, fileName, sizeof(fileName) - 1
-        )) {
+        if (unzGoToFirstFile64(m_zip, &fileInfo, fileName, sizeof(fileName) - 1)) {
             return false;
         }
         // Loop over all files
@@ -157,18 +155,15 @@ public:
             // Read file and add to entries
             unz_file_pos pos;
             if (unzGetFilePos(m_zip, &pos) == UNZ_OK) {
-                m_entries.insert({
-                    fileName, ZipEntry {
-                        .m_pos = pos,
-                        .m_compressedSize = fileInfo.compressed_size,
-                        .m_uncompressedSize = fileInfo.uncompressed_size,
-                    }
-                });
+                m_entries.insert({ fileName,
+                                   ZipEntry {
+                                       .m_pos = pos,
+                                       .m_compressedSize = fileInfo.compressed_size,
+                                       .m_uncompressedSize = fileInfo.uncompressed_size,
+                                   } });
             }
             // Read next file, or break on error
-            if (unzGoToNextFile64(
-                m_zip, &fileInfo, fileName, sizeof(fileName) - 1
-            ) != UNZ_OK) {
+            if (unzGoToNextFile64(m_zip, &fileInfo, fileName, sizeof(fileName) - 1) != UNZ_OK) {
                 break;
             }
         }
@@ -208,6 +203,7 @@ public:
     }
 
     UnzipImpl(unzFile zip, Path const& path) : m_zip(zip), m_zipPath(path) {}
+
     ~UnzipImpl() {
         unzClose(m_zip);
     }

From 67d26ac6a7c71e7f8f0723efb6c47c297b3b46a3 Mon Sep 17 00:00:00 2001
From: altalk23 <45172705+altalk23@users.noreply.github.com>
Date: Sat, 3 Dec 2022 14:35:28 +0300
Subject: [PATCH 2/2] fully fix result impl

---
 loader/include/Geode/utils/Result.hpp | 8 ++++----
 loader/src/utils/cocos.cpp            | 4 ++--
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/loader/include/Geode/utils/Result.hpp b/loader/include/Geode/utils/Result.hpp
index 4fd2f43b..56c31ae1 100644
--- a/loader/include/Geode/utils/Result.hpp
+++ b/loader/include/Geode/utils/Result.hpp
@@ -33,7 +33,7 @@ namespace geode {
 
             template <class E2>
                 requires(std::is_constructible_v<E, E2 &&>)
-            explicit constexpr Failure(E2&& e) : m_error(std::forward<E>(e)) {}
+            explicit constexpr Failure(E2&& e) : m_error(std::move(e)) {}
 
             E& error() & noexcept {
                 return m_error;
@@ -65,7 +65,7 @@ namespace geode {
 
             template <class T2>
                 requires(std::is_constructible_v<T, T2 &&>)
-            explicit constexpr Success(T2&& v) : m_value(std::forward<T>(v)) {}
+            explicit constexpr Success(T2&& v) : m_value(std::forward<T2>(v)) {}
 
             T& value() & noexcept {
                 return m_value;
@@ -104,7 +104,7 @@ namespace geode {
 
         template <class E2>
             requires(std::is_constructible_v<E, E2 &&>)
-        constexpr Result(impl::Failure<E2>&& e) : Base(cpp::failure<E>(e.error())) {}
+        constexpr Result(impl::Failure<E2>&& e) : Base(cpp::failure<E>(std::move(e.error()))) {}
 
         template <class T2>
             requires(std::is_constructible_v<T, T2 const&>)
@@ -112,7 +112,7 @@ namespace geode {
 
         template <class T2>
             requires(std::is_constructible_v<T, T2 &&>)
-        constexpr Result(impl::Success<T2>&& s) : Base(s.value()) {}
+        constexpr Result(impl::Success<T2>&& s) : Base(std::move(s.value())) {}
 
         [[nodiscard]] constexpr explicit operator bool() const noexcept {
             return this->operator bool();
diff --git a/loader/src/utils/cocos.cpp b/loader/src/utils/cocos.cpp
index 36cb10f0..ac2a6fef 100644
--- a/loader/src/utils/cocos.cpp
+++ b/loader/src/utils/cocos.cpp
@@ -1,5 +1,5 @@
-#include <Geode/utils/cocos.hpp>
 #include <Geode/modify/LoadingLayer.hpp>
+#include <Geode/utils/cocos.hpp>
 
 USE_GEODE_NAMESPACE();
 
@@ -346,7 +346,7 @@ void geode::cocos::reloadTextures(CreateLayerFunc returnTo) {
     GameManager::get()->reloadAll(false, false, true);
 }
 
-class $modify(LoadingLayer) {
+struct LoadingFinished : Modify<LoadingFinished, LoadingLayer> {
     void loadAssets() {
         // loadFinished is inlined on Macchew OS :sob: