diff --git a/src/sled/cleanup.h b/src/sled/cleanup.h
index 5cc1fa5..a522b49 100644
--- a/src/sled/cleanup.h
+++ b/src/sled/cleanup.h
@@ -50,7 +50,7 @@ public:
     }
 
 private:
-    sled::optional<Callback> callback_;
+    tl::optional<Callback> callback_;
 };
 
 template<typename... Args, typename Callback>
diff --git a/src/sled/config.cc b/src/sled/config.cc
index 6c81ba9..e19b01d 100644
--- a/src/sled/config.cc
+++ b/src/sled/config.cc
@@ -256,16 +256,16 @@ Config::AddDefaultNode(sled::string_view key, ValueType value)
         auto first_key = keys[0];
         switch (value.index()) {
         case 0:
-            toml_[first_key] = sled::get<bool>(value);
+            toml_[first_key] = mpark::get<bool>(value);
             break;
         case 1:
-            toml_[first_key] = sled::get<std::string>(value);
+            toml_[first_key] = mpark::get<std::string>(value);
             break;
         case 2:
-            toml_[first_key] = sled::get<int>(value);
+            toml_[first_key] = mpark::get<int>(value);
             break;
         case 3:
-            toml_[first_key] = sled::get<double>(value);
+            toml_[first_key] = mpark::get<double>(value);
             break;
         default:
             return false;
@@ -284,16 +284,16 @@ Config::GetValueNode(sled::string_view key, toml::value &value) const
     auto &default_value = iter->second;
     switch (default_value.index()) {
     case 0:
-        value = sled::get<bool>(default_value);
+        value = mpark::get<bool>(default_value);
         break;
     case 1:
-        value = sled::get<std::string>(default_value);
+        value = mpark::get<std::string>(default_value);
         break;
     case 2:
-        value = sled::get<int>(default_value);
+        value = mpark::get<int>(default_value);
         break;
     case 3:
-        value = sled::get<double>(default_value);
+        value = mpark::get<double>(default_value);
         break;
     default:
         return false;
@@ -309,16 +309,16 @@ Config::GetDefaultNode(sled::string_view key, toml::value &value) const
     auto &default_value = iter->second;
     switch (default_value.index()) {
     case 0:
-        value = sled::get<bool>(default_value);
+        value = mpark::get<bool>(default_value);
         break;
     case 1:
-        value = sled::get<std::string>(default_value);
+        value = mpark::get<std::string>(default_value);
         break;
     case 2:
-        value = sled::get<int>(default_value);
+        value = mpark::get<int>(default_value);
         break;
     case 3:
-        value = sled::get<double>(default_value);
+        value = mpark::get<double>(default_value);
         break;
     default:
         return false;
diff --git a/src/sled/config.h b/src/sled/config.h
index 332c63f..e7954c2 100644
--- a/src/sled/config.h
+++ b/src/sled/config.h
@@ -8,9 +8,9 @@
 namespace sled {
 class Config {
 public:
-    using ValueType = sled::variant<bool, std::string, int, double>;
+    using ValueType = mpark::variant<bool, std::string, int, double>;
     Config();
-    virtual ~Config()=default;
+    virtual ~Config() = default;
     Config(sled::string_view name);
     Config(sled::string_view name, sled::string_view path);
     Config(const Config &lhs)                = delete;
diff --git a/src/sled/nonstd/expected.h b/src/sled/nonstd/expected.h
index c4e816e..c7057f4 100644
--- a/src/sled/nonstd/expected.h
+++ b/src/sled/nonstd/expected.h
@@ -1,2613 +1,3067 @@
-///
-// expected - An implementation of std::expected with extensions
-// Written in 2017 by Sy Brand (tartanllama@gmail.com, @TartanLlama)
+// This version targets C++11 and later.
 //
-// Documentation available at http://tl.tartanllama.xyz/
+// Copyright (C) 2016-2020 Martin Moene.
 //
-// To the extent possible under law, the author(s) have dedicated all
-// copyright and related and neighboring rights to this software to the
-// public domain worldwide. This software is distributed without any warranty.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //
-// You should have received a copy of the CC0 Public Domain Dedication
-// along with this software. If not, see
-// <http://creativecommons.org/publicdomain/zero/1.0/>.
-///
+// expected lite is based on:
+//   A proposal to add a utility class to represent expected monad
+//   by Vicente J. Botet Escriba and Pierre Talbot. http:://wg21.link/p0323
 
-#ifndef TL_EXPECTED_HPP
-#define TL_EXPECTED_HPP
+#ifndef NONSTD_EXPECTED_LITE_HPP
+#define NONSTD_EXPECTED_LITE_HPP
 
-#define TL_EXPECTED_VERSION_MAJOR 1
-#define TL_EXPECTED_VERSION_MINOR 1
-#define TL_EXPECTED_VERSION_PATCH 0
+#define expected_lite_MAJOR 0
+#define expected_lite_MINOR 6
+#define expected_lite_PATCH 3
 
+#define expected_lite_VERSION                                                  \
+  expected_STRINGIFY(expected_lite_MAJOR) "." expected_STRINGIFY(              \
+      expected_lite_MINOR) "." expected_STRINGIFY(expected_lite_PATCH)
+
+#define expected_STRINGIFY(x) expected_STRINGIFY_(x)
+#define expected_STRINGIFY_(x) #x
+
+// expected-lite configuration:
+
+#define nsel_EXPECTED_DEFAULT 0
+#define nsel_EXPECTED_NONSTD 1
+#define nsel_EXPECTED_STD 2
+
+// tweak header support:
+
+#ifdef __has_include
+#if __has_include(<nonstd/expected.tweak.hpp>)
+#include <nonstd/expected.tweak.hpp>
+#endif
+#define expected_HAVE_TWEAK_HEADER 1
+#else
+#define expected_HAVE_TWEAK_HEADER 0
+// # pragma message("expected.hpp: Note: Tweak header not supported.")
+#endif
+
+// expected selection and configuration:
+
+#if !defined(nsel_CONFIG_SELECT_EXPECTED)
+#define nsel_CONFIG_SELECT_EXPECTED                                            \
+  (nsel_HAVE_STD_EXPECTED ? nsel_EXPECTED_STD : nsel_EXPECTED_NONSTD)
+#endif
+
+// Proposal revisions:
+//
+// DXXXXR0: --
+// N4015  : -2 (2014-05-26)
+// N4109  : -1 (2014-06-29)
+// P0323R0:  0 (2016-05-28)
+// P0323R1:  1 (2016-10-12)
+// -------:
+// P0323R2:  2 (2017-06-15)
+// P0323R3:  3 (2017-10-15)
+// P0323R4:  4 (2017-11-26)
+// P0323R5:  5 (2018-02-08)
+// P0323R6:  6 (2018-04-02)
+// P0323R7:  7 (2018-06-22) *
+//
+// expected-lite uses 2 and higher
+
+#ifndef nsel_P0323R
+#define nsel_P0323R 7
+#endif
+
+// Monadic operations proposal revisions:
+//
+// P2505R0:  0 (2021-12-12)
+// P2505R1:  1 (2022-02-10)
+// P2505R2:  2 (2022-04-15)
+// P2505R3:  3 (2022-06-05)
+// P2505R4:  4 (2022-06-15)
+// P2505R5:  5 (2022-09-20) *
+//
+// expected-lite uses 5
+
+#ifndef nsel_P2505R
+#define nsel_P2505R 5
+#endif
+
+// Control presence of C++ exception handling (try and auto discover):
+
+#ifndef nsel_CONFIG_NO_EXCEPTIONS
+#if defined(_MSC_VER)
+#include <cstddef> // for _HAS_EXCEPTIONS
+#endif
+#if defined(__cpp_exceptions) || defined(__EXCEPTIONS) || (_HAS_EXCEPTIONS)
+#define nsel_CONFIG_NO_EXCEPTIONS 0
+#else
+#define nsel_CONFIG_NO_EXCEPTIONS 1
+#endif
+#endif
+
+// at default use SEH with MSVC for no C++ exceptions
+
+#ifndef nsel_CONFIG_NO_EXCEPTIONS_SEH
+#define nsel_CONFIG_NO_EXCEPTIONS_SEH (nsel_CONFIG_NO_EXCEPTIONS && _MSC_VER)
+#endif
+
+// C++ language version detection (C++23 is speculative):
+// Note: VC14.0/1900 (VS2015) lacks too much from C++14.
+
+#ifndef nsel_CPLUSPLUS
+#if defined(_MSVC_LANG) && !defined(__clang__)
+#define nsel_CPLUSPLUS (_MSC_VER == 1900 ? 201103L : _MSVC_LANG)
+#else
+#define nsel_CPLUSPLUS __cplusplus
+#endif
+#endif
+
+#define nsel_CPP98_OR_GREATER (nsel_CPLUSPLUS >= 199711L)
+#define nsel_CPP11_OR_GREATER (nsel_CPLUSPLUS >= 201103L)
+#define nsel_CPP14_OR_GREATER (nsel_CPLUSPLUS >= 201402L)
+#define nsel_CPP17_OR_GREATER (nsel_CPLUSPLUS >= 201703L)
+#define nsel_CPP20_OR_GREATER (nsel_CPLUSPLUS >= 202002L)
+#define nsel_CPP23_OR_GREATER (nsel_CPLUSPLUS >= 202300L)
+
+// Use C++23 std::expected if available and requested:
+
+#if nsel_CPP23_OR_GREATER && defined(__has_include)
+#if __has_include(<expected> )
+#define nsel_HAVE_STD_EXPECTED 1
+#else
+#define nsel_HAVE_STD_EXPECTED 0
+#endif
+#else
+#define nsel_HAVE_STD_EXPECTED 0
+#endif
+
+#define nsel_USES_STD_EXPECTED                                                 \
+  ((nsel_CONFIG_SELECT_EXPECTED == nsel_EXPECTED_STD) ||                       \
+   ((nsel_CONFIG_SELECT_EXPECTED == nsel_EXPECTED_DEFAULT) &&                  \
+    nsel_HAVE_STD_EXPECTED))
+
+//
+// in_place: code duplicated in any-lite, expected-lite, expected-lite,
+// value-ptr-lite, variant-lite:
+//
+
+#ifndef nonstd_lite_HAVE_IN_PLACE_TYPES
+#define nonstd_lite_HAVE_IN_PLACE_TYPES 1
+
+// C++17 std::in_place in <utility>:
+
+#if nsel_CPP17_OR_GREATER
+
+#include <utility>
+
+namespace nonstd {
+
+using std::in_place;
+using std::in_place_index;
+using std::in_place_index_t;
+using std::in_place_t;
+using std::in_place_type;
+using std::in_place_type_t;
+
+#define nonstd_lite_in_place_t(T) std::in_place_t
+#define nonstd_lite_in_place_type_t(T) std::in_place_type_t<T>
+#define nonstd_lite_in_place_index_t(K) std::in_place_index_t<K>
+
+#define nonstd_lite_in_place(T)                                                \
+  std::in_place_t {}
+#define nonstd_lite_in_place_type(T)                                           \
+  std::in_place_type_t<T> {}
+#define nonstd_lite_in_place_index(K)                                          \
+  std::in_place_index_t<K> {}
+
+} // namespace nonstd
+
+#else // nsel_CPP17_OR_GREATER
+
+#include <cstddef>
+
+namespace nonstd {
+namespace detail {
+
+template <class T> struct in_place_type_tag {};
+
+template <std::size_t K> struct in_place_index_tag {};
+
+} // namespace detail
+
+struct in_place_t {};
+
+template <class T>
+inline in_place_t
+in_place(detail::in_place_type_tag<T> = detail::in_place_type_tag<T>()) {
+  return in_place_t();
+}
+
+template <std::size_t K>
+inline in_place_t
+in_place(detail::in_place_index_tag<K> = detail::in_place_index_tag<K>()) {
+  return in_place_t();
+}
+
+template <class T>
+inline in_place_t
+in_place_type(detail::in_place_type_tag<T> = detail::in_place_type_tag<T>()) {
+  return in_place_t();
+}
+
+template <std::size_t K>
+inline in_place_t in_place_index(
+    detail::in_place_index_tag<K> = detail::in_place_index_tag<K>()) {
+  return in_place_t();
+}
+
+// mimic templated typedef:
+
+#define nonstd_lite_in_place_t(T)                                              \
+  nonstd::in_place_t (&)(nonstd::detail::in_place_type_tag<T>)
+#define nonstd_lite_in_place_type_t(T)                                         \
+  nonstd::in_place_t (&)(nonstd::detail::in_place_type_tag<T>)
+#define nonstd_lite_in_place_index_t(K)                                        \
+  nonstd::in_place_t (&)(nonstd::detail::in_place_index_tag<K>)
+
+#define nonstd_lite_in_place(T) nonstd::in_place_type<T>
+#define nonstd_lite_in_place_type(T) nonstd::in_place_type<T>
+#define nonstd_lite_in_place_index(K) nonstd::in_place_index<K>
+
+} // namespace nonstd
+
+#endif // nsel_CPP17_OR_GREATER
+#endif // nonstd_lite_HAVE_IN_PLACE_TYPES
+
+//
+// Using std::expected:
+//
+
+#if nsel_USES_STD_EXPECTED
+
+#include <expected>
+
+namespace nonstd {
+
+using std::expected;
+//  ...
+} // namespace nonstd
+
+#else // nsel_USES_STD_EXPECTED
+
+#include <cassert>
 #include <exception>
 #include <functional>
+#include <initializer_list>
+#include <memory>
+#include <new>
+#include <system_error>
 #include <type_traits>
 #include <utility>
 
-#if defined(__EXCEPTIONS) || defined(_CPPUNWIND)
-#define TL_EXPECTED_EXCEPTIONS_ENABLED
-#endif
+// additional includes:
 
-#if (defined(_MSC_VER) && _MSC_VER == 1900)
-#define TL_EXPECTED_MSVC2015
-#define TL_EXPECTED_MSVC2015_CONSTEXPR
+#if nsel_CONFIG_NO_EXCEPTIONS
+#if nsel_CONFIG_NO_EXCEPTIONS_SEH
+#include <windows.h> // for ExceptionCodes
 #else
-#define TL_EXPECTED_MSVC2015_CONSTEXPR constexpr
+// already included: <cassert>
 #endif
-
-#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 && !defined(__clang__))
-#define TL_EXPECTED_GCC49
-#endif
-
-#if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 4 && !defined(__clang__))
-#define TL_EXPECTED_GCC54
-#endif
-
-#if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 5 && !defined(__clang__))
-#define TL_EXPECTED_GCC55
-#endif
-
-#if !defined(TL_ASSERT)
-//can't have assert in constexpr in C++11 and GCC 4.9 has a compiler bug
-#if (__cplusplus > 201103L) && !defined(TL_EXPECTED_GCC49)
-#include <cassert>
-#define TL_ASSERT(x) assert(x)
 #else
-#define TL_ASSERT(x)
-#endif
+#include <stdexcept>
 #endif
 
-#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 && !defined(__clang__))
-// GCC < 5 doesn't support overloading on const&& for member functions
+// C++ feature usage:
 
-#define TL_EXPECTED_NO_CONSTRR
-// GCC < 5 doesn't support some standard C++11 type traits
-#define TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) std::has_trivial_copy_constructor<T>
-#define TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T) std::has_trivial_copy_assign<T>
-
-// This one will be different for GCC 5.7 if it's ever supported
-#define TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>
-
-// GCC 5 < v < 8 has a bug in is_trivially_copy_constructible which breaks
-// std::vector for non-copyable types
-#elif (defined(__GNUC__) && __GNUC__ < 8 && !defined(__clang__))
-#ifndef TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX
-#define TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX
-
-namespace tl {
-namespace detail {
-template<class T>
-struct is_trivially_copy_constructible : std::is_trivially_copy_constructible<T> {};
-#ifdef _GLIBCXX_VECTOR
-template<class T, class A>
-struct is_trivially_copy_constructible<std::vector<T, A>> : std::false_type {};
-#endif
-}// namespace detail
-}// namespace tl
-#endif
-
-#define TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) tl::detail::is_trivially_copy_constructible<T>
-#define TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T) std::is_trivially_copy_assignable<T>
-#define TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>
+#if nsel_CPP11_OR_GREATER
+#define nsel_constexpr constexpr
 #else
-#define TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) std::is_trivially_copy_constructible<T>
-#define TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T) std::is_trivially_copy_assignable<T>
-#define TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>
+#define nsel_constexpr /*constexpr*/
 #endif
 
-#if __cplusplus > 201103L
-#define TL_EXPECTED_CXX14
-#endif
-
-#ifdef TL_EXPECTED_GCC49
-#define TL_EXPECTED_GCC49_CONSTEXPR
+#if nsel_CPP14_OR_GREATER
+#define nsel_constexpr14 constexpr
 #else
-#define TL_EXPECTED_GCC49_CONSTEXPR constexpr
+#define nsel_constexpr14 /*constexpr*/
 #endif
 
-#if (__cplusplus == 201103L || defined(TL_EXPECTED_MSVC2015) || defined(TL_EXPECTED_GCC49))
-#define TL_EXPECTED_11_CONSTEXPR
+#if nsel_CPP17_OR_GREATER
+#define nsel_inline17 inline
 #else
-#define TL_EXPECTED_11_CONSTEXPR constexpr
+#define nsel_inline17 /*inline*/
 #endif
 
-namespace tl {
-template<class T, class E>
-class expected;
-
-#ifndef TL_MONOSTATE_INPLACE_MUTEX
-#define TL_MONOSTATE_INPLACE_MUTEX
-
-class monostate {};
-
-struct in_place_t {
-    explicit in_place_t() = default;
-};
-
-static constexpr in_place_t in_place{};
-#endif
-
-template<class E>
-class unexpected {
-public:
-    static_assert(!std::is_same<E, void>::value, "E must not be void");
-
-    unexpected() = delete;
-
-    constexpr explicit unexpected(const E &e) : m_val(e) {}
-
-    constexpr explicit unexpected(E &&e) : m_val(std::move(e)) {}
-
-    template<class... Args, typename std::enable_if<std::is_constructible<E, Args &&...>::value>::type * = nullptr>
-    constexpr explicit unexpected(Args &&...args) : m_val(std::forward<Args>(args)...)
-    {}
-
-    template<class U,
-             class... Args,
-             typename std::enable_if<std::is_constructible<E, std::initializer_list<U> &, Args &&...>::value>::type
-                 * = nullptr>
-    constexpr explicit unexpected(std::initializer_list<U> l, Args &&...args) : m_val(l, std::forward<Args>(args)...)
-    {}
-
-    constexpr const E &value() const & { return m_val; }
-
-    TL_EXPECTED_11_CONSTEXPR E &value() & { return m_val; }
-
-    TL_EXPECTED_11_CONSTEXPR E &&value() && { return std::move(m_val); }
-
-    constexpr const E &&value() const && { return std::move(m_val); }
-
-private:
-    E m_val;
-};
-
-#ifdef __cpp_deduction_guides
-template<class E>
-unexpected(E) -> unexpected<E>;
-#endif
-
-template<class E>
-constexpr bool
-operator==(const unexpected<E> &lhs, const unexpected<E> &rhs)
-{
-    return lhs.value() == rhs.value();
-}
-
-template<class E>
-constexpr bool
-operator!=(const unexpected<E> &lhs, const unexpected<E> &rhs)
-{
-    return lhs.value() != rhs.value();
-}
-
-template<class E>
-constexpr bool
-operator<(const unexpected<E> &lhs, const unexpected<E> &rhs)
-{
-    return lhs.value() < rhs.value();
-}
-
-template<class E>
-constexpr bool
-operator<=(const unexpected<E> &lhs, const unexpected<E> &rhs)
-{
-    return lhs.value() <= rhs.value();
-}
-
-template<class E>
-constexpr bool
-operator>(const unexpected<E> &lhs, const unexpected<E> &rhs)
-{
-    return lhs.value() > rhs.value();
-}
-
-template<class E>
-constexpr bool
-operator>=(const unexpected<E> &lhs, const unexpected<E> &rhs)
-{
-    return lhs.value() >= rhs.value();
-}
-
-template<class E>
-unexpected<typename std::decay<E>::type>
-make_unexpected(E &&e)
-{
-    return unexpected<typename std::decay<E>::type>(std::forward<E>(e));
-}
-
-struct unexpect_t {
-    unexpect_t() = default;
-};
-
-static constexpr unexpect_t unexpect{};
-
-namespace detail {
-template<typename E>
-[[noreturn]] TL_EXPECTED_11_CONSTEXPR void
-throw_exception(E &&e)
-{
-#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED
-    throw std::forward<E>(e);
-#else
-    (void) e;
-#ifdef _MSC_VER
-    __assume(0);
-#else
-    __builtin_unreachable();
-#endif
-#endif
-}
-
-#ifndef TL_TRAITS_MUTEX
-#define TL_TRAITS_MUTEX
-// C++14-style aliases for brevity
-template<class T>
-using remove_const_t = typename std::remove_const<T>::type;
-template<class T>
-using remove_reference_t = typename std::remove_reference<T>::type;
-template<class T>
-using decay_t = typename std::decay<T>::type;
-template<bool E, class T = void>
-using enable_if_t = typename std::enable_if<E, T>::type;
-template<bool B, class T, class F>
-using conditional_t = typename std::conditional<B, T, F>::type;
-
-// std::conjunction from C++17
-template<class...>
-struct conjunction : std::true_type {};
-
-template<class B>
-struct conjunction<B> : B {};
-
-template<class B, class... Bs>
-struct conjunction<B, Bs...> : std::conditional<bool(B::value), conjunction<Bs...>, B>::type {};
-
-#if defined(_LIBCPP_VERSION) && __cplusplus == 201103L
-#define TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND
-#endif
-
-// In C++11 mode, there's an issue in libc++'s std::mem_fn
-// which results in a hard-error when using it in a noexcept expression
-// in some cases. This is a check to workaround the common failing case.
-#ifdef TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND
-template<class T>
-struct is_pointer_to_non_const_member_func : std::false_type {};
-
-template<class T, class Ret, class... Args>
-struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...)> : std::true_type {};
-
-template<class T, class Ret, class... Args>
-struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) &> : std::true_type {};
-
-template<class T, class Ret, class... Args>
-struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) &&> : std::true_type {};
-
-template<class T, class Ret, class... Args>
-struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile> : std::true_type {};
-
-template<class T, class Ret, class... Args>
-struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile &> : std::true_type {};
-
-template<class T, class Ret, class... Args>
-struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile &&> : std::true_type {};
-
-template<class T>
-struct is_const_or_const_ref : std::false_type {};
-
-template<class T>
-struct is_const_or_const_ref<T const &> : std::true_type {};
-
-template<class T>
-struct is_const_or_const_ref<T const> : std::true_type {};
-#endif
-
-// std::invoke from C++17
-// https://stackoverflow.com/questions/38288042/c11-14-invoke-workaround
-template<typename Fn,
-         typename... Args,
-#ifdef TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND
-         typename
-         = enable_if_t<!(is_pointer_to_non_const_member_func<Fn>::value && is_const_or_const_ref<Args...>::value)>,
-#endif
-         typename = enable_if_t<std::is_member_pointer<decay_t<Fn>>::value>,
-         int      = 0>
-constexpr auto
-invoke(Fn &&f, Args &&...args) noexcept(noexcept(std::mem_fn(f)(std::forward<Args>(args)...)))
-    -> decltype(std::mem_fn(f)(std::forward<Args>(args)...))
-{
-    return std::mem_fn(f)(std::forward<Args>(args)...);
-}
-
-template<typename Fn, typename... Args, typename = enable_if_t<!std::is_member_pointer<decay_t<Fn>>::value>>
-constexpr auto
-invoke(Fn &&f, Args &&...args) noexcept(noexcept(std::forward<Fn>(f)(std::forward<Args>(args)...)))
-    -> decltype(std::forward<Fn>(f)(std::forward<Args>(args)...))
-{
-    return std::forward<Fn>(f)(std::forward<Args>(args)...);
-}
-
-// std::invoke_result from C++17
-template<class F, class, class... Us>
-struct invoke_result_impl;
-
-template<class F, class... Us>
-struct invoke_result_impl<F, decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...), void()), Us...> {
-    using type = decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...));
-};
-
-template<class F, class... Us>
-using invoke_result = invoke_result_impl<F, void, Us...>;
-
-template<class F, class... Us>
-using invoke_result_t = typename invoke_result<F, Us...>::type;
-
-#if defined(_MSC_VER) && _MSC_VER <= 1900
-// TODO make a version which works with MSVC 2015
-template<class T, class U = T>
-struct is_swappable : std::true_type {};
-
-template<class T, class U = T>
-struct is_nothrow_swappable : std::true_type {};
-#else
-// https://stackoverflow.com/questions/26744589/what-is-a-proper-way-to-implement-is-swappable-to-test-for-the-swappable-concept
-namespace swap_adl_tests {
-// if swap ADL finds this then it would call std::swap otherwise (same
-// signature)
-struct tag {};
-
-template<class T>
-tag swap(T &, T &);
-template<class T, std::size_t N>
-tag swap(T (&a)[N], T (&b)[N]);
-
-// helper functions to test if an unqualified swap is possible, and if it
-// becomes std::swap
-template<class, class>
-std::false_type can_swap(...) noexcept(false);
-template<class T, class U, class = decltype(swap(std::declval<T &>(), std::declval<U &>()))>
-std::true_type can_swap(int) noexcept(noexcept(swap(std::declval<T &>(), std::declval<U &>())));
-
-template<class, class>
-std::false_type uses_std(...);
-template<class T, class U>
-std::is_same<decltype(swap(std::declval<T &>(), std::declval<U &>())), tag> uses_std(int);
-
-template<class T>
-struct is_std_swap_noexcept
-    : std::integral_constant<bool,
-                             std::is_nothrow_move_constructible<T>::value
-                                 && std::is_nothrow_move_assignable<T>::value> {};
-
-template<class T, std::size_t N>
-struct is_std_swap_noexcept<T[N]> : is_std_swap_noexcept<T> {};
-
-template<class T, class U>
-struct is_adl_swap_noexcept : std::integral_constant<bool, noexcept(can_swap<T, U>(0))> {};
-}// namespace swap_adl_tests
-
-template<class T, class U = T>
-struct is_swappable
-    : std::integral_constant<bool,
-                             decltype(detail::swap_adl_tests::can_swap<T, U>(0))::value
-                                 && (!decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value
-                                     || (std::is_move_assignable<T>::value && std::is_move_constructible<T>::value))> {
-};
-
-template<class T, std::size_t N>
-struct is_swappable<T[N], T[N]>
-    : std::integral_constant<bool,
-                             decltype(detail::swap_adl_tests::can_swap<T[N], T[N]>(0))::value
-                                 && (!decltype(detail::swap_adl_tests::uses_std<T[N], T[N]>(0))::value
-                                     || is_swappable<T, T>::value)> {};
-
-template<class T, class U = T>
-struct is_nothrow_swappable
-    : std::integral_constant<bool,
-                             is_swappable<T, U>::value
-                                 && ((decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value
-                                      && detail::swap_adl_tests::is_std_swap_noexcept<T>::value)
-                                     || (!decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value
-                                         && detail::swap_adl_tests::is_adl_swap_noexcept<T, U>::value))> {};
-#endif
-#endif
-
-// Trait for checking if a type is a tl::expected
-template<class T>
-struct is_expected_impl : std::false_type {};
-
-template<class T, class E>
-struct is_expected_impl<expected<T, E>> : std::true_type {};
-template<class T>
-using is_expected = is_expected_impl<decay_t<T>>;
-
-template<class T, class E, class U>
-using expected_enable_forward_value
-    = detail::enable_if_t<std::is_constructible<T, U &&>::value && !std::is_same<detail::decay_t<U>, in_place_t>::value
-                          && !std::is_same<expected<T, E>, detail::decay_t<U>>::value
-                          && !std::is_same<unexpected<E>, detail::decay_t<U>>::value>;
-
-template<class T, class E, class U, class G, class UR, class GR>
-using expected_enable_from_other = detail::enable_if_t<
-    std::is_constructible<T, UR>::value && std::is_constructible<E, GR>::value
-    && !std::is_constructible<T, expected<U, G> &>::value && !std::is_constructible<T, expected<U, G> &&>::value
-    && !std::is_constructible<T, const expected<U, G> &>::value
-    && !std::is_constructible<T, const expected<U, G> &&>::value && !std::is_convertible<expected<U, G> &, T>::value
-    && !std::is_convertible<expected<U, G> &&, T>::value && !std::is_convertible<const expected<U, G> &, T>::value
-    && !std::is_convertible<const expected<U, G> &&, T>::value>;
-
-template<class T, class U>
-using is_void_or = conditional_t<std::is_void<T>::value, std::true_type, U>;
-
-template<class T>
-using is_copy_constructible_or_void = is_void_or<T, std::is_copy_constructible<T>>;
-
-template<class T>
-using is_move_constructible_or_void = is_void_or<T, std::is_move_constructible<T>>;
-
-template<class T>
-using is_copy_assignable_or_void = is_void_or<T, std::is_copy_assignable<T>>;
-
-template<class T>
-using is_move_assignable_or_void = is_void_or<T, std::is_move_assignable<T>>;
-
-}// namespace detail
-
-namespace detail {
-struct no_init_t {};
-
-static constexpr no_init_t no_init{};
-
-// Implements the storage of the values, and ensures that the destructor is
-// trivial if it can be.
+// Compiler versions:
 //
-// This specialization is for where neither `T` or `E` is trivially
-// destructible, so the destructors must be called on destruction of the
-// `expected`
-template<class T,
-         class E,
-         bool = std::is_trivially_destructible<T>::value,
-         bool = std::is_trivially_destructible<E>::value>
-struct expected_storage_base {
-    constexpr expected_storage_base() : m_val(T{}), m_has_val(true) {}
+// MSVC++  6.0  _MSC_VER == 1200  nsel_COMPILER_MSVC_VERSION ==  60  (Visual
+// Studio 6.0) MSVC++  7.0  _MSC_VER == 1300  nsel_COMPILER_MSVC_VERSION ==  70
+// (Visual Studio .NET 2002) MSVC++  7.1  _MSC_VER == 1310
+// nsel_COMPILER_MSVC_VERSION ==  71  (Visual Studio .NET 2003) MSVC++  8.0
+// _MSC_VER == 1400  nsel_COMPILER_MSVC_VERSION ==  80  (Visual Studio 2005)
+// MSVC++  9.0  _MSC_VER == 1500  nsel_COMPILER_MSVC_VERSION ==  90  (Visual
+// Studio 2008) MSVC++ 10.0  _MSC_VER == 1600  nsel_COMPILER_MSVC_VERSION == 100
+// (Visual Studio 2010) MSVC++ 11.0  _MSC_VER == 1700 nsel_COMPILER_MSVC_VERSION
+// == 110  (Visual Studio 2012) MSVC++ 12.0  _MSC_VER == 1800
+// nsel_COMPILER_MSVC_VERSION == 120  (Visual Studio 2013) MSVC++ 14.0  _MSC_VER
+// == 1900  nsel_COMPILER_MSVC_VERSION == 140  (Visual Studio 2015) MSVC++ 14.1
+// _MSC_VER >= 1910  nsel_COMPILER_MSVC_VERSION == 141  (Visual Studio 2017)
+// MSVC++ 14.2  _MSC_VER >= 1920  nsel_COMPILER_MSVC_VERSION == 142  (Visual
+// Studio 2019)
 
-    constexpr expected_storage_base(no_init_t) : m_no_init(), m_has_val(false) {}
-
-    template<class... Args, detail::enable_if_t<std::is_constructible<T, Args &&...>::value> * = nullptr>
-    constexpr expected_storage_base(in_place_t, Args &&...args)
-        : m_val(std::forward<Args>(args)...),
-          m_has_val(true)
-    {}
-
-    template<class U,
-             class... Args,
-             detail::enable_if_t<std::is_constructible<T, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
-    constexpr expected_storage_base(in_place_t, std::initializer_list<U> il, Args &&...args)
-        : m_val(il, std::forward<Args>(args)...),
-          m_has_val(true)
-    {}
-
-    template<class... Args, detail::enable_if_t<std::is_constructible<E, Args &&...>::value> * = nullptr>
-    constexpr explicit expected_storage_base(unexpect_t, Args &&...args)
-        : m_unexpect(std::forward<Args>(args)...),
-          m_has_val(false)
-    {}
-
-    template<class U,
-             class... Args,
-             detail::enable_if_t<std::is_constructible<E, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
-    constexpr explicit expected_storage_base(unexpect_t, std::initializer_list<U> il, Args &&...args)
-        : m_unexpect(il, std::forward<Args>(args)...),
-          m_has_val(false)
-    {}
-
-    ~expected_storage_base()
-    {
-        if (m_has_val) {
-            m_val.~T();
-        } else {
-            m_unexpect.~unexpected<E>();
-        }
-    }
-
-    union {
-        T m_val;
-        unexpected<E> m_unexpect;
-        char m_no_init;
-    };
-
-    bool m_has_val;
-};
-
-// This specialization is for when both `T` and `E` are trivially-destructible,
-// so the destructor of the `expected` can be trivial.
-template<class T, class E>
-struct expected_storage_base<T, E, true, true> {
-    constexpr expected_storage_base() : m_val(T{}), m_has_val(true) {}
-
-    constexpr expected_storage_base(no_init_t) : m_no_init(), m_has_val(false) {}
-
-    template<class... Args, detail::enable_if_t<std::is_constructible<T, Args &&...>::value> * = nullptr>
-    constexpr expected_storage_base(in_place_t, Args &&...args)
-        : m_val(std::forward<Args>(args)...),
-          m_has_val(true)
-    {}
-
-    template<class U,
-             class... Args,
-             detail::enable_if_t<std::is_constructible<T, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
-    constexpr expected_storage_base(in_place_t, std::initializer_list<U> il, Args &&...args)
-        : m_val(il, std::forward<Args>(args)...),
-          m_has_val(true)
-    {}
-
-    template<class... Args, detail::enable_if_t<std::is_constructible<E, Args &&...>::value> * = nullptr>
-    constexpr explicit expected_storage_base(unexpect_t, Args &&...args)
-        : m_unexpect(std::forward<Args>(args)...),
-          m_has_val(false)
-    {}
-
-    template<class U,
-             class... Args,
-             detail::enable_if_t<std::is_constructible<E, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
-    constexpr explicit expected_storage_base(unexpect_t, std::initializer_list<U> il, Args &&...args)
-        : m_unexpect(il, std::forward<Args>(args)...),
-          m_has_val(false)
-    {}
-
-    ~expected_storage_base() = default;
-
-    union {
-        T m_val;
-        unexpected<E> m_unexpect;
-        char m_no_init;
-    };
-
-    bool m_has_val;
-};
-
-// T is trivial, E is not.
-template<class T, class E>
-struct expected_storage_base<T, E, true, false> {
-    constexpr expected_storage_base() : m_val(T{}), m_has_val(true) {}
-
-    TL_EXPECTED_MSVC2015_CONSTEXPR expected_storage_base(no_init_t) : m_no_init(), m_has_val(false) {}
-
-    template<class... Args, detail::enable_if_t<std::is_constructible<T, Args &&...>::value> * = nullptr>
-    constexpr expected_storage_base(in_place_t, Args &&...args)
-        : m_val(std::forward<Args>(args)...),
-          m_has_val(true)
-    {}
-
-    template<class U,
-             class... Args,
-             detail::enable_if_t<std::is_constructible<T, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
-    constexpr expected_storage_base(in_place_t, std::initializer_list<U> il, Args &&...args)
-        : m_val(il, std::forward<Args>(args)...),
-          m_has_val(true)
-    {}
-
-    template<class... Args, detail::enable_if_t<std::is_constructible<E, Args &&...>::value> * = nullptr>
-    constexpr explicit expected_storage_base(unexpect_t, Args &&...args)
-        : m_unexpect(std::forward<Args>(args)...),
-          m_has_val(false)
-    {}
-
-    template<class U,
-             class... Args,
-             detail::enable_if_t<std::is_constructible<E, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
-    constexpr explicit expected_storage_base(unexpect_t, std::initializer_list<U> il, Args &&...args)
-        : m_unexpect(il, std::forward<Args>(args)...),
-          m_has_val(false)
-    {}
-
-    ~expected_storage_base()
-    {
-        if (!m_has_val) { m_unexpect.~unexpected<E>(); }
-    }
-
-    union {
-        T m_val;
-        unexpected<E> m_unexpect;
-        char m_no_init;
-    };
-
-    bool m_has_val;
-};
-
-// E is trivial, T is not.
-template<class T, class E>
-struct expected_storage_base<T, E, false, true> {
-    constexpr expected_storage_base() : m_val(T{}), m_has_val(true) {}
-
-    constexpr expected_storage_base(no_init_t) : m_no_init(), m_has_val(false) {}
-
-    template<class... Args, detail::enable_if_t<std::is_constructible<T, Args &&...>::value> * = nullptr>
-    constexpr expected_storage_base(in_place_t, Args &&...args)
-        : m_val(std::forward<Args>(args)...),
-          m_has_val(true)
-    {}
-
-    template<class U,
-             class... Args,
-             detail::enable_if_t<std::is_constructible<T, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
-    constexpr expected_storage_base(in_place_t, std::initializer_list<U> il, Args &&...args)
-        : m_val(il, std::forward<Args>(args)...),
-          m_has_val(true)
-    {}
-
-    template<class... Args, detail::enable_if_t<std::is_constructible<E, Args &&...>::value> * = nullptr>
-    constexpr explicit expected_storage_base(unexpect_t, Args &&...args)
-        : m_unexpect(std::forward<Args>(args)...),
-          m_has_val(false)
-    {}
-
-    template<class U,
-             class... Args,
-             detail::enable_if_t<std::is_constructible<E, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
-    constexpr explicit expected_storage_base(unexpect_t, std::initializer_list<U> il, Args &&...args)
-        : m_unexpect(il, std::forward<Args>(args)...),
-          m_has_val(false)
-    {}
-
-    ~expected_storage_base()
-    {
-        if (m_has_val) { m_val.~T(); }
-    }
-
-    union {
-        T m_val;
-        unexpected<E> m_unexpect;
-        char m_no_init;
-    };
-
-    bool m_has_val;
-};
-
-// `T` is `void`, `E` is trivially-destructible
-template<class E>
-struct expected_storage_base<void, E, false, true> {
-#if __GNUC__ <= 5
-//no constexpr for GCC 4/5 bug
+#if defined(_MSC_VER) && !defined(__clang__)
+#define nsel_COMPILER_MSVC_VER (_MSC_VER)
+#define nsel_COMPILER_MSVC_VERSION                                             \
+  (_MSC_VER / 10 - 10 * (5 + (_MSC_VER < 1900)))
 #else
-    TL_EXPECTED_MSVC2015_CONSTEXPR
+#define nsel_COMPILER_MSVC_VER 0
+#define nsel_COMPILER_MSVC_VERSION 0
 #endif
-    expected_storage_base() : m_has_val(true) {}
 
-    constexpr expected_storage_base(no_init_t) : m_val(), m_has_val(false) {}
+#define nsel_COMPILER_VERSION(major, minor, patch)                             \
+  (10 * (10 * (major) + (minor)) + (patch))
 
-    constexpr expected_storage_base(in_place_t) : m_has_val(true) {}
+#if defined(__clang__)
+#define nsel_COMPILER_CLANG_VERSION                                            \
+  nsel_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)
+#else
+#define nsel_COMPILER_CLANG_VERSION 0
+#endif
 
-    template<class... Args, detail::enable_if_t<std::is_constructible<E, Args &&...>::value> * = nullptr>
-    constexpr explicit expected_storage_base(unexpect_t, Args &&...args)
-        : m_unexpect(std::forward<Args>(args)...),
-          m_has_val(false)
-    {}
+#if defined(__GNUC__) && !defined(__clang__)
+#define nsel_COMPILER_GNUC_VERSION                                             \
+  nsel_COMPILER_VERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
+#else
+#define nsel_COMPILER_GNUC_VERSION 0
+#endif
 
-    template<class U,
-             class... Args,
-             detail::enable_if_t<std::is_constructible<E, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
-    constexpr explicit expected_storage_base(unexpect_t, std::initializer_list<U> il, Args &&...args)
-        : m_unexpect(il, std::forward<Args>(args)...),
-          m_has_val(false)
-    {}
+// half-open range [lo..hi):
+// #define nsel_BETWEEN( v, lo, hi ) ( (lo) <= (v) && (v) < (hi) )
 
-    ~expected_storage_base() = default;
+// Method enabling
 
-    struct dummy {};
+#define nsel_REQUIRES_0(...)                                                   \
+  template <bool B = (__VA_ARGS__), typename std::enable_if<B, int>::type = 0>
 
-    union {
-        unexpected<E> m_unexpect;
-        dummy m_val;
-    };
+#define nsel_REQUIRES_T(...)                                                   \
+  , typename std::enable_if<(__VA_ARGS__), int>::type = 0
 
-    bool m_has_val;
-};
+#define nsel_REQUIRES_R(R, ...) typename std::enable_if<(__VA_ARGS__), R>::type
 
-// `T` is `void`, `E` is not trivially-destructible
-template<class E>
-struct expected_storage_base<void, E, false, false> {
-    constexpr expected_storage_base() : m_dummy(), m_has_val(true) {}
+#define nsel_REQUIRES_A(...)                                                   \
+  , typename std::enable_if<(__VA_ARGS__), void *>::type = nullptr
 
-    constexpr expected_storage_base(no_init_t) : m_dummy(), m_has_val(false) {}
+// Presence of language and library features:
 
-    constexpr expected_storage_base(in_place_t) : m_dummy(), m_has_val(true) {}
+#ifdef _HAS_CPP0X
+#define nsel_HAS_CPP0X _HAS_CPP0X
+#else
+#define nsel_HAS_CPP0X 0
+#endif
 
-    template<class... Args, detail::enable_if_t<std::is_constructible<E, Args &&...>::value> * = nullptr>
-    constexpr explicit expected_storage_base(unexpect_t, Args &&...args)
-        : m_unexpect(std::forward<Args>(args)...),
-          m_has_val(false)
-    {}
+// #define nsel_CPP11_140  (nsel_CPP11_OR_GREATER || nsel_COMPILER_MSVC_VER >=
+// 1900)
 
-    template<class U,
-             class... Args,
-             detail::enable_if_t<std::is_constructible<E, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
-    constexpr explicit expected_storage_base(unexpect_t, std::initializer_list<U> il, Args &&...args)
-        : m_unexpect(il, std::forward<Args>(args)...),
-          m_has_val(false)
-    {}
+// Clang, GNUC, MSVC warning suppression macros:
 
-    ~expected_storage_base()
-    {
-        if (!m_has_val) { m_unexpect.~unexpected<E>(); }
-    }
+#ifdef __clang__
+#pragma clang diagnostic push
+#elif defined __GNUC__
+#pragma GCC diagnostic push
+#endif // __clang__
 
-    union {
-        unexpected<E> m_unexpect;
-        char m_dummy;
-    };
+#if nsel_COMPILER_MSVC_VERSION >= 140
+#pragma warning(push)
+#define nsel_DISABLE_MSVC_WARNINGS(codes) __pragma(warning(disable : codes))
+#else
+#define nsel_DISABLE_MSVC_WARNINGS(codes)
+#endif
 
-    bool m_has_val;
-};
+#ifdef __clang__
+#define nsel_RESTORE_WARNINGS() _Pragma("clang diagnostic pop")
+#elif defined __GNUC__
+#define nsel_RESTORE_WARNINGS() _Pragma("GCC diagnostic pop")
+#elif nsel_COMPILER_MSVC_VERSION >= 140
+#define nsel_RESTORE_WARNINGS() __pragma(warning(pop))
+#else
+#define nsel_RESTORE_WARNINGS()
+#endif
 
-// This base class provides some handy member functions which can be used in
-// further derived classes
-template<class T, class E>
-struct expected_operations_base : expected_storage_base<T, E> {
-    using expected_storage_base<T, E>::expected_storage_base;
+// Suppress the following MSVC (GSL) warnings:
+// - C26409: Avoid calling new and delete explicitly, use std::make_unique<T>
+// instead (r.11)
 
-    template<class... Args>
-    void construct(Args &&...args) noexcept
-    {
-        new (std::addressof(this->m_val)) T(std::forward<Args>(args)...);
-        this->m_has_val = true;
-    }
+nsel_DISABLE_MSVC_WARNINGS(26409)
 
-    template<class Rhs>
-    void construct_with(Rhs &&rhs) noexcept
-    {
-        new (std::addressof(this->m_val)) T(std::forward<Rhs>(rhs).get());
-        this->m_has_val = true;
-    }
-
-    template<class... Args>
-    void construct_error(Args &&...args) noexcept
-    {
-        new (std::addressof(this->m_unexpect)) unexpected<E>(std::forward<Args>(args)...);
-        this->m_has_val = false;
-    }
-
-#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED
-
-    // These assign overloads ensure that the most efficient assignment
-    // implementation is used while maintaining the strong exception guarantee.
-    // The problematic case is where rhs has a value, but *this does not.
     //
-    // This overload handles the case where we can just copy-construct `T`
-    // directly into place without throwing.
-    template<class U = T, detail::enable_if_t<std::is_nothrow_copy_constructible<U>::value> * = nullptr>
-    void assign(const expected_operations_base &rhs) noexcept
-    {
-        if (!this->m_has_val && rhs.m_has_val) {
-            geterr().~unexpected<E>();
-            construct(rhs.get());
-        } else {
-            assign_common(rhs);
-        }
+    // expected:
+    //
+
+    namespace nonstd {
+  namespace expected_lite {
+
+  // type traits C++17:
+
+  namespace std17 {
+
+#if nsel_CPP17_OR_GREATER
+
+  using std::conjunction;
+  using std::is_nothrow_swappable;
+  using std::is_swappable;
+
+#else // nsel_CPP17_OR_GREATER
+
+  namespace detail {
+
+  using std::swap;
+
+  struct is_swappable {
+    template <typename T, typename = decltype(swap(std::declval<T &>(),
+                                                   std::declval<T &>()))>
+    static std::true_type test(int /* unused */);
+
+    template <typename> static std::false_type test(...);
+  };
+
+  struct is_nothrow_swappable {
+    // wrap noexcept(expr) in separate function as work-around for VC140
+    // (VS2015):
+
+    template <typename T> static constexpr bool satisfies() {
+      return noexcept(swap(std::declval<T &>(), std::declval<T &>()));
     }
 
-    // This overload handles the case where we can attempt to create a copy of
-    // `T`, then no-throw move it into place if the copy was successful.
-    template<class U                                                                = T,
-             detail::enable_if_t<!std::is_nothrow_copy_constructible<U>::value
-                                 && std::is_nothrow_move_constructible<U>::value> * = nullptr>
-    void assign(const expected_operations_base &rhs) noexcept
-    {
-        if (!this->m_has_val && rhs.m_has_val) {
-            T tmp = rhs.get();
-            geterr().~unexpected<E>();
-            construct(std::move(tmp));
-        } else {
-            assign_common(rhs);
-        }
-    }
+    template <typename T>
+    static auto test(int) -> std::integral_constant<bool, satisfies<T>()> {}
 
-    // This overload is the worst-case, where we have to move-construct the
-    // unexpected value into temporary storage, then try to copy the T into place.
-    // If the construction succeeds, then everything is fine, but if it throws,
-    // then we move the old unexpected value back into place before rethrowing the
-    // exception.
-    template<class U                                                                 = T,
-             detail::enable_if_t<!std::is_nothrow_copy_constructible<U>::value
-                                 && !std::is_nothrow_move_constructible<U>::value> * = nullptr>
-    void assign(const expected_operations_base &rhs)
-    {
-        if (!this->m_has_val && rhs.m_has_val) {
-            auto tmp = std::move(geterr());
-            geterr().~unexpected<E>();
+    template <typename> static auto test(...) -> std::false_type;
+  };
+  } // namespace detail
 
-#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED
-            try {
-                construct(rhs.get());
-            } catch (...) {
-                geterr() = std::move(tmp);
-                throw;
-            }
-#else
-            construct(rhs.get());
-#endif
-        } else {
-            assign_common(rhs);
-        }
-    }
+  // is [nothrow] swappable:
 
-    // These overloads do the same as above, but for rvalues
-    template<class U = T, detail::enable_if_t<std::is_nothrow_move_constructible<U>::value> * = nullptr>
-    void assign(expected_operations_base &&rhs) noexcept
-    {
-        if (!this->m_has_val && rhs.m_has_val) {
-            geterr().~unexpected<E>();
-            construct(std::move(rhs).get());
-        } else {
-            assign_common(std::move(rhs));
-        }
-    }
+  template <typename T>
+  struct is_swappable : decltype(detail::is_swappable::test<T>(0)) {};
 
-    template<class U = T, detail::enable_if_t<!std::is_nothrow_move_constructible<U>::value> * = nullptr>
-    void assign(expected_operations_base &&rhs)
-    {
-        if (!this->m_has_val && rhs.m_has_val) {
-            auto tmp = std::move(geterr());
-            geterr().~unexpected<E>();
-#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED
-            try {
-                construct(std::move(rhs).get());
-            } catch (...) {
-                geterr() = std::move(tmp);
-                throw;
-            }
-#else
-            construct(std::move(rhs).get());
-#endif
-        } else {
-            assign_common(std::move(rhs));
-        }
-    }
+  template <typename T>
+  struct is_nothrow_swappable
+      : decltype(detail::is_nothrow_swappable::test<T>(0)) {};
+
+  // conjunction:
+
+  template <typename...> struct conjunction : std::true_type {};
+  template <typename B1> struct conjunction<B1> : B1 {};
+
+  template <typename B1, typename... Bn>
+  struct conjunction<B1, Bn...>
+      : std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
+
+#endif // nsel_CPP17_OR_GREATER
+
+  } // namespace std17
+
+  // type traits C++20:
+
+  namespace std20 {
+
+#if defined(__cpp_lib_remove_cvref)
+
+  using std::remove_cvref;
 
 #else
 
-    // If exceptions are disabled then we can just copy-construct
-    void assign(const expected_operations_base &rhs) noexcept
-    {
-        if (!this->m_has_val && rhs.m_has_val) {
-            geterr().~unexpected<E>();
-            construct(rhs.get());
-        } else {
-            assign_common(rhs);
-        }
-    }
-
-    void assign(expected_operations_base &&rhs) noexcept
-    {
-        if (!this->m_has_val && rhs.m_has_val) {
-            geterr().~unexpected<E>();
-            construct(std::move(rhs).get());
-        } else {
-            assign_common(std::move(rhs));
-        }
-    }
+  template <typename T> struct remove_cvref {
+    typedef
+        typename std::remove_cv<typename std::remove_reference<T>::type>::type
+            type;
+  };
 
 #endif
 
-    // The common part of move/copy assigning
-    template<class Rhs>
-    void assign_common(Rhs &&rhs)
-    {
-        if (this->m_has_val) {
-            if (rhs.m_has_val) {
-                get() = std::forward<Rhs>(rhs).get();
-            } else {
-                destroy_val();
-                construct_error(std::forward<Rhs>(rhs).geterr());
-            }
-        } else {
-            if (!rhs.m_has_val) { geterr() = std::forward<Rhs>(rhs).geterr(); }
-        }
+  } // namespace std20
+
+  // forward declaration:
+
+  template <typename T, typename E> class expected;
+
+  namespace detail {
+
+#if nsel_P2505R >= 3
+  template <typename T> struct is_expected : std::false_type {};
+
+  template <typename T, typename E>
+  struct is_expected<expected<T, E>> : std::true_type {};
+#endif // nsel_P2505R >= 3
+
+  /// discriminated union to hold value or 'error'.
+
+  template <typename T, typename E> class storage_t_noncopy_nonmove_impl {
+    template <typename, typename> friend class nonstd::expected_lite::expected;
+
+  public:
+    using value_type = T;
+    using error_type = E;
+
+    // no-op construction
+    storage_t_noncopy_nonmove_impl() {}
+    ~storage_t_noncopy_nonmove_impl() {}
+
+    explicit storage_t_noncopy_nonmove_impl(bool has_value)
+        : m_has_value(has_value) {}
+
+    void construct_value() { new (&m_value) value_type(); }
+
+    // void construct_value( value_type const & e )
+    // {
+    //     new( &m_value ) value_type( e );
+    // }
+
+    // void construct_value( value_type && e )
+    // {
+    //     new( &m_value ) value_type( std::move( e ) );
+    // }
+
+    template <class... Args> void emplace_value(Args &&...args) {
+      new (&m_value) value_type(std::forward<Args>(args)...);
     }
 
-    bool has_value() const { return this->m_has_val; }
-
-    TL_EXPECTED_11_CONSTEXPR T &get() & { return this->m_val; }
-
-    constexpr const T &get() const & { return this->m_val; }
-
-    TL_EXPECTED_11_CONSTEXPR T &&get() && { return std::move(this->m_val); }
-#ifndef TL_EXPECTED_NO_CONSTRR
-    constexpr const T &&get() const && { return std::move(this->m_val); }
-#endif
-
-    TL_EXPECTED_11_CONSTEXPR unexpected<E> &geterr() & { return this->m_unexpect; }
-
-    constexpr const unexpected<E> &geterr() const & { return this->m_unexpect; }
-
-    TL_EXPECTED_11_CONSTEXPR unexpected<E> &&geterr() && { return std::move(this->m_unexpect); }
-#ifndef TL_EXPECTED_NO_CONSTRR
-    constexpr const unexpected<E> &&geterr() const && { return std::move(this->m_unexpect); }
-#endif
-
-    TL_EXPECTED_11_CONSTEXPR void destroy_val() { get().~T(); }
-};
-
-// This base class provides some handy member functions which can be used in
-// further derived classes
-template<class E>
-struct expected_operations_base<void, E> : expected_storage_base<void, E> {
-    using expected_storage_base<void, E>::expected_storage_base;
-
-    template<class... Args>
-    void construct() noexcept
-    {
-        this->m_has_val = true;
+    template <class U, class... Args>
+    void emplace_value(std::initializer_list<U> il, Args &&...args) {
+      new (&m_value) value_type(il, std::forward<Args>(args)...);
     }
 
-    // This function doesn't use its argument, but needs it so that code in
-    // levels above this can work independently of whether T is void
-    template<class Rhs>
-    void construct_with(Rhs &&) noexcept
-    {
-        this->m_has_val = true;
+    void destruct_value() { m_value.~value_type(); }
+
+    // void construct_error( error_type const & e )
+    // {
+    //     // new( &m_error ) error_type( e );
+    // }
+
+    // void construct_error( error_type && e )
+    // {
+    //     // new( &m_error ) error_type( std::move( e ) );
+    // }
+
+    template <class... Args> void emplace_error(Args &&...args) {
+      new (&m_error) error_type(std::forward<Args>(args)...);
     }
 
-    template<class... Args>
-    void construct_error(Args &&...args) noexcept
-    {
-        new (std::addressof(this->m_unexpect)) unexpected<E>(std::forward<Args>(args)...);
-        this->m_has_val = false;
+    template <class U, class... Args>
+    void emplace_error(std::initializer_list<U> il, Args &&...args) {
+      new (&m_error) error_type(il, std::forward<Args>(args)...);
     }
 
-    template<class Rhs>
-    void assign(Rhs &&rhs) noexcept
-    {
-        if (!this->m_has_val) {
-            if (rhs.m_has_val) {
-                geterr().~unexpected<E>();
-                construct();
-            } else {
-                geterr() = std::forward<Rhs>(rhs).geterr();
-            }
-        } else {
-            if (!rhs.m_has_val) { construct_error(std::forward<Rhs>(rhs).geterr()); }
-        }
+    void destruct_error() { m_error.~error_type(); }
+
+    constexpr value_type const &value() const & { return m_value; }
+
+    value_type &value() & { return m_value; }
+
+    constexpr value_type const &&value() const && { return std::move(m_value); }
+
+    nsel_constexpr14 value_type &&value() && { return std::move(m_value); }
+
+    value_type const *value_ptr() const { return &m_value; }
+
+    value_type *value_ptr() { return &m_value; }
+
+    error_type const &error() const & { return m_error; }
+
+    error_type &error() & { return m_error; }
+
+    constexpr error_type const &&error() const && { return std::move(m_error); }
+
+    nsel_constexpr14 error_type &&error() && { return std::move(m_error); }
+
+    bool has_value() const { return m_has_value; }
+
+    void set_has_value(bool v) { m_has_value = v; }
+
+  private:
+    union {
+      value_type m_value;
+      error_type m_error;
+    };
+
+    bool m_has_value = false;
+  };
+
+  template <typename T, typename E> class storage_t_impl {
+    template <typename, typename> friend class nonstd::expected_lite::expected;
+
+  public:
+    using value_type = T;
+    using error_type = E;
+
+    // no-op construction
+    storage_t_impl() {}
+    ~storage_t_impl() {}
+
+    explicit storage_t_impl(bool has_value) : m_has_value(has_value) {}
+
+    void construct_value() { new (&m_value) value_type(); }
+
+    void construct_value(value_type const &e) { new (&m_value) value_type(e); }
+
+    void construct_value(value_type &&e) {
+      new (&m_value) value_type(std::move(e));
     }
 
-    bool has_value() const { return this->m_has_val; }
-
-    TL_EXPECTED_11_CONSTEXPR unexpected<E> &geterr() & { return this->m_unexpect; }
-
-    constexpr const unexpected<E> &geterr() const & { return this->m_unexpect; }
-
-    TL_EXPECTED_11_CONSTEXPR unexpected<E> &&geterr() && { return std::move(this->m_unexpect); }
-#ifndef TL_EXPECTED_NO_CONSTRR
-    constexpr const unexpected<E> &&geterr() const && { return std::move(this->m_unexpect); }
-#endif
-
-    TL_EXPECTED_11_CONSTEXPR void destroy_val()
-    {
-        // no-op
-    }
-};
-
-// This class manages conditionally having a trivial copy constructor
-// This specialization is for when T and E are trivially copy constructible
-template<class T,
-         class E,
-         bool = is_void_or<T, TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)>::value
-                && TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(E)::value>
-struct expected_copy_base : expected_operations_base<T, E> {
-    using expected_operations_base<T, E>::expected_operations_base;
-};
-
-// This specialization is for when T or E are not trivially copy constructible
-template<class T, class E>
-struct expected_copy_base<T, E, false> : expected_operations_base<T, E> {
-    using expected_operations_base<T, E>::expected_operations_base;
-
-    expected_copy_base() = default;
-
-    expected_copy_base(const expected_copy_base &rhs) : expected_operations_base<T, E>(no_init)
-    {
-        if (rhs.has_value()) {
-            this->construct_with(rhs);
-        } else {
-            this->construct_error(rhs.geterr());
-        }
+    template <class... Args> void emplace_value(Args &&...args) {
+      new (&m_value) value_type(std::forward<Args>(args)...);
     }
 
-    expected_copy_base(expected_copy_base &&rhs)                 = default;
-    expected_copy_base &operator=(const expected_copy_base &rhs) = default;
-    expected_copy_base &operator=(expected_copy_base &&rhs)      = default;
-};
+    template <class U, class... Args>
+    void emplace_value(std::initializer_list<U> il, Args &&...args) {
+      new (&m_value) value_type(il, std::forward<Args>(args)...);
+    }
 
-// This class manages conditionally having a trivial move constructor
-// Unfortunately there's no way to achieve this in GCC < 5 AFAIK, since it
-// doesn't implement an analogue to std::is_trivially_move_constructible. We
-// have to make do with a non-trivial move constructor even if T is trivially
-// move constructible
-#ifndef TL_EXPECTED_GCC49
-template<class T,
-         class E,
-         bool = is_void_or<T, std::is_trivially_move_constructible<T>>::value
-                && std::is_trivially_move_constructible<E>::value>
-struct expected_move_base : expected_copy_base<T, E> {
-    using expected_copy_base<T, E>::expected_copy_base;
-};
+    void destruct_value() { m_value.~value_type(); }
+
+    void construct_error(error_type const &e) { new (&m_error) error_type(e); }
+
+    void construct_error(error_type &&e) {
+      new (&m_error) error_type(std::move(e));
+    }
+
+    template <class... Args> void emplace_error(Args &&...args) {
+      new (&m_error) error_type(std::forward<Args>(args)...);
+    }
+
+    template <class U, class... Args>
+    void emplace_error(std::initializer_list<U> il, Args &&...args) {
+      new (&m_error) error_type(il, std::forward<Args>(args)...);
+    }
+
+    void destruct_error() { m_error.~error_type(); }
+
+    constexpr value_type const &value() const & { return m_value; }
+
+    value_type &value() & { return m_value; }
+
+    constexpr value_type const &&value() const && { return std::move(m_value); }
+
+    nsel_constexpr14 value_type &&value() && { return std::move(m_value); }
+
+    value_type const *value_ptr() const { return &m_value; }
+
+    value_type *value_ptr() { return &m_value; }
+
+    error_type const &error() const & { return m_error; }
+
+    error_type &error() & { return m_error; }
+
+    constexpr error_type const &&error() const && { return std::move(m_error); }
+
+    nsel_constexpr14 error_type &&error() && { return std::move(m_error); }
+
+    bool has_value() const { return m_has_value; }
+
+    void set_has_value(bool v) { m_has_value = v; }
+
+  private:
+    union {
+      value_type m_value;
+      error_type m_error;
+    };
+
+    bool m_has_value = false;
+  };
+
+  /// discriminated union to hold only 'error'.
+
+  template <typename E> struct storage_t_impl<void, E> {
+    template <typename, typename> friend class nonstd::expected_lite::expected;
+
+  public:
+    using value_type = void;
+    using error_type = E;
+
+    // no-op construction
+    storage_t_impl() {}
+    ~storage_t_impl() {}
+
+    explicit storage_t_impl(bool has_value) : m_has_value(has_value) {}
+
+    void construct_error(error_type const &e) { new (&m_error) error_type(e); }
+
+    void construct_error(error_type &&e) {
+      new (&m_error) error_type(std::move(e));
+    }
+
+    template <class... Args> void emplace_error(Args &&...args) {
+      new (&m_error) error_type(std::forward<Args>(args)...);
+    }
+
+    template <class U, class... Args>
+    void emplace_error(std::initializer_list<U> il, Args &&...args) {
+      new (&m_error) error_type(il, std::forward<Args>(args)...);
+    }
+
+    void destruct_error() { m_error.~error_type(); }
+
+    error_type const &error() const & { return m_error; }
+
+    error_type &error() & { return m_error; }
+
+    constexpr error_type const &&error() const && { return std::move(m_error); }
+
+    nsel_constexpr14 error_type &&error() && { return std::move(m_error); }
+
+    bool has_value() const { return m_has_value; }
+
+    void set_has_value(bool v) { m_has_value = v; }
+
+  private:
+    union {
+      char m_dummy;
+      error_type m_error;
+    };
+
+    bool m_has_value = false;
+  };
+
+  template <typename T, typename E, bool isConstructable, bool isMoveable>
+  class storage_t {
+  public:
+  };
+
+  template <typename T, typename E>
+  class storage_t<T, E, false, false>
+      : public storage_t_noncopy_nonmove_impl<T, E> {
+  public:
+    storage_t() = default;
+    ~storage_t() = default;
+
+    explicit storage_t(bool has_value)
+        : storage_t_noncopy_nonmove_impl<T, E>(has_value) {}
+
+    storage_t(storage_t const &other) = delete;
+    storage_t(storage_t &&other) = delete;
+  };
+
+  template <typename T, typename E>
+  class storage_t<T, E, true, true> : public storage_t_impl<T, E> {
+  public:
+    storage_t() = default;
+    ~storage_t() = default;
+
+    explicit storage_t(bool has_value) : storage_t_impl<T, E>(has_value) {}
+
+    storage_t(storage_t const &other)
+        : storage_t_impl<T, E>(other.has_value()) {
+      if (this->has_value())
+        this->construct_value(other.value());
+      else
+        this->construct_error(other.error());
+    }
+
+    storage_t(storage_t &&other) : storage_t_impl<T, E>(other.has_value()) {
+      if (this->has_value())
+        this->construct_value(std::move(other.value()));
+      else
+        this->construct_error(std::move(other.error()));
+    }
+  };
+
+  template <typename E>
+  class storage_t<void, E, true, true> : public storage_t_impl<void, E> {
+  public:
+    storage_t() = default;
+    ~storage_t() = default;
+
+    explicit storage_t(bool has_value) : storage_t_impl<void, E>(has_value) {}
+
+    storage_t(storage_t const &other)
+        : storage_t_impl<void, E>(other.has_value()) {
+      if (this->has_value())
+        ;
+      else
+        this->construct_error(other.error());
+    }
+
+    storage_t(storage_t &&other) : storage_t_impl<void, E>(other.has_value()) {
+      if (this->has_value())
+        ;
+      else
+        this->construct_error(std::move(other.error()));
+    }
+  };
+
+  template <typename T, typename E>
+  class storage_t<T, E, true, false> : public storage_t_impl<T, E> {
+  public:
+    storage_t() = default;
+    ~storage_t() = default;
+
+    explicit storage_t(bool has_value) : storage_t_impl<T, E>(has_value) {}
+
+    storage_t(storage_t const &other)
+        : storage_t_impl<T, E>(other.has_value()) {
+      if (this->has_value())
+        this->construct_value(other.value());
+      else
+        this->construct_error(other.error());
+    }
+
+    storage_t(storage_t &&other) = delete;
+  };
+
+  template <typename E>
+  class storage_t<void, E, true, false> : public storage_t_impl<void, E> {
+  public:
+    storage_t() = default;
+    ~storage_t() = default;
+
+    explicit storage_t(bool has_value) : storage_t_impl<void, E>(has_value) {}
+
+    storage_t(storage_t const &other)
+        : storage_t_impl<void, E>(other.has_value()) {
+      if (this->has_value())
+        ;
+      else
+        this->construct_error(other.error());
+    }
+
+    storage_t(storage_t &&other) = delete;
+  };
+
+  template <typename T, typename E>
+  class storage_t<T, E, false, true> : public storage_t_impl<T, E> {
+  public:
+    storage_t() = default;
+    ~storage_t() = default;
+
+    explicit storage_t(bool has_value) : storage_t_impl<T, E>(has_value) {}
+
+    storage_t(storage_t const &other) = delete;
+
+    storage_t(storage_t &&other) : storage_t_impl<T, E>(other.has_value()) {
+      if (this->has_value())
+        this->construct_value(std::move(other.value()));
+      else
+        this->construct_error(std::move(other.error()));
+    }
+  };
+
+  template <typename E>
+  class storage_t<void, E, false, true> : public storage_t_impl<void, E> {
+  public:
+    storage_t() = default;
+    ~storage_t() = default;
+
+    explicit storage_t(bool has_value) : storage_t_impl<void, E>(has_value) {}
+
+    storage_t(storage_t const &other) = delete;
+
+    storage_t(storage_t &&other) : storage_t_impl<void, E>(other.has_value()) {
+      if (this->has_value())
+        ;
+      else
+        this->construct_error(std::move(other.error()));
+    }
+  };
+
+#if nsel_P2505R >= 3
+  // C++11 invoke implementation
+  template <typename> struct is_reference_wrapper : std::false_type {};
+  template <typename T>
+  struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};
+
+  template <
+      typename FnT, typename ClassT, typename ObjectT,
+      typename... Args nsel_REQUIRES_T(
+          std::is_function<FnT>::value &&
+          (std::is_same<ClassT,
+                        typename std20::remove_cvref<ObjectT>::type>::value ||
+           std::is_base_of<
+               ClassT, typename std20::remove_cvref<ObjectT>::type>::value))>
+  nsel_constexpr auto invoke_member_function_impl(
+      FnT ClassT::*memfnptr, ObjectT &&obj,
+      Args &&...args) noexcept(noexcept((std::forward<ObjectT>(obj).*
+                                         memfnptr)(std::forward<Args>(
+      args)...))) -> decltype((std::forward<ObjectT>(obj).*
+                               memfnptr)(std::forward<Args>(args)...)) {
+    return (std::forward<ObjectT>(obj).*memfnptr)(std::forward<Args>(args)...);
+  }
+
+  template <typename FnT, typename ClassT, typename ObjectT,
+            typename... Args nsel_REQUIRES_T(
+                std::is_function<FnT>::value &&is_reference_wrapper<
+                    typename std20::remove_cvref<ObjectT>::type>::value)>
+  nsel_constexpr auto
+  invoke_member_function_impl(FnT ClassT::*memfnptr, ObjectT &&obj,
+                              Args &&...args) noexcept(noexcept((obj.get().*
+                                                                 memfnptr)(
+      std::forward<Args>(args)...)))
+      -> decltype((obj.get().*memfnptr)(std::forward<Args>(args)...)) {
+    return (obj.get().*memfnptr)(std::forward<Args>(args)...);
+  }
+
+  template <
+      typename FnT, typename ClassT, typename ObjectT,
+      typename... Args nsel_REQUIRES_T(
+          std::is_function<FnT>::value &&
+          !std::is_same<ClassT,
+                        typename std20::remove_cvref<ObjectT>::type>::value &&
+          !std::is_base_of<
+              ClassT, typename std20::remove_cvref<ObjectT>::type>::value &&
+          !is_reference_wrapper<
+              typename std20::remove_cvref<ObjectT>::type>::value)>
+  nsel_constexpr auto invoke_member_function_impl(
+      FnT ClassT::*memfnptr, ObjectT &&obj,
+      Args &&...args) noexcept(noexcept(((*std::forward<ObjectT>(obj)).*
+                                         memfnptr)(std::forward<Args>(
+      args)...))) -> decltype(((*std::forward<ObjectT>(obj)).*
+                               memfnptr)(std::forward<Args>(args)...)) {
+    return ((*std::forward<ObjectT>(obj)).*
+            memfnptr)(std::forward<Args>(args)...);
+  }
+
+  template <
+      typename MemberT, typename ClassT,
+      typename ObjectT nsel_REQUIRES_T(
+          std::is_same<ClassT,
+                       typename std20::remove_cvref<ObjectT>::type>::value ||
+          std::is_base_of<ClassT,
+                          typename std20::remove_cvref<ObjectT>::type>::value)>
+  nsel_constexpr auto
+  invoke_member_object_impl(MemberT ClassT::*memobjptr, ObjectT &&obj) noexcept(
+      noexcept(std::forward<ObjectT>(obj).*
+               memobjptr)) -> decltype(std::forward<ObjectT>(obj).*memobjptr) {
+    return std::forward<ObjectT>(obj).*memobjptr;
+  }
+
+  template <typename MemberT, typename ClassT,
+            typename ObjectT nsel_REQUIRES_T(
+                is_reference_wrapper<
+                    typename std20::remove_cvref<ObjectT>::type>::value)>
+  nsel_constexpr auto
+  invoke_member_object_impl(MemberT ClassT::*memobjptr, ObjectT &&obj) noexcept(
+      noexcept(obj.get().*memobjptr)) -> decltype(obj.get().*memobjptr) {
+    return obj.get().*memobjptr;
+  }
+
+  template <
+      typename MemberT, typename ClassT,
+      typename ObjectT nsel_REQUIRES_T(
+          !std::is_same<ClassT,
+                        typename std20::remove_cvref<ObjectT>::type>::value &&
+          !std::is_base_of<
+              ClassT, typename std20::remove_cvref<ObjectT>::type>::value &&
+          !is_reference_wrapper<
+              typename std20::remove_cvref<ObjectT>::type>::value)>
+  nsel_constexpr auto
+  invoke_member_object_impl(MemberT ClassT::*memobjptr, ObjectT &&obj) noexcept(
+      noexcept((*std::forward<ObjectT>(obj)).*memobjptr))
+      -> decltype((*std::forward<ObjectT>(obj)).*memobjptr) {
+    return (*std::forward<ObjectT>(obj)).*memobjptr;
+  }
+
+  template <typename F, typename... Args nsel_REQUIRES_T(
+                            std::is_member_function_pointer<
+                                typename std20::remove_cvref<F>::type>::value)>
+  nsel_constexpr auto invoke(F &&f, Args &&...args) noexcept(
+      noexcept(invoke_member_function_impl(std::forward<F>(f),
+                                           std::forward<Args>(args)...)))
+      -> decltype(invoke_member_function_impl(std::forward<F>(f),
+                                              std::forward<Args>(args)...)) {
+    return invoke_member_function_impl(std::forward<F>(f),
+                                       std::forward<Args>(args)...);
+  }
+
+  template <typename F, typename... Args nsel_REQUIRES_T(
+                            std::is_member_object_pointer<
+                                typename std20::remove_cvref<F>::type>::value)>
+  nsel_constexpr auto invoke(F &&f, Args &&...args) noexcept(
+      noexcept(invoke_member_object_impl(std::forward<F>(f),
+                                         std::forward<Args>(args)...)))
+      -> decltype(invoke_member_object_impl(std::forward<F>(f),
+                                            std::forward<Args>(args)...)) {
+    return invoke_member_object_impl(std::forward<F>(f),
+                                     std::forward<Args>(args)...);
+  }
+
+  template <typename F, typename... Args nsel_REQUIRES_T(
+                            !std::is_member_function_pointer<
+                                typename std20::remove_cvref<F>::type>::value &&
+                            !std::is_member_object_pointer<
+                                typename std20::remove_cvref<F>::type>::value)>
+  nsel_constexpr auto invoke(F &&f, Args &&...args) noexcept(
+      noexcept(std::forward<F>(f)(std::forward<Args>(args)...)))
+      -> decltype(std::forward<F>(f)(std::forward<Args>(args)...)) {
+    return std::forward<F>(f)(std::forward<Args>(args)...);
+  }
+
+  template <typename F, typename... Args>
+  using invoke_result_nocvref_t = typename std20::remove_cvref<decltype(invoke(
+      std::declval<F>(), std::declval<Args>()...))>::type;
+
+#if nsel_P2505R >= 5
+  template <typename F, typename... Args>
+  using transform_invoke_result_t = typename std::remove_cv<decltype(invoke(
+      std::declval<F>(), std::declval<Args>()...))>::type;
 #else
-template<class T, class E, bool = false>
-struct expected_move_base;
-#endif
-template<class T, class E>
-struct expected_move_base<T, E, false> : expected_copy_base<T, E> {
-    using expected_copy_base<T, E>::expected_copy_base;
+  template <typename F, typename... Args>
+  using transform_invoke_result_t = invoke_result_nocvref_t
+#endif // nsel_P2505R >= 5
 
-    expected_move_base()                              = default;
-    expected_move_base(const expected_move_base &rhs) = default;
+  template <typename T>
+  struct valid_expected_value_type
+      : std::integral_constant<bool, std::is_destructible<T>::value &&
+                                         !std::is_reference<T>::value &&
+                                         !std::is_array<T>::value> {};
 
-    expected_move_base(expected_move_base &&rhs) noexcept(std::is_nothrow_move_constructible<T>::value)
-        : expected_copy_base<T, E>(no_init)
-    {
-        if (rhs.has_value()) {
-            this->construct_with(std::move(rhs));
-        } else {
-            this->construct_error(std::move(rhs.geterr()));
-        }
-    }
+#endif // nsel_P2505R >= 3
+  } // namespace detail
 
-    expected_move_base &operator=(const expected_move_base &rhs) = default;
-    expected_move_base &operator=(expected_move_base &&rhs)      = default;
-};
+  /// x.x.5 Unexpected object type; unexpected_type; C++17 and later can also
+  /// use aliased type unexpected.
 
-// This class manages conditionally having a trivial copy assignment operator
-template<class T,
-         class E,
-         bool
-         = is_void_or<T,
-                      conjunction<TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T),
-                                  TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T),
-                                  TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T)>>::value
-           && TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(E)::value
-           && TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(E)::value && TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(E)::value>
-struct expected_copy_assign_base : expected_move_base<T, E> {
-    using expected_move_base<T, E>::expected_move_base;
-};
-
-template<class T, class E>
-struct expected_copy_assign_base<T, E, false> : expected_move_base<T, E> {
-    using expected_move_base<T, E>::expected_move_base;
-
-    expected_copy_assign_base()                                     = default;
-    expected_copy_assign_base(const expected_copy_assign_base &rhs) = default;
-
-    expected_copy_assign_base(expected_copy_assign_base &&rhs) = default;
-
-    expected_copy_assign_base &operator=(const expected_copy_assign_base &rhs)
-    {
-        this->assign(rhs);
-        return *this;
-    }
-
-    expected_copy_assign_base &operator=(expected_copy_assign_base &&rhs) = default;
-};
-
-// This class manages conditionally having a trivial move assignment operator
-// Unfortunately there's no way to achieve this in GCC < 5 AFAIK, since it
-// doesn't implement an analogue to std::is_trivially_move_assignable. We have
-// to make do with a non-trivial move assignment operator even if T is trivially
-// move assignable
-#ifndef TL_EXPECTED_GCC49
-template<class T,
-         class E,
-         bool = is_void_or<T,
-                           conjunction<std::is_trivially_destructible<T>,
-                                       std::is_trivially_move_constructible<T>,
-                                       std::is_trivially_move_assignable<T>>>::value
-                && std::is_trivially_destructible<E>::value && std::is_trivially_move_constructible<E>::value
-                && std::is_trivially_move_assignable<E>::value>
-struct expected_move_assign_base : expected_copy_assign_base<T, E> {
-    using expected_copy_assign_base<T, E>::expected_copy_assign_base;
-};
+#if nsel_P0323R <= 2
+  template <typename E = std::exception_ptr>
+  class unexpected_type
 #else
-template<class T, class E, bool = false>
-struct expected_move_assign_base;
+  template <typename E>
+  class unexpected_type
+#endif // nsel_P0323R
+  {
+  public:
+    using error_type = E;
+
+    // x.x.5.2.1 Constructors
+
+    //  unexpected_type() = delete;
+
+    constexpr unexpected_type(unexpected_type const &) = default;
+    constexpr unexpected_type(unexpected_type &&) = default;
+
+    template <typename... Args nsel_REQUIRES_T(
+        std::is_constructible<E, Args &&...>::value)>
+    constexpr explicit unexpected_type(nonstd_lite_in_place_t(E),
+                                       Args &&...args)
+        : m_error(std::forward<Args>(args)...) {}
+
+    template <typename U, typename... Args nsel_REQUIRES_T(
+                              std::is_constructible<E, std::initializer_list<U>,
+                                                    Args &&...>::value)>
+    constexpr explicit unexpected_type(nonstd_lite_in_place_t(E),
+                                       std::initializer_list<U> il,
+                                       Args &&...args)
+        : m_error(il, std::forward<Args>(args)...) {}
+
+    template <typename E2 nsel_REQUIRES_T(
+        std::is_constructible<E, E2>::value &&
+        !std::is_same<typename std20::remove_cvref<E2>::type,
+                      nonstd_lite_in_place_t(E2)>::value &&
+        !std::is_same<typename std20::remove_cvref<E2>::type,
+                      unexpected_type>::value)>
+    constexpr explicit unexpected_type(E2 &&error)
+        : m_error(std::forward<E2>(error)) {}
+
+    template <typename E2 nsel_REQUIRES_T(
+        std::is_constructible<E, E2>::value &&
+        !std::is_constructible<E, unexpected_type<E2> &>::value &&
+        !std::is_constructible<E, unexpected_type<E2>>::value &&
+        !std::is_constructible<E, unexpected_type<E2> const &>::value &&
+        !std::is_constructible<E, unexpected_type<E2> const>::value &&
+        !std::is_convertible<unexpected_type<E2> &, E>::value &&
+        !std::is_convertible<unexpected_type<E2>, E>::value &&
+        !std::is_convertible<unexpected_type<E2> const &, E>::value &&
+        !std::is_convertible<unexpected_type<E2> const, E>::value &&
+        !std::is_convertible<E2 const &, E>::value /*=> explicit */
+        )>
+    constexpr explicit unexpected_type(unexpected_type<E2> const &error)
+        : m_error(E{error.value()}) {}
+
+    template <typename E2 nsel_REQUIRES_T(
+        std::is_constructible<E, E2>::value &&
+        !std::is_constructible<E, unexpected_type<E2> &>::value &&
+        !std::is_constructible<E, unexpected_type<E2>>::value &&
+        !std::is_constructible<E, unexpected_type<E2> const &>::value &&
+        !std::is_constructible<E, unexpected_type<E2> const>::value &&
+        !std::is_convertible<unexpected_type<E2> &, E>::value &&
+        !std::is_convertible<unexpected_type<E2>, E>::value &&
+        !std::is_convertible<unexpected_type<E2> const &, E>::value &&
+        !std::is_convertible<unexpected_type<E2> const, E>::value &&
+        std::is_convertible<E2 const &, E>::value /*=> explicit */
+        )>
+    constexpr /*non-explicit*/ unexpected_type(unexpected_type<E2> const &error)
+        : m_error(error.value()) {}
+
+    template <typename E2 nsel_REQUIRES_T(
+        std::is_constructible<E, E2>::value &&
+        !std::is_constructible<E, unexpected_type<E2> &>::value &&
+        !std::is_constructible<E, unexpected_type<E2>>::value &&
+        !std::is_constructible<E, unexpected_type<E2> const &>::value &&
+        !std::is_constructible<E, unexpected_type<E2> const>::value &&
+        !std::is_convertible<unexpected_type<E2> &, E>::value &&
+        !std::is_convertible<unexpected_type<E2>, E>::value &&
+        !std::is_convertible<unexpected_type<E2> const &, E>::value &&
+        !std::is_convertible<unexpected_type<E2> const, E>::value &&
+        !std::is_convertible<E2 const &, E>::value /*=> explicit */
+        )>
+    constexpr explicit unexpected_type(unexpected_type<E2> &&error)
+        : m_error(E{std::move(error.value())}) {}
+
+    template <typename E2 nsel_REQUIRES_T(
+        std::is_constructible<E, E2>::value &&
+        !std::is_constructible<E, unexpected_type<E2> &>::value &&
+        !std::is_constructible<E, unexpected_type<E2>>::value &&
+        !std::is_constructible<E, unexpected_type<E2> const &>::value &&
+        !std::is_constructible<E, unexpected_type<E2> const>::value &&
+        !std::is_convertible<unexpected_type<E2> &, E>::value &&
+        !std::is_convertible<unexpected_type<E2>, E>::value &&
+        !std::is_convertible<unexpected_type<E2> const &, E>::value &&
+        !std::is_convertible<unexpected_type<E2> const, E>::value &&
+        std::is_convertible<E2 const &, E>::value /*=> non-explicit */
+        )>
+    constexpr /*non-explicit*/ unexpected_type(unexpected_type<E2> &&error)
+        : m_error(std::move(error.value())) {}
+
+    // x.x.5.2.2 Assignment
+
+    nsel_constexpr14 unexpected_type &
+    operator=(unexpected_type const &) = default;
+    nsel_constexpr14 unexpected_type &operator=(unexpected_type &&) = default;
+
+    template <typename E2 = E>
+    nsel_constexpr14 unexpected_type &
+    operator=(unexpected_type<E2> const &other) {
+      unexpected_type{other.value()}.swap(*this);
+      return *this;
+    }
+
+    template <typename E2 = E>
+    nsel_constexpr14 unexpected_type &operator=(unexpected_type<E2> &&other) {
+      unexpected_type{std::move(other.value())}.swap(*this);
+      return *this;
+    }
+
+    // x.x.5.2.3 Observers
+
+    nsel_constexpr14 E &value() & noexcept { return m_error; }
+
+    constexpr E const &value() const & noexcept { return m_error; }
+
+#if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
+
+    nsel_constexpr14 E &&value() && noexcept { return std::move(m_error); }
+
+    constexpr E const &&value() const && noexcept { return std::move(m_error); }
+
 #endif
 
-template<class T, class E>
-struct expected_move_assign_base<T, E, false> : expected_copy_assign_base<T, E> {
-    using expected_copy_assign_base<T, E>::expected_copy_assign_base;
+    // x.x.5.2.4 Swap
 
-    expected_move_assign_base()                                     = default;
-    expected_move_assign_base(const expected_move_assign_base &rhs) = default;
-
-    expected_move_assign_base(expected_move_assign_base &&rhs) = default;
-
-    expected_move_assign_base &operator=(const expected_move_assign_base &rhs) = default;
-
-    expected_move_assign_base &operator=(expected_move_assign_base &&rhs) noexcept(
-        std::is_nothrow_move_constructible<T>::value && std::is_nothrow_move_assignable<T>::value)
-    {
-        this->assign(std::move(rhs));
-        return *this;
+    template <typename U = E>
+    nsel_REQUIRES_R(void, std17::is_swappable<U>::value)
+        swap(unexpected_type &other) noexcept(
+            std17::is_nothrow_swappable<U>::value) {
+      using std::swap;
+      swap(m_error, other.m_error);
     }
+
+    // TODO: ??? unexpected_type: in-class friend operator==, !=
+
+  private:
+    error_type m_error;
+  };
+
+#if nsel_CPP17_OR_GREATER
+
+  /// template deduction guide:
+
+  template <typename E> unexpected_type(E) -> unexpected_type<E>;
+
+#endif
+
+  /// class unexpected_type, std::exception_ptr specialization (P0323R2)
+
+#if !nsel_CONFIG_NO_EXCEPTIONS
+#if nsel_P0323R <= 2
+
+  // TODO: Should expected be specialized for particular E types such as
+  // exception_ptr and how?
+  //       See p0323r7 2.1. Ergonomics, http://wg21.link/p0323
+  template <> class unexpected_type<std::exception_ptr> {
+  public:
+    using error_type = std::exception_ptr;
+
+    unexpected_type() = delete;
+
+    ~unexpected_type() {}
+
+    explicit unexpected_type(std::exception_ptr const &error)
+        : m_error(error) {}
+
+    explicit unexpected_type(std::exception_ptr &&error)
+        : m_error(std::move(error)) {}
+
+    template <typename E>
+    explicit unexpected_type(E error)
+        : m_error(std::make_exception_ptr(error)) {}
+
+    std::exception_ptr const &value() const { return m_error; }
+
+    std::exception_ptr &value() { return m_error; }
+
+  private:
+    std::exception_ptr m_error;
+  };
+
+#endif // nsel_P0323R
+#endif // !nsel_CONFIG_NO_EXCEPTIONS
+
+  /// x.x.4, Unexpected equality operators
+
+  template <typename E1, typename E2>
+  constexpr bool operator==(unexpected_type<E1> const &x,
+                            unexpected_type<E2> const &y) {
+    return x.value() == y.value();
+  }
+
+  template <typename E1, typename E2>
+  constexpr bool operator!=(unexpected_type<E1> const &x,
+                            unexpected_type<E2> const &y) {
+    return !(x == y);
+  }
+
+#if nsel_P0323R <= 2
+
+  template <typename E>
+  constexpr bool operator<(unexpected_type<E> const &x,
+                           unexpected_type<E> const &y) {
+    return x.value() < y.value();
+  }
+
+  template <typename E>
+  constexpr bool operator>(unexpected_type<E> const &x,
+                           unexpected_type<E> const &y) {
+    return (y < x);
+  }
+
+  template <typename E>
+  constexpr bool operator<=(unexpected_type<E> const &x,
+                            unexpected_type<E> const &y) {
+    return !(y < x);
+  }
+
+  template <typename E>
+  constexpr bool operator>=(unexpected_type<E> const &x,
+                            unexpected_type<E> const &y) {
+    return !(x < y);
+  }
+
+#endif // nsel_P0323R
+
+  /// x.x.5 Specialized algorithms
+
+  template <typename E nsel_REQUIRES_T(std17::is_swappable<E>::value)>
+  void swap(unexpected_type<E> &x,
+            unexpected_type<E> &y) noexcept(noexcept(x.swap(y))) {
+    x.swap(y);
+  }
+
+#if nsel_P0323R <= 2
+
+  // unexpected: relational operators for std::exception_ptr:
+
+  inline constexpr bool
+  operator<(unexpected_type<std::exception_ptr> const & /*x*/,
+            unexpected_type<std::exception_ptr> const & /*y*/) {
+    return false;
+  }
+
+  inline constexpr bool
+  operator>(unexpected_type<std::exception_ptr> const & /*x*/,
+            unexpected_type<std::exception_ptr> const & /*y*/) {
+    return false;
+  }
+
+  inline constexpr bool
+  operator<=(unexpected_type<std::exception_ptr> const &x,
+             unexpected_type<std::exception_ptr> const &y) {
+    return (x == y);
+  }
+
+  inline constexpr bool
+  operator>=(unexpected_type<std::exception_ptr> const &x,
+             unexpected_type<std::exception_ptr> const &y) {
+    return (x == y);
+  }
+
+#endif // nsel_P0323R
+
+  // unexpected: traits
+
+#if nsel_P0323R <= 3
+
+  template <typename E> struct is_unexpected : std::false_type {};
+
+  template <typename E>
+  struct is_unexpected<unexpected_type<E>> : std::true_type {};
+
+#endif // nsel_P0323R
+
+  // unexpected: factory
+
+  // keep make_unexpected() removed in p0323r2 for pre-C++17:
+
+  template <typename E>
+  nsel_constexpr14 auto
+  make_unexpected(E &&value) -> unexpected_type<typename std::decay<E>::type> {
+    return unexpected_type<typename std::decay<E>::type>(
+        std::forward<E>(value));
+  }
+
+#if nsel_P0323R <= 3
+
+  /*nsel_constexpr14*/ auto inline make_unexpected_from_current_exception()
+      -> unexpected_type<std::exception_ptr> {
+    return unexpected_type<std::exception_ptr>(std::current_exception());
+  }
+
+#endif // nsel_P0323R
+
+  /// x.x.6, x.x.7 expected access error
+
+  template <typename E> class bad_expected_access;
+
+  /// x.x.7 bad_expected_access<void>: expected access error
+
+  template <> class bad_expected_access<void> : public std::exception {
+  public:
+    explicit bad_expected_access() : std::exception() {}
+  };
+
+  /// x.x.6 bad_expected_access: expected access error
+
+#if !nsel_CONFIG_NO_EXCEPTIONS
+
+  template <typename E>
+  class bad_expected_access : public bad_expected_access<void> {
+  public:
+    using error_type = E;
+
+    explicit bad_expected_access(error_type error) : m_error(error) {}
+
+    virtual char const *what() const noexcept override {
+      return "bad_expected_access";
+    }
+
+    nsel_constexpr14 error_type &error() & { return m_error; }
+
+    constexpr error_type const &error() const & { return m_error; }
+
+#if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
+
+    nsel_constexpr14 error_type &&error() && { return std::move(m_error); }
+
+    constexpr error_type const &&error() const && { return std::move(m_error); }
+
+#endif
+
+  private:
+    error_type m_error;
+  };
+
+#endif // nsel_CONFIG_NO_EXCEPTIONS
+
+  /// x.x.8 unexpect tag, in_place_unexpected tag: construct an error
+
+  struct unexpect_t {};
+  using in_place_unexpected_t = unexpect_t;
+
+  nsel_inline17 constexpr unexpect_t unexpect{};
+  nsel_inline17 constexpr unexpect_t in_place_unexpected{};
+
+  /// class error_traits
+
+#if nsel_CONFIG_NO_EXCEPTIONS
+
+  namespace detail {
+  inline bool text(char const * /*text*/) { return true; }
+  } // namespace detail
+
+  template <typename Error> struct error_traits {
+    static void rethrow(Error const & /*e*/) {
+#if nsel_CONFIG_NO_EXCEPTIONS_SEH
+      RaiseException(EXCEPTION_ACCESS_VIOLATION, EXCEPTION_NONCONTINUABLE, 0,
+                     NULL);
+#else
+      assert(false && detail::text("throw bad_expected_access<Error>{ e };"));
+#endif
+    }
+  };
+
+  template <> struct error_traits<std::exception_ptr> {
+    static void rethrow(std::exception_ptr const & /*e*/) {
+#if nsel_CONFIG_NO_EXCEPTIONS_SEH
+      RaiseException(EXCEPTION_ACCESS_VIOLATION, EXCEPTION_NONCONTINUABLE, 0,
+                     NULL);
+#else
+      assert(
+          false &&
+          detail::text("throw bad_expected_access<std::exception_ptr>{ e };"));
+#endif
+    }
+  };
+
+  template <> struct error_traits<std::error_code> {
+    static void rethrow(std::error_code const & /*e*/) {
+#if nsel_CONFIG_NO_EXCEPTIONS_SEH
+      RaiseException(EXCEPTION_ACCESS_VIOLATION, EXCEPTION_NONCONTINUABLE, 0,
+                     NULL);
+#else
+      assert(false && detail::text("throw std::system_error( e );"));
+#endif
+    }
+  };
+
+#else // nsel_CONFIG_NO_EXCEPTIONS
+
+  template <typename Error> struct error_traits {
+    static void rethrow(Error const &e) { throw bad_expected_access<Error>{e}; }
+  };
+
+  template <> struct error_traits<std::exception_ptr> {
+    static void rethrow(std::exception_ptr const &e) {
+      std::rethrow_exception(e);
+    }
+  };
+
+  template <> struct error_traits<std::error_code> {
+    static void rethrow(std::error_code const &e) {
+      throw std::system_error(e);
+    }
+  };
+
+#endif // nsel_CONFIG_NO_EXCEPTIONS
+
+#if nsel_P2505R >= 3
+  namespace detail {
+
+  // from https://en.cppreference.com/w/cpp/utility/expected/unexpected:
+  // "the type of the unexpected value. The type must not be an array type, a
+  // non-object type, a specialization of std::unexpected, or a cv-qualified
+  // type."
+  template <typename T>
+  struct valid_unexpected_type
+      : std::integral_constant<
+            bool,
+            std::is_same<T, typename std20::remove_cvref<T>::type>::value &&
+                std::is_object<T>::value && !std::is_array<T>::value> {};
+
+  template <typename T>
+  struct valid_unexpected_type<unexpected_type<T>> : std::false_type {};
+
+  } // namespace detail
+#endif // nsel_P2505R >= 3
+
+  } // namespace expected_lite
+
+  // provide nonstd::unexpected_type:
+
+  using expected_lite::unexpected_type;
+
+  namespace expected_lite {
+
+  /// class expected
+
+#if nsel_P0323R <= 2
+  template <typename T, typename E = std::exception_ptr>
+  class expected
+#else
+  template <typename T, typename E>
+  class expected
+#endif // nsel_P0323R
+  {
+  private:
+    template <typename, typename> friend class expected;
+
+  public:
+    using value_type = T;
+    using error_type = E;
+    using unexpected_type = nonstd::unexpected_type<E>;
+
+    template <typename U> struct rebind {
+      using type = expected<U, error_type>;
+    };
+
+    // x.x.4.1 constructors
+
+    nsel_REQUIRES_0(std::is_default_constructible<T>::value) nsel_constexpr14
+        expected()
+        : contained(true) {
+      contained.construct_value();
+    }
+
+    nsel_constexpr14 expected(expected const &) = default;
+    nsel_constexpr14 expected(expected &&) = default;
+
+    template <typename U,
+              typename G nsel_REQUIRES_T(
+                  std::is_constructible<T, U const &>::value
+                      &&std::is_constructible<E, G const &>::value &&
+                  !std::is_constructible<T, expected<U, G> &>::value &&
+                  !std::is_constructible<T, expected<U, G> &&>::value &&
+                  !std::is_constructible<T, expected<U, G> const &>::value &&
+                  !std::is_constructible<T, expected<U, G> const &&>::value &&
+                  !std::is_convertible<expected<U, G> &, T>::value &&
+                  !std::is_convertible<expected<U, G> &&, T>::value &&
+                  !std::is_convertible<expected<U, G> const &, T>::value &&
+                  !std::is_convertible<expected<U, G> const &&, T>::value &&
+                  (!std::is_convertible<U const &, T>::value ||
+                   !std::is_convertible<G const &, E>::value) /*=> explicit */
+                  )>
+    nsel_constexpr14 explicit expected(expected<U, G> const &other)
+        : contained(other.has_value()) {
+      if (has_value())
+        contained.construct_value(T{other.contained.value()});
+      else
+        contained.construct_error(E{other.contained.error()});
+    }
+
+    template <typename U,
+              typename G nsel_REQUIRES_T(
+                  std::is_constructible<T, U const &>::value
+                      &&std::is_constructible<E, G const &>::value &&
+                  !std::is_constructible<T, expected<U, G> &>::value &&
+                  !std::is_constructible<T, expected<U, G> &&>::value &&
+                  !std::is_constructible<T, expected<U, G> const &>::value &&
+                  !std::is_constructible<T, expected<U, G> const &&>::value &&
+                  !std::is_convertible<expected<U, G> &, T>::value &&
+                  !std::is_convertible<expected<U, G> &&, T>::value &&
+                  !std::is_convertible<expected<U, G> const &, T>::value &&
+                  !std::is_convertible<expected<U, G> const &&, T>::value &&
+                  !(!std::is_convertible<U const &, T>::value ||
+                    !std::is_convertible<G const &, E>::value) /*=> non-explicit
+                                                                */
+                  )>
+    nsel_constexpr14 /*non-explicit*/ expected(expected<U, G> const &other)
+        : contained(other.has_value()) {
+      if (has_value())
+        contained.construct_value(other.contained.value());
+      else
+        contained.construct_error(other.contained.error());
+    }
+
+    template <typename U,
+              typename G nsel_REQUIRES_T(
+                  std::is_constructible<T, U>::value
+                      &&std::is_constructible<E, G>::value &&
+                  !std::is_constructible<T, expected<U, G> &>::value &&
+                  !std::is_constructible<T, expected<U, G> &&>::value &&
+                  !std::is_constructible<T, expected<U, G> const &>::value &&
+                  !std::is_constructible<T, expected<U, G> const &&>::value &&
+                  !std::is_convertible<expected<U, G> &, T>::value &&
+                  !std::is_convertible<expected<U, G> &&, T>::value &&
+                  !std::is_convertible<expected<U, G> const &, T>::value &&
+                  !std::is_convertible<expected<U, G> const &&, T>::value &&
+                  (!std::is_convertible<U, T>::value ||
+                   !std::is_convertible<G, E>::value) /*=> explicit */
+                  )>
+    nsel_constexpr14 explicit expected(expected<U, G> &&other)
+        : contained(other.has_value()) {
+      if (has_value())
+        contained.construct_value(T{std::move(other.contained.value())});
+      else
+        contained.construct_error(E{std::move(other.contained.error())});
+    }
+
+    template <typename U,
+              typename G nsel_REQUIRES_T(
+                  std::is_constructible<T, U>::value
+                      &&std::is_constructible<E, G>::value &&
+                  !std::is_constructible<T, expected<U, G> &>::value &&
+                  !std::is_constructible<T, expected<U, G> &&>::value &&
+                  !std::is_constructible<T, expected<U, G> const &>::value &&
+                  !std::is_constructible<T, expected<U, G> const &&>::value &&
+                  !std::is_convertible<expected<U, G> &, T>::value &&
+                  !std::is_convertible<expected<U, G> &&, T>::value &&
+                  !std::is_convertible<expected<U, G> const &, T>::value &&
+                  !std::is_convertible<expected<U, G> const &&, T>::value &&
+                  !(!std::is_convertible<U, T>::value ||
+                    !std::is_convertible<G, E>::value) /*=> non-explicit */
+                  )>
+    nsel_constexpr14 /*non-explicit*/ expected(expected<U, G> &&other)
+        : contained(other.has_value()) {
+      if (has_value())
+        contained.construct_value(std::move(other.contained.value()));
+      else
+        contained.construct_error(std::move(other.contained.error()));
+    }
+
+    template <
+        typename U = T nsel_REQUIRES_T(std::is_copy_constructible<U>::value)>
+    nsel_constexpr14 expected(value_type const &value) : contained(true) {
+      contained.construct_value(value);
+    }
+
+    template <typename U = T nsel_REQUIRES_T(
+                  std::is_constructible<T, U &&>::value &&
+                  !std::is_same<typename std20::remove_cvref<U>::type,
+                                nonstd_lite_in_place_t(U)>::value &&
+                  !std::is_same<expected<T, E>,
+                                typename std20::remove_cvref<U>::type>::value &&
+                  !std::is_same<nonstd::unexpected_type<E>,
+                                typename std20::remove_cvref<U>::type>::value &&
+                  !std::is_convertible<U &&, T>::value /*=> explicit */
+                  )>
+    nsel_constexpr14 explicit expected(U &&value) noexcept(
+        std::is_nothrow_move_constructible<U>::value &&
+        std::is_nothrow_move_constructible<E>::value)
+        : contained(true) {
+      contained.construct_value(T{std::forward<U>(value)});
+    }
+
+    template <typename U = T nsel_REQUIRES_T(
+                  std::is_constructible<T, U &&>::value &&
+                  !std::is_same<typename std20::remove_cvref<U>::type,
+                                nonstd_lite_in_place_t(U)>::value &&
+                  !std::is_same<expected<T, E>,
+                                typename std20::remove_cvref<U>::type>::value &&
+                  !std::is_same<nonstd::unexpected_type<E>,
+                                typename std20::remove_cvref<U>::type>::value &&
+                  std::is_convertible<U &&, T>::value /*=> non-explicit */
+                  )>
+    nsel_constexpr14 /*non-explicit*/
+    expected(U &&value) noexcept(std::is_nothrow_move_constructible<U>::value &&
+                                 std::is_nothrow_move_constructible<E>::value)
+        : contained(true) {
+      contained.construct_value(std::forward<U>(value));
+    }
+
+    // construct error:
+
+    template <typename G = E nsel_REQUIRES_T(
+                  std::is_constructible<E, G const &>::value &&
+                  !std::is_convertible<G const &, E>::value /*=> explicit */
+                  )>
+    nsel_constexpr14 explicit expected(nonstd::unexpected_type<G> const &error)
+        : contained(false) {
+      contained.construct_error(E{error.value()});
+    }
+
+    template <typename G = E nsel_REQUIRES_T(
+                  std::is_constructible<E, G const &>::value &&
+                      std::is_convertible<G const &, E>::value /*=> non-explicit
+                                                                */
+                  )>
+    nsel_constexpr14 /*non-explicit*/
+    expected(nonstd::unexpected_type<G> const &error)
+        : contained(false) {
+      contained.construct_error(error.value());
+    }
+
+    template <typename G = E nsel_REQUIRES_T(
+                  std::is_constructible<E, G &&>::value &&
+                  !std::is_convertible<G &&, E>::value /*=> explicit */
+                  )>
+    nsel_constexpr14 explicit expected(nonstd::unexpected_type<G> &&error)
+        : contained(false) {
+      contained.construct_error(E{std::move(error.value())});
+    }
+
+    template <typename G = E nsel_REQUIRES_T(
+                  std::is_constructible<E, G &&>::value
+                      &&std::is_convertible<G &&, E>::value /*=> non-explicit */
+                  )>
+    nsel_constexpr14 /*non-explicit*/
+    expected(nonstd::unexpected_type<G> &&error)
+        : contained(false) {
+      contained.construct_error(std::move(error.value()));
+    }
+
+    // in-place construction, value
+
+    template <typename... Args nsel_REQUIRES_T(
+        std::is_constructible<T, Args &&...>::value)>
+    nsel_constexpr14 explicit expected(nonstd_lite_in_place_t(T),
+                                       Args &&...args)
+        : contained(true) {
+      contained.emplace_value(std::forward<Args>(args)...);
+    }
+
+    template <typename U, typename... Args nsel_REQUIRES_T(
+                              std::is_constructible<T, std::initializer_list<U>,
+                                                    Args &&...>::value)>
+    nsel_constexpr14 explicit expected(nonstd_lite_in_place_t(T),
+                                       std::initializer_list<U> il,
+                                       Args &&...args)
+        : contained(true) {
+      contained.emplace_value(il, std::forward<Args>(args)...);
+    }
+
+    // in-place construction, error
+
+    template <typename... Args nsel_REQUIRES_T(
+        std::is_constructible<E, Args &&...>::value)>
+    nsel_constexpr14 explicit expected(unexpect_t, Args &&...args)
+        : contained(false) {
+      contained.emplace_error(std::forward<Args>(args)...);
+    }
+
+    template <typename U, typename... Args nsel_REQUIRES_T(
+                              std::is_constructible<E, std::initializer_list<U>,
+                                                    Args &&...>::value)>
+    nsel_constexpr14 explicit expected(unexpect_t, std::initializer_list<U> il,
+                                       Args &&...args)
+        : contained(false) {
+      contained.emplace_error(il, std::forward<Args>(args)...);
+    }
+
+    // x.x.4.2 destructor
+
+    // TODO: ~expected: triviality
+    // Effects: If T is not cv void and is_trivially_destructible_v<T> is false
+    // and bool(*this), calls val.~T(). If is_trivially_destructible_v<E> is
+    // false and !bool(*this), calls unexpect.~unexpected<E>(). Remarks: If
+    // either T is cv void or is_trivially_destructible_v<T> is true, and
+    // is_trivially_destructible_v<E> is true, then this destructor shall be a
+    // trivial destructor.
+
+    ~expected() {
+      if (has_value())
+        contained.destruct_value();
+      else
+        contained.destruct_error();
+    }
+
+    // x.x.4.3 assignment
+
+    expected &operator=(expected const &other) {
+      expected(other).swap(*this);
+      return *this;
+    }
+
+    expected &operator=(expected &&other) noexcept(
+        std::is_nothrow_move_constructible<T>::value &&
+        std::is_nothrow_move_assignable<T>::value &&
+        std::is_nothrow_move_constructible<E>::value  // added for missing
+        && std::is_nothrow_move_assignable<E>::value) //   nothrow above
+    {
+      expected(std::move(other)).swap(*this);
+      return *this;
+    }
+
+    template <typename U nsel_REQUIRES_T(
+        !std::is_same<expected<T, E>,
+                      typename std20::remove_cvref<U>::type>::value &&
+        std17::conjunction<std::is_scalar<T>,
+                           std::is_same<T, std::decay<U>>>::value &&
+        std::is_constructible<T, U>::value &&
+        std::is_assignable<T &, U>::value &&
+        std::is_nothrow_move_constructible<E>::value)>
+    expected &operator=(U &&value) {
+      expected(std::forward<U>(value)).swap(*this);
+      return *this;
+    }
+
+    template <typename G = E nsel_REQUIRES_T(
+                  std::is_constructible<E, G const &>::value
+                      &&std::is_copy_constructible<G>::
+                          value // TODO: std::is_nothrow_copy_constructible<G>
+                              &&std::is_copy_assignable<G>::value)>
+    expected &operator=(nonstd::unexpected_type<G> const &error) {
+      expected(unexpect, error.value()).swap(*this);
+      return *this;
+    }
+
+    template <
+        typename G = E nsel_REQUIRES_T(
+            std::is_constructible<E, G &&>::value &&std::is_move_constructible<
+                G>::value // TODO: std::is_nothrow_move_constructible<G>
+                &&std::is_move_assignable<G>::value)>
+    expected &operator=(nonstd::unexpected_type<G> &&error) {
+      expected(unexpect, std::move(error.value())).swap(*this);
+      return *this;
+    }
+
+    template <typename... Args nsel_REQUIRES_T(
+        std::is_nothrow_constructible<T, Args &&...>::value)>
+    value_type &emplace(Args &&...args) {
+      expected(nonstd_lite_in_place(T), std::forward<Args>(args)...)
+          .swap(*this);
+      return value();
+    }
+
+    template <typename U,
+              typename... Args nsel_REQUIRES_T(
+                  std::is_nothrow_constructible<T, std::initializer_list<U> &,
+                                                Args &&...>::value)>
+    value_type &emplace(std::initializer_list<U> il, Args &&...args) {
+      expected(nonstd_lite_in_place(T), il, std::forward<Args>(args)...)
+          .swap(*this);
+      return value();
+    }
+
+    // x.x.4.4 swap
+
+    template <typename U = T, typename G = E>
+    nsel_REQUIRES_R(
+        void, std17::is_swappable<U>::value &&std17::is_swappable<G>::value &&
+                  (std::is_move_constructible<U>::value ||
+                   std::is_move_constructible<G>::value))
+        swap(expected &other) noexcept(
+            std::is_nothrow_move_constructible<T>::value &&
+            std17::is_nothrow_swappable<T &>::value &&
+            std::is_nothrow_move_constructible<E>::value &&
+            std17::is_nothrow_swappable<E &>::value) {
+      using std::swap;
+
+      if (bool(*this) && bool(other)) {
+        swap(contained.value(), other.contained.value());
+      } else if (!bool(*this) && !bool(other)) {
+        swap(contained.error(), other.contained.error());
+      } else if (bool(*this) && !bool(other)) {
+        error_type t(std::move(other.error()));
+        other.contained.destruct_error();
+        other.contained.construct_value(std::move(contained.value()));
+        contained.destruct_value();
+        contained.construct_error(std::move(t));
+        bool has_value = contained.has_value();
+        bool other_has_value = other.has_value();
+        other.contained.set_has_value(has_value);
+        contained.set_has_value(other_has_value);
+      } else if (!bool(*this) && bool(other)) {
+        other.swap(*this);
+      }
+    }
+
+    // x.x.4.5 observers
+
+    constexpr value_type const *operator->() const {
+      return assert(has_value()), contained.value_ptr();
+    }
+
+    value_type *operator->() {
+      return assert(has_value()), contained.value_ptr();
+    }
+
+    constexpr value_type const &operator*() const & {
+      return assert(has_value()), contained.value();
+    }
+
+    value_type &operator*() & { return assert(has_value()), contained.value(); }
+
+#if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
+
+    constexpr value_type const &&operator*() const && {
+      return std::move((assert(has_value()), contained.value()));
+    }
+
+    nsel_constexpr14 value_type &&operator*() && {
+      return std::move((assert(has_value()), contained.value()));
+    }
+
+#endif
+
+    constexpr explicit operator bool() const noexcept { return has_value(); }
+
+    constexpr bool has_value() const noexcept { return contained.has_value(); }
+
+    constexpr value_type const &value() const & {
+      return has_value()
+                 ? (contained.value())
+                 : (error_traits<error_type>::rethrow(contained.error()),
+                    contained.value());
+    }
+
+    value_type &value() & {
+      return has_value()
+                 ? (contained.value())
+                 : (error_traits<error_type>::rethrow(contained.error()),
+                    contained.value());
+    }
+
+#if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
+
+    constexpr value_type const &&value() const && {
+      return std::move(
+          has_value() ? (contained.value())
+                      : (error_traits<error_type>::rethrow(contained.error()),
+                         contained.value()));
+    }
+
+    nsel_constexpr14 value_type &&value() && {
+      return std::move(
+          has_value() ? (contained.value())
+                      : (error_traits<error_type>::rethrow(contained.error()),
+                         contained.value()));
+    }
+
+#endif
+
+    constexpr error_type const &error() const & {
+      return assert(!has_value()), contained.error();
+    }
+
+    error_type &error() & { return assert(!has_value()), contained.error(); }
+
+#if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
+
+    constexpr error_type const &&error() const && {
+      return std::move((assert(!has_value()), contained.error()));
+    }
+
+    error_type &&error() && {
+      return std::move((assert(!has_value()), contained.error()));
+    }
+
+#endif
+
+    constexpr unexpected_type get_unexpected() const {
+      return make_unexpected(contained.error());
+    }
+
+    template <typename Ex> bool has_exception() const {
+      using ContainedEx = typename std::remove_reference<
+          decltype(get_unexpected().value())>::type;
+      return !has_value() && std::is_base_of<Ex, ContainedEx>::value;
+    }
+
+    template <
+        typename U nsel_REQUIRES_T(std::is_copy_constructible<T>::value
+                                       &&std::is_convertible<U &&, T>::value)>
+    value_type value_or(U &&v) const & {
+      return has_value() ? contained.value()
+                         : static_cast<T>(std::forward<U>(v));
+    }
+
+    template <
+        typename U nsel_REQUIRES_T(std::is_move_constructible<T>::value
+                                       &&std::is_convertible<U &&, T>::value)>
+    value_type value_or(U &&v) && {
+      return has_value() ? std::move(contained.value())
+                         : static_cast<T>(std::forward<U>(v));
+    }
+
+#if nsel_P2505R >= 4
+    template <
+        typename G = E nsel_REQUIRES_T(std::is_copy_constructible<E>::value
+                                           &&std::is_convertible<G, E>::value)>
+    nsel_constexpr error_type error_or(G &&e) const & {
+      return has_value() ? static_cast<E>(std::forward<G>(e))
+                         : contained.error();
+    }
+
+    template <
+        typename G = E nsel_REQUIRES_T(std::is_move_constructible<E>::value
+                                           &&std::is_convertible<G, E>::value)>
+    nsel_constexpr14 error_type error_or(G &&e) && {
+      return has_value() ? static_cast<E>(std::forward<G>(e))
+                         : std::move(contained.error());
+    }
+#endif // nsel_P2505R >= 4
+
+#if nsel_P2505R >= 3
+    // Monadic operations (P2505)
+    template <typename F nsel_REQUIRES_T(
+        detail::is_expected<detail::invoke_result_nocvref_t<F, value_type &>>::
+            value &&std::is_same<typename detail::invoke_result_nocvref_t<
+                                     F, value_type &>::error_type,
+                                 error_type>::value
+                &&std::is_constructible<error_type, error_type &>::value)>
+    nsel_constexpr14 detail::invoke_result_nocvref_t<F, value_type &>
+    and_then(F &&f) & {
+      return has_value() ? detail::invoke_result_nocvref_t<F, value_type &>(
+                               detail::invoke(std::forward<F>(f), value()))
+                         : detail::invoke_result_nocvref_t<F, value_type &>(
+                               unexpect, error());
+    }
+
+    template <typename F nsel_REQUIRES_T(
+        detail::is_expected<
+            detail::invoke_result_nocvref_t<F, const value_type &>>::value
+            &&std::is_same<typename detail::invoke_result_nocvref_t<
+                               F, const value_type &>::error_type,
+                           error_type>::value
+                &&std::is_constructible<error_type, const error_type &>::value)>
+    nsel_constexpr detail::invoke_result_nocvref_t<F, const value_type &>
+    and_then(F &&f) const & {
+      return has_value()
+                 ? detail::invoke_result_nocvref_t<F, const value_type &>(
+                       detail::invoke(std::forward<F>(f), value()))
+                 : detail::invoke_result_nocvref_t<F, const value_type &>(
+                       unexpect, error());
+    }
+
+#if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
+    template <typename F nsel_REQUIRES_T(
+        detail::is_expected<detail::invoke_result_nocvref_t<F, value_type &&>>::
+            value &&std::is_same<typename detail::invoke_result_nocvref_t<
+                                     F, value_type &&>::error_type,
+                                 error_type>::value
+                &&std::is_constructible<error_type, error_type &&>::value)>
+    nsel_constexpr14 detail::invoke_result_nocvref_t<F, value_type &&>
+    and_then(F &&f) && {
+      return has_value()
+                 ? detail::invoke_result_nocvref_t<F, value_type &&>(
+                       detail::invoke(std::forward<F>(f), std::move(value())))
+                 : detail::invoke_result_nocvref_t<F, value_type &&>(
+                       unexpect, std::move(error()));
+    }
+
+    template <typename F nsel_REQUIRES_T(
+        detail::is_expected<
+            detail::invoke_result_nocvref_t<F, const value_type &&>>::value
+            &&std::is_same<typename detail::invoke_result_nocvref_t<
+                               F, const value_type &>::error_type,
+                           error_type>::value &&
+                std::is_constructible<error_type, const error_type &&>::value)>
+    nsel_constexpr detail::invoke_result_nocvref_t<F, const value_type &&>
+    and_then(F &&f) const && {
+      return has_value()
+                 ? detail::invoke_result_nocvref_t<F, const value_type &&>(
+                       detail::invoke(std::forward<F>(f), std::move(value())))
+                 : detail::invoke_result_nocvref_t<F, const value_type &&>(
+                       unexpect, std::move(error()));
+    }
+#endif
+
+    template <typename F nsel_REQUIRES_T(
+        detail::is_expected<detail::invoke_result_nocvref_t<F, error_type &>>::
+            value &&std::is_same<typename detail::invoke_result_nocvref_t<
+                                     F, error_type &>::value_type,
+                                 value_type>::value
+                &&std::is_constructible<value_type, value_type &>::value)>
+    nsel_constexpr14 detail::invoke_result_nocvref_t<F, error_type &>
+    or_else(F &&f) & {
+      return has_value()
+                 ? detail::invoke_result_nocvref_t<F, error_type &>(value())
+                 : detail::invoke_result_nocvref_t<F, error_type &>(
+                       detail::invoke(std::forward<F>(f), error()));
+    }
+
+    template <typename F nsel_REQUIRES_T(
+        detail::is_expected<
+            detail::invoke_result_nocvref_t<F, const error_type &>>::value
+            &&std::is_same<typename detail::invoke_result_nocvref_t<
+                               F, const error_type &>::value_type,
+                           value_type>::value
+                &&std::is_constructible<value_type, const value_type &>::value)>
+    nsel_constexpr detail::invoke_result_nocvref_t<F, const error_type &>
+    or_else(F &&f) const & {
+      return has_value()
+                 ? detail::invoke_result_nocvref_t<F, const error_type &>(
+                       value())
+                 : detail::invoke_result_nocvref_t<F, const error_type &>(
+                       detail::invoke(std::forward<F>(f), error()));
+    }
+
+#if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
+    template <typename F nsel_REQUIRES_T(
+        detail::is_expected<detail::invoke_result_nocvref_t<F, error_type &&>>::
+            value &&std::is_same<typename detail::invoke_result_nocvref_t<
+                                     F, error_type &&>::value_type,
+                                 value_type>::value
+                &&std::is_constructible<value_type, value_type &&>::value)>
+    nsel_constexpr14 detail::invoke_result_nocvref_t<F, error_type &&>
+    or_else(F &&f) && {
+      return has_value()
+                 ? detail::invoke_result_nocvref_t<F, error_type &&>(
+                       std::move(value()))
+                 : detail::invoke_result_nocvref_t<F, error_type &&>(
+                       detail::invoke(std::forward<F>(f), std::move(error())));
+    }
+
+    template <typename F nsel_REQUIRES_T(
+        detail::is_expected<
+            detail::invoke_result_nocvref_t<F, const error_type &&>>::value
+            &&std::is_same<typename detail::invoke_result_nocvref_t<
+                               F, const error_type &&>::value_type,
+                           value_type>::value &&
+                std::is_constructible<value_type, const value_type &&>::value)>
+    nsel_constexpr detail::invoke_result_nocvref_t<F, const error_type &&>
+    or_else(F &&f) const && {
+      return has_value()
+                 ? detail::invoke_result_nocvref_t<F, const error_type &&>(
+                       std::move(value()))
+                 : detail::invoke_result_nocvref_t<F, const error_type &&>(
+                       detail::invoke(std::forward<F>(f), std::move(error())));
+    }
+#endif
+
+    template <typename F nsel_REQUIRES_T(
+        std::is_constructible<error_type, error_type &>::value &&
+        !std::is_void<
+            detail::transform_invoke_result_t<F, value_type &>>::value &&
+        detail::valid_expected_value_type<
+            detail::transform_invoke_result_t<F, value_type &>>::value)>
+    nsel_constexpr14
+        expected<detail::transform_invoke_result_t<F, value_type &>, error_type>
+        transform(F &&f) & {
+      return has_value()
+                 ? expected<detail::transform_invoke_result_t<F, value_type &>,
+                            error_type>(
+                       detail::invoke(std::forward<F>(f), **this))
+                 : make_unexpected(error());
+    }
+
+    template <typename F nsel_REQUIRES_T(
+        std::is_constructible<error_type, error_type &>::value &&std::is_void<
+            detail::transform_invoke_result_t<F, value_type &>>::value)>
+    nsel_constexpr14 expected<void, error_type> transform(F &&f) & {
+      return has_value() ? (detail::invoke(std::forward<F>(f), **this),
+                            expected<void, error_type>())
+                         : make_unexpected(error());
+    }
+
+    template <typename F nsel_REQUIRES_T(
+        std::is_constructible<error_type, const error_type &>::value &&
+        !std::is_void<
+            detail::transform_invoke_result_t<F, const value_type &>>::value &&
+        detail::valid_expected_value_type<
+            detail::transform_invoke_result_t<F, const value_type &>>::value)>
+    nsel_constexpr
+        expected<detail::transform_invoke_result_t<F, const value_type &>,
+                 error_type>
+        transform(F &&f) const & {
+      return has_value()
+                 ? expected<
+                       detail::transform_invoke_result_t<F, const value_type &>,
+                       error_type>(detail::invoke(std::forward<F>(f), **this))
+                 : make_unexpected(error());
+    }
+
+    template <typename F nsel_REQUIRES_T(
+        std::is_constructible<error_type, const error_type &>::value
+            &&std::is_void<detail::transform_invoke_result_t<
+                F, const value_type &>>::value)>
+    nsel_constexpr expected<void, error_type> transform(F &&f) const & {
+      return has_value() ? (detail::invoke(std::forward<F>(f), **this),
+                            expected<void, error_type>())
+                         : make_unexpected(error());
+    }
+
+#if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
+    template <typename F nsel_REQUIRES_T(
+        std::is_constructible<error_type, error_type &&>::value &&
+        !std::is_void<
+            detail::transform_invoke_result_t<F, value_type &&>>::value &&
+        detail::valid_expected_value_type<
+            detail::transform_invoke_result_t<F, value_type &&>>::value)>
+    nsel_constexpr14
+        expected<detail::transform_invoke_result_t<F, value_type &&>,
+                 error_type>
+        transform(F &&f) && {
+      return has_value()
+                 ? expected<detail::transform_invoke_result_t<F, value_type &&>,
+                            error_type>(
+                       detail::invoke(std::forward<F>(f), std::move(**this)))
+                 : make_unexpected(std::move(error()));
+    }
+
+    template <typename F nsel_REQUIRES_T(
+        std::is_constructible<error_type, error_type &&>::value &&std::is_void<
+            detail::transform_invoke_result_t<F, value_type &&>>::value)>
+    nsel_constexpr14 expected<void, error_type> transform(F &&f) && {
+      return has_value() ? (detail::invoke(std::forward<F>(f), **this),
+                            expected<void, error_type>())
+                         : make_unexpected(std::move(error()));
+    }
+
+    template <typename F nsel_REQUIRES_T(
+        std::is_constructible<error_type, const error_type &&>::value &&
+        !std::is_void<
+            detail::transform_invoke_result_t<F, const value_type &&>>::value &&
+        detail::valid_expected_value_type<
+            detail::transform_invoke_result_t<F, const value_type &&>>::value)>
+    nsel_constexpr
+        expected<detail::transform_invoke_result_t<F, const value_type &&>,
+                 error_type>
+        transform(F &&f) const && {
+      return has_value() ? expected<detail::transform_invoke_result_t<
+                                        F, const value_type &&>,
+                                    error_type>(detail::invoke(
+                               std::forward<F>(f), std::move(**this)))
+                         : make_unexpected(std::move(error()));
+    }
+
+    template <typename F nsel_REQUIRES_T(
+        std::is_constructible<error_type, const error_type &&>::value
+            &&std::is_void<detail::transform_invoke_result_t<
+                F, const value_type &&>>::value)>
+    nsel_constexpr expected<void, error_type> transform(F &&f) const && {
+      return has_value() ? (detail::invoke(std::forward<F>(f), **this),
+                            expected<void, error_type>())
+                         : make_unexpected(std::move(error()));
+    }
+#endif
+
+    template <typename F nsel_REQUIRES_T(
+        detail::valid_unexpected_type<
+            detail::transform_invoke_result_t<F, error_type &>>::value
+            &&std::is_constructible<value_type, value_type &>::value)>
+    nsel_constexpr14
+        expected<value_type, detail::transform_invoke_result_t<F, error_type &>>
+        transform_error(F &&f) & {
+      return has_value()
+                 ? expected<value_type,
+                            detail::transform_invoke_result_t<F, error_type &>>(
+                       in_place, **this)
+                 : make_unexpected(detail::invoke(std::forward<F>(f), error()));
+    }
+
+    template <typename F nsel_REQUIRES_T(
+        detail::valid_unexpected_type<
+            detail::transform_invoke_result_t<F, const error_type &>>::value
+            &&std::is_constructible<value_type, const value_type &>::value)>
+    nsel_constexpr
+        expected<value_type,
+                 detail::transform_invoke_result_t<F, const error_type &>>
+        transform_error(F &&f) const & {
+      return has_value()
+                 ? expected<value_type, detail::transform_invoke_result_t<
+                                            F, const error_type &>>(in_place,
+                                                                    **this)
+                 : make_unexpected(detail::invoke(std::forward<F>(f), error()));
+    }
+
+#if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
+    template <typename F nsel_REQUIRES_T(
+        detail::valid_unexpected_type<
+            detail::transform_invoke_result_t<F, error_type &&>>::value
+            &&std::is_constructible<value_type, value_type &&>::value)>
+    nsel_constexpr14
+        expected<value_type,
+                 detail::transform_invoke_result_t<F, error_type &&>>
+        transform_error(F &&f) && {
+      return has_value()
+                 ? expected<value_type, detail::transform_invoke_result_t<
+                                            F, error_type &&>>(
+                       in_place, std::move(**this))
+                 : make_unexpected(
+                       detail::invoke(std::forward<F>(f), std::move(error())));
+    }
+
+    template <typename F nsel_REQUIRES_T(
+        detail::valid_unexpected_type<
+            detail::transform_invoke_result_t<F, const error_type &&>>::value
+            &&std::is_constructible<value_type, const value_type &&>::value)>
+    nsel_constexpr
+        expected<value_type,
+                 detail::transform_invoke_result_t<F, const error_type &&>>
+        transform_error(F &&f) const && {
+      return has_value()
+                 ? expected<value_type, detail::transform_invoke_result_t<
+                                            F, const error_type &&>>(
+                       in_place, std::move(**this))
+                 : make_unexpected(
+                       detail::invoke(std::forward<F>(f), std::move(error())));
+    }
+#endif
+#endif // nsel_P2505R >= 3
+    // unwrap()
+
+    //  template <class U, class E>
+    //  constexpr expected<U,E> expected<expected<U,E>,E>::unwrap() const&;
+
+    //  template <class T, class E>
+    //  constexpr expected<T,E> expected<T,E>::unwrap() const&;
+
+    //  template <class U, class E>
+    //  expected<U,E> expected<expected<U,E>, E>::unwrap() &&;
+
+    //  template <class T, class E>
+    //  template expected<T,E> expected<T,E>::unwrap() &&;
+
+    // factories
+
+    //  template< typename Ex, typename F>
+    //  expected<T,E> catch_exception(F&& f);
+
+    //  template< typename F>
+    //  expected<decltype(func(declval<T>())),E> map(F&& func) ;
+
+    //  template< typename F>
+    //  'see below' bind(F&& func);
+
+    //  template< typename F>
+    //  expected<T,E> catch_error(F&& f);
+
+    //  template< typename F>
+    //  'see below' then(F&& func);
+
+  private:
+    detail::storage_t<T, E,
+                      std::is_copy_constructible<T>::value &&
+                          std::is_copy_constructible<E>::value,
+                      std::is_move_constructible<T>::value &&
+                          std::is_move_constructible<E>::value>
+        contained;
+  };
+
+  /// class expected, void specialization
+
+  template <typename E> class expected<void, E> {
+  private:
+    template <typename, typename> friend class expected;
+
+  public:
+    using value_type = void;
+    using error_type = E;
+    using unexpected_type = nonstd::unexpected_type<E>;
+
+    // x.x.4.1 constructors
+
+    constexpr expected() noexcept : contained(true) {}
+
+    nsel_constexpr14 expected(expected const &other) = default;
+    nsel_constexpr14 expected(expected &&other) = default;
+
+    constexpr explicit expected(nonstd_lite_in_place_t(void))
+        : contained(true) {}
+
+    template <typename G = E nsel_REQUIRES_T(
+                  !std::is_convertible<G const &, E>::value /*=> explicit */
+                  )>
+    nsel_constexpr14 explicit expected(nonstd::unexpected_type<G> const &error)
+        : contained(false) {
+      contained.construct_error(E{error.value()});
+    }
+
+    template <typename G = E nsel_REQUIRES_T(
+                  std::is_convertible<G const &, E>::value /*=> non-explicit */
+                  )>
+    nsel_constexpr14 /*non-explicit*/
+    expected(nonstd::unexpected_type<G> const &error)
+        : contained(false) {
+      contained.construct_error(error.value());
+    }
+
+    template <typename G = E nsel_REQUIRES_T(
+                  !std::is_convertible<G &&, E>::value /*=> explicit */
+                  )>
+    nsel_constexpr14 explicit expected(nonstd::unexpected_type<G> &&error)
+        : contained(false) {
+      contained.construct_error(E{std::move(error.value())});
+    }
+
+    template <typename G = E nsel_REQUIRES_T(
+                  std::is_convertible<G &&, E>::value /*=> non-explicit */
+                  )>
+    nsel_constexpr14 /*non-explicit*/
+    expected(nonstd::unexpected_type<G> &&error)
+        : contained(false) {
+      contained.construct_error(std::move(error.value()));
+    }
+
+    template <typename... Args nsel_REQUIRES_T(
+        std::is_constructible<E, Args &&...>::value)>
+    nsel_constexpr14 explicit expected(unexpect_t, Args &&...args)
+        : contained(false) {
+      contained.emplace_error(std::forward<Args>(args)...);
+    }
+
+    template <typename U, typename... Args nsel_REQUIRES_T(
+                              std::is_constructible<E, std::initializer_list<U>,
+                                                    Args &&...>::value)>
+    nsel_constexpr14 explicit expected(unexpect_t, std::initializer_list<U> il,
+                                       Args &&...args)
+        : contained(false) {
+      contained.emplace_error(il, std::forward<Args>(args)...);
+    }
+
+    // destructor
+
+    ~expected() {
+      if (!has_value()) {
+        contained.destruct_error();
+      }
+    }
+
+    // x.x.4.3 assignment
+
+    expected &operator=(expected const &other) {
+      expected(other).swap(*this);
+      return *this;
+    }
+
+    expected &operator=(expected &&other) noexcept(
+        std::is_nothrow_move_assignable<E>::value &&
+        std::is_nothrow_move_constructible<E>::value) {
+      expected(std::move(other)).swap(*this);
+      return *this;
+    }
+
+    void emplace() { expected().swap(*this); }
+
+    // x.x.4.4 swap
+
+    template <typename G = E>
+    nsel_REQUIRES_R(
+        void,
+        std17::is_swappable<G>::value &&std::is_move_constructible<G>::value)
+        swap(expected &other) noexcept(
+            std::is_nothrow_move_constructible<E>::value &&
+            std17::is_nothrow_swappable<E &>::value) {
+      using std::swap;
+
+      if (!bool(*this) && !bool(other)) {
+        swap(contained.error(), other.contained.error());
+      } else if (bool(*this) && !bool(other)) {
+        contained.construct_error(std::move(other.error()));
+        bool has_value = contained.has_value();
+        bool other_has_value = other.has_value();
+        other.contained.set_has_value(has_value);
+        contained.set_has_value(other_has_value);
+      } else if (!bool(*this) && bool(other)) {
+        other.swap(*this);
+      }
+    }
+
+    // x.x.4.5 observers
+
+    constexpr explicit operator bool() const noexcept { return has_value(); }
+
+    constexpr bool has_value() const noexcept { return contained.has_value(); }
+
+    void value() const {
+      if (!has_value()) {
+        error_traits<error_type>::rethrow(contained.error());
+      }
+    }
+
+    constexpr error_type const &error() const & {
+      return assert(!has_value()), contained.error();
+    }
+
+    error_type &error() & { return assert(!has_value()), contained.error(); }
+
+#if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
+
+    constexpr error_type const &&error() const && {
+      return std::move((assert(!has_value()), contained.error()));
+    }
+
+    error_type &&error() && {
+      return std::move((assert(!has_value()), contained.error()));
+    }
+
+#endif
+
+    constexpr unexpected_type get_unexpected() const {
+      return make_unexpected(contained.error());
+    }
+
+    template <typename Ex> bool has_exception() const {
+      using ContainedEx = typename std::remove_reference<
+          decltype(get_unexpected().value())>::type;
+      return !has_value() && std::is_base_of<Ex, ContainedEx>::value;
+    }
+
+#if nsel_P2505R >= 4
+    template <
+        typename G = E nsel_REQUIRES_T(std::is_copy_constructible<E>::value
+                                           &&std::is_convertible<G, E>::value)>
+    nsel_constexpr error_type error_or(G &&e) const & {
+      return has_value() ? static_cast<E>(std::forward<G>(e))
+                         : contained.error();
+    }
+
+    template <
+        typename G = E nsel_REQUIRES_T(std::is_move_constructible<E>::value
+                                           &&std::is_convertible<G, E>::value)>
+    nsel_constexpr14 error_type error_or(G &&e) && {
+      return has_value() ? static_cast<E>(std::forward<G>(e))
+                         : std::move(contained.error());
+    }
+#endif // nsel_P2505R >= 4
+
+#if nsel_P2505R >= 3
+    // Monadic operations (P2505)
+    template <typename F nsel_REQUIRES_T(
+        detail::is_expected<detail::invoke_result_nocvref_t<F>>::value &&std::
+            is_same<typename detail::invoke_result_nocvref_t<F>::error_type,
+                    error_type>::value
+                &&std::is_constructible<error_type, error_type &>::value)>
+    nsel_constexpr14 detail::invoke_result_nocvref_t<F> and_then(F &&f) & {
+      return has_value()
+                 ? detail::invoke_result_nocvref_t<F>(
+                       detail::invoke(std::forward<F>(f)))
+                 : detail::invoke_result_nocvref_t<F>(unexpect, error());
+    }
+
+    template <typename F nsel_REQUIRES_T(
+        detail::is_expected<detail::invoke_result_nocvref_t<F>>::value &&std::
+            is_same<typename detail::invoke_result_nocvref_t<F>::error_type,
+                    error_type>::value
+                &&std::is_constructible<error_type, const error_type &>::value)>
+    nsel_constexpr detail::invoke_result_nocvref_t<F> and_then(F &&f) const & {
+      return has_value()
+                 ? detail::invoke_result_nocvref_t<F>(
+                       detail::invoke(std::forward<F>(f)))
+                 : detail::invoke_result_nocvref_t<F>(unexpect, error());
+    }
+
+#if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
+    template <typename F nsel_REQUIRES_T(
+        detail::is_expected<detail::invoke_result_nocvref_t<F>>::value &&std::
+            is_same<typename detail::invoke_result_nocvref_t<F>::error_type,
+                    error_type>::value
+                &&std::is_constructible<error_type, error_type &&>::value)>
+    nsel_constexpr14 detail::invoke_result_nocvref_t<F> and_then(F &&f) && {
+      return has_value() ? detail::invoke_result_nocvref_t<F>(
+                               detail::invoke(std::forward<F>(f)))
+                         : detail::invoke_result_nocvref_t<F>(
+                               unexpect, std::move(error()));
+    }
+
+    template <typename F nsel_REQUIRES_T(
+        detail::is_expected<detail::invoke_result_nocvref_t<F>>::value &&std::
+            is_same<typename detail::invoke_result_nocvref_t<F>::error_type,
+                    error_type>::value &&
+                std::is_constructible<error_type, const error_type &&>::value)>
+    nsel_constexpr detail::invoke_result_nocvref_t<F> and_then(F &&f) const && {
+      return has_value() ? detail::invoke_result_nocvref_t<F>(
+                               detail::invoke(std::forward<F>(f)))
+                         : detail::invoke_result_nocvref_t<F>(
+                               unexpect, std::move(error()));
+    }
+#endif
+
+    template <typename F nsel_REQUIRES_T(
+        detail::is_expected<detail::invoke_result_nocvref_t<F, error_type &>>::
+            value &&std::is_void<typename detail::invoke_result_nocvref_t<
+                F, error_type &>::value_type>::value)>
+    nsel_constexpr14 detail::invoke_result_nocvref_t<F, error_type &>
+    or_else(F &&f) & {
+      return has_value() ? detail::invoke_result_nocvref_t<F, error_type &>()
+                         : detail::invoke_result_nocvref_t<F, error_type &>(
+                               detail::invoke(std::forward<F>(f), error()));
+    }
+
+    template <typename F nsel_REQUIRES_T(
+        detail::is_expected<
+            detail::invoke_result_nocvref_t<F, const error_type &>>::value
+            &&std::is_void<typename detail::invoke_result_nocvref_t<
+                F, const error_type &>::value_type>::value)>
+    nsel_constexpr detail::invoke_result_nocvref_t<F, const error_type &>
+    or_else(F &&f) const & {
+      return has_value()
+                 ? detail::invoke_result_nocvref_t<F, const error_type &>()
+                 : detail::invoke_result_nocvref_t<F, const error_type &>(
+                       detail::invoke(std::forward<F>(f), error()));
+    }
+
+#if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
+    template <typename F nsel_REQUIRES_T(
+        detail::is_expected<detail::invoke_result_nocvref_t<F, error_type &&>>::
+            value &&std::is_void<typename detail::invoke_result_nocvref_t<
+                F, error_type &&>::value_type>::value)>
+    nsel_constexpr14 detail::invoke_result_nocvref_t<F, error_type &&>
+    or_else(F &&f) && {
+      return has_value()
+                 ? detail::invoke_result_nocvref_t<F, error_type &&>()
+                 : detail::invoke_result_nocvref_t<F, error_type &&>(
+                       detail::invoke(std::forward<F>(f), std::move(error())));
+    }
+
+    template <typename F nsel_REQUIRES_T(
+        detail::is_expected<
+            detail::invoke_result_nocvref_t<F, const error_type &&>>::value
+            &&std::is_void<typename detail::invoke_result_nocvref_t<
+                F, const error_type &&>::value_type>::value)>
+    nsel_constexpr detail::invoke_result_nocvref_t<F, const error_type &&>
+    or_else(F &&f) const && {
+      return has_value()
+                 ? detail::invoke_result_nocvref_t<F, const error_type &&>()
+                 : detail::invoke_result_nocvref_t<F, const error_type &&>(
+                       detail::invoke(std::forward<F>(f), std::move(error())));
+    }
+#endif
+
+    template <typename F nsel_REQUIRES_T(
+        std::is_constructible<error_type, error_type &>::value &&
+        !std::is_void<detail::transform_invoke_result_t<F>>::value)>
+    nsel_constexpr14 expected<detail::transform_invoke_result_t<F>, error_type>
+    transform(F &&f) & {
+      return has_value()
+                 ? expected<detail::transform_invoke_result_t<F>, error_type>(
+                       detail::invoke(std::forward<F>(f)))
+                 : make_unexpected(error());
+    }
+
+    template <typename F nsel_REQUIRES_T(
+        std::is_constructible<error_type, error_type &>::value
+            &&std::is_void<detail::transform_invoke_result_t<F>>::value)>
+    nsel_constexpr14 expected<void, error_type> transform(F &&f) & {
+      return has_value() ? (detail::invoke(std::forward<F>(f)),
+                            expected<void, error_type>())
+                         : make_unexpected(error());
+    }
+
+    template <typename F nsel_REQUIRES_T(
+        std::is_constructible<error_type, const error_type &>::value &&
+        !std::is_void<detail::transform_invoke_result_t<F>>::value)>
+    nsel_constexpr expected<detail::transform_invoke_result_t<F>, error_type>
+    transform(F &&f) const & {
+      return has_value()
+                 ? expected<detail::transform_invoke_result_t<F>, error_type>(
+                       detail::invoke(std::forward<F>(f)))
+                 : make_unexpected(error());
+    }
+
+    template <typename F nsel_REQUIRES_T(
+        std::is_constructible<error_type, const error_type &>::value
+            &&std::is_void<detail::transform_invoke_result_t<F>>::value)>
+    nsel_constexpr expected<void, error_type> transform(F &&f) const & {
+      return has_value() ? (detail::invoke(std::forward<F>(f)),
+                            expected<void, error_type>())
+                         : make_unexpected(error());
+    }
+
+#if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
+    template <typename F nsel_REQUIRES_T(
+        std::is_constructible<error_type, error_type &&>::value &&
+        !std::is_void<detail::transform_invoke_result_t<F>>::value)>
+    nsel_constexpr14 expected<detail::transform_invoke_result_t<F>, error_type>
+    transform(F &&f) && {
+      return has_value()
+                 ? expected<detail::transform_invoke_result_t<F>, error_type>(
+                       detail::invoke(std::forward<F>(f)))
+                 : make_unexpected(error());
+    }
+
+    template <typename F nsel_REQUIRES_T(
+        std::is_constructible<error_type, error_type &&>::value
+            &&std::is_void<detail::transform_invoke_result_t<F>>::value)>
+    nsel_constexpr14 expected<void, error_type> transform(F &&f) && {
+      return has_value() ? (detail::invoke(std::forward<F>(f)),
+                            expected<void, error_type>())
+                         : make_unexpected(error());
+    }
+
+    template <typename F nsel_REQUIRES_T(
+        std::is_constructible<error_type, const error_type &&>::value &&
+        !std::is_void<detail::transform_invoke_result_t<F>>::value)>
+    nsel_constexpr expected<detail::transform_invoke_result_t<F>, error_type>
+    transform(F &&f) const && {
+      return has_value()
+                 ? expected<detail::transform_invoke_result_t<F>, error_type>(
+                       detail::invoke(std::forward<F>(f)))
+                 : make_unexpected(error());
+    }
+
+    template <typename F nsel_REQUIRES_T(
+        std::is_constructible<error_type, const error_type &&>::value
+            &&std::is_void<detail::transform_invoke_result_t<F>>::value)>
+    nsel_constexpr expected<void, error_type> transform(F &&f) const && {
+      return has_value() ? (detail::invoke(std::forward<F>(f)),
+                            expected<void, error_type>())
+                         : make_unexpected(error());
+    }
+#endif
+
+    template <typename F nsel_REQUIRES_T(
+        detail::valid_unexpected_type<
+            detail::transform_invoke_result_t<F, error_type &>>::value)>
+    nsel_constexpr14
+        expected<void, detail::transform_invoke_result_t<F, error_type &>>
+        transform_error(F &&f) & {
+      return has_value()
+                 ? expected<void, detail::transform_invoke_result_t<
+                                      F, error_type &>>()
+                 : make_unexpected(detail::invoke(std::forward<F>(f), error()));
+    }
+
+    template <typename F nsel_REQUIRES_T(
+        detail::valid_unexpected_type<
+            detail::transform_invoke_result_t<F, const error_type &>>::value)>
+    nsel_constexpr
+        expected<void, detail::transform_invoke_result_t<F, const error_type &>>
+        transform_error(F &&f) const & {
+      return has_value()
+                 ? expected<void, detail::transform_invoke_result_t<
+                                      F, const error_type &>>()
+                 : make_unexpected(detail::invoke(std::forward<F>(f), error()));
+    }
+
+#if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
+    template <typename F nsel_REQUIRES_T(
+        detail::valid_unexpected_type<
+            detail::transform_invoke_result_t<F, error_type &&>>::value)>
+    nsel_constexpr14
+        expected<void, detail::transform_invoke_result_t<F, error_type &&>>
+        transform_error(F &&f) && {
+      return has_value() ? expected<void, detail::transform_invoke_result_t<
+                                              F, error_type &&>>()
+                         : make_unexpected(detail::invoke(std::forward<F>(f),
+                                                          std::move(error())));
+    }
+
+    template <typename F nsel_REQUIRES_T(
+        detail::valid_unexpected_type<
+            detail::transform_invoke_result_t<F, const error_type &&>>::value)>
+    nsel_constexpr
+        expected<void,
+                 detail::transform_invoke_result_t<F, const error_type &&>>
+        transform_error(F &&f) const && {
+      return has_value() ? expected<void, detail::transform_invoke_result_t<
+                                              F, const error_type &&>>()
+                         : make_unexpected(detail::invoke(std::forward<F>(f),
+                                                          std::move(error())));
+    }
+#endif
+#endif // nsel_P2505R >= 3
+
+    //  template constexpr 'see below' unwrap() const&;
+    //
+    //  template 'see below' unwrap() &&;
+
+    // factories
+
+    //  template< typename Ex, typename F>
+    //  expected<void,E> catch_exception(F&& f);
+    //
+    //  template< typename F>
+    //  expected<decltype(func()), E> map(F&& func) ;
+    //
+    //  template< typename F>
+    //  'see below' bind(F&& func) ;
+    //
+    //  template< typename F>
+    //  expected<void,E> catch_error(F&& f);
+    //
+    //  template< typename F>
+    //  'see below' then(F&& func);
+
+  private:
+    detail::storage_t<void, E, std::is_copy_constructible<E>::value,
+                      std::is_move_constructible<E>::value>
+        contained;
+  };
+
+  // x.x.4.6 expected<>: comparison operators
+
+  template <typename T1, typename E1, typename T2,
+            typename E2 nsel_REQUIRES_T(!std::is_void<T1>::value &&
+                                        !std::is_void<T2>::value)>
+  constexpr bool operator==(expected<T1, E1> const &x,
+                            expected<T2, E2> const &y) {
+    return bool(x) != bool(y) ? false
+           : bool(x)          ? *x == *y
+                              : x.error() == y.error();
+  }
+
+  template <typename T1, typename E1, typename T2,
+            typename E2 nsel_REQUIRES_T(
+                std::is_void<T1>::value &&std::is_void<T2>::value)>
+  constexpr bool operator==(expected<T1, E1> const &x,
+                            expected<T2, E2> const &y) {
+    return bool(x) != bool(y)
+               ? false
+               : bool(x) || static_cast<bool>(x.error() == y.error());
+  }
+
+  template <typename T1, typename E1, typename T2, typename E2>
+  constexpr bool operator!=(expected<T1, E1> const &x,
+                            expected<T2, E2> const &y) {
+    return !(x == y);
+  }
+
+#if nsel_P0323R <= 2
+
+  template <typename T, typename E>
+  constexpr bool operator<(expected<T, E> const &x, expected<T, E> const &y) {
+    return (!y) ? false : (!x) ? true : *x < *y;
+  }
+
+  template <typename T, typename E>
+  constexpr bool operator>(expected<T, E> const &x, expected<T, E> const &y) {
+    return (y < x);
+  }
+
+  template <typename T, typename E>
+  constexpr bool operator<=(expected<T, E> const &x, expected<T, E> const &y) {
+    return !(y < x);
+  }
+
+  template <typename T, typename E>
+  constexpr bool operator>=(expected<T, E> const &x, expected<T, E> const &y) {
+    return !(x < y);
+  }
+
+#endif
+
+  // x.x.4.7 expected: comparison with T
+
+  template <typename T1, typename E1,
+            typename T2 nsel_REQUIRES_T(!std::is_void<T1>::value)>
+  constexpr bool operator==(expected<T1, E1> const &x, T2 const &v) {
+    return bool(x) ? *x == v : false;
+  }
+
+  template <typename T1, typename E1,
+            typename T2 nsel_REQUIRES_T(!std::is_void<T1>::value)>
+  constexpr bool operator==(T2 const &v, expected<T1, E1> const &x) {
+    return bool(x) ? v == *x : false;
+  }
+
+  template <typename T1, typename E1, typename T2>
+  constexpr bool operator!=(expected<T1, E1> const &x, T2 const &v) {
+    return bool(x) ? *x != v : true;
+  }
+
+  template <typename T1, typename E1, typename T2>
+  constexpr bool operator!=(T2 const &v, expected<T1, E1> const &x) {
+    return bool(x) ? v != *x : true;
+  }
+
+#if nsel_P0323R <= 2
+
+  template <typename T, typename E>
+  constexpr bool operator<(expected<T, E> const &x, T const &v) {
+    return bool(x) ? *x < v : true;
+  }
+
+  template <typename T, typename E>
+  constexpr bool operator<(T const &v, expected<T, E> const &x) {
+    return bool(x) ? v < *x : false;
+  }
+
+  template <typename T, typename E>
+  constexpr bool operator>(T const &v, expected<T, E> const &x) {
+    return bool(x) ? *x < v : false;
+  }
+
+  template <typename T, typename E>
+  constexpr bool operator>(expected<T, E> const &x, T const &v) {
+    return bool(x) ? v < *x : false;
+  }
+
+  template <typename T, typename E>
+  constexpr bool operator<=(T const &v, expected<T, E> const &x) {
+    return bool(x) ? !(*x < v) : false;
+  }
+
+  template <typename T, typename E>
+  constexpr bool operator<=(expected<T, E> const &x, T const &v) {
+    return bool(x) ? !(v < *x) : true;
+  }
+
+  template <typename T, typename E>
+  constexpr bool operator>=(expected<T, E> const &x, T const &v) {
+    return bool(x) ? !(*x < v) : false;
+  }
+
+  template <typename T, typename E>
+  constexpr bool operator>=(T const &v, expected<T, E> const &x) {
+    return bool(x) ? !(v < *x) : true;
+  }
+
+#endif // nsel_P0323R
+
+  // x.x.4.8 expected: comparison with unexpected_type
+
+  template <typename T1, typename E1, typename E2>
+  constexpr bool operator==(expected<T1, E1> const &x,
+                            unexpected_type<E2> const &u) {
+    return (!x) ? x.get_unexpected() == u : false;
+  }
+
+  template <typename T1, typename E1, typename E2>
+  constexpr bool operator==(unexpected_type<E2> const &u,
+                            expected<T1, E1> const &x) {
+    return (x == u);
+  }
+
+  template <typename T1, typename E1, typename E2>
+  constexpr bool operator!=(expected<T1, E1> const &x,
+                            unexpected_type<E2> const &u) {
+    return !(x == u);
+  }
+
+  template <typename T1, typename E1, typename E2>
+  constexpr bool operator!=(unexpected_type<E2> const &u,
+                            expected<T1, E1> const &x) {
+    return !(x == u);
+  }
+
+#if nsel_P0323R <= 2
+
+  template <typename T, typename E>
+  constexpr bool operator<(expected<T, E> const &x,
+                           unexpected_type<E> const &u) {
+    return (!x) ? (x.get_unexpected() < u) : false;
+  }
+
+  template <typename T, typename E>
+  constexpr bool operator<(unexpected_type<E> const &u,
+                           expected<T, E> const &x) {
+    return (!x) ? (u < x.get_unexpected()) : true;
+  }
+
+  template <typename T, typename E>
+  constexpr bool operator>(expected<T, E> const &x,
+                           unexpected_type<E> const &u) {
+    return (u < x);
+  }
+
+  template <typename T, typename E>
+  constexpr bool operator>(unexpected_type<E> const &u,
+                           expected<T, E> const &x) {
+    return (x < u);
+  }
+
+  template <typename T, typename E>
+  constexpr bool operator<=(expected<T, E> const &x,
+                            unexpected_type<E> const &u) {
+    return !(u < x);
+  }
+
+  template <typename T, typename E>
+  constexpr bool operator<=(unexpected_type<E> const &u,
+                            expected<T, E> const &x) {
+    return !(x < u);
+  }
+
+  template <typename T, typename E>
+  constexpr bool operator>=(expected<T, E> const &x,
+                            unexpected_type<E> const &u) {
+    return !(u > x);
+  }
+
+  template <typename T, typename E>
+  constexpr bool operator>=(unexpected_type<E> const &u,
+                            expected<T, E> const &x) {
+    return !(x > u);
+  }
+
+#endif // nsel_P0323R
+
+  /// x.x.x Specialized algorithms
+
+  template <typename T,
+            typename E nsel_REQUIRES_T((std::is_void<T>::value ||
+                                        std::is_move_constructible<T>::value) &&
+                                       std::is_move_constructible<E>::value &&
+                                       std17::is_swappable<T>::value &&
+                                       std17::is_swappable<E>::value)>
+  void swap(expected<T, E> &x,
+            expected<T, E> &y) noexcept(noexcept(x.swap(y))) {
+    x.swap(y);
+  }
+
+#if nsel_P0323R <= 3
+
+  template <typename T>
+  constexpr auto
+  make_expected(T &&v) -> expected<typename std::decay<T>::type> {
+    return expected<typename std::decay<T>::type>(std::forward<T>(v));
+  }
+
+  // expected<void> specialization:
+
+  auto inline make_expected() -> expected<void> {
+    return expected<void>(in_place);
+  }
+
+  template <typename T>
+  constexpr auto make_expected_from_current_exception() -> expected<T> {
+    return expected<T>(make_unexpected_from_current_exception());
+  }
+
+  template <typename T>
+  auto make_expected_from_exception(std::exception_ptr v) -> expected<T> {
+    return expected<T>(unexpected_type<std::exception_ptr>(
+        std::forward<std::exception_ptr>(v)));
+  }
+
+  template <typename T, typename E>
+  constexpr auto
+  make_expected_from_error(E e) -> expected<T, typename std::decay<E>::type> {
+    return expected<T, typename std::decay<E>::type>(make_unexpected(e));
+  }
+
+  template <typename F nsel_REQUIRES_T(
+      !std::is_same<typename std::result_of<F()>::type, void>::value)>
+  /*nsel_constexpr14*/
+  auto
+  make_expected_from_call(F f) -> expected<typename std::result_of<F()>::type> {
+    try {
+      return make_expected(f());
+    } catch (...) {
+      return make_unexpected_from_current_exception();
+    }
+  }
+
+  template <typename F nsel_REQUIRES_T(
+      std::is_same<typename std::result_of<F()>::type, void>::value)>
+  /*nsel_constexpr14*/
+  auto make_expected_from_call(F f) -> expected<void> {
+    try {
+      f();
+      return make_expected();
+    } catch (...) {
+      return make_unexpected_from_current_exception();
+    }
+  }
+
+#endif // nsel_P0323R
+
+  } // namespace expected_lite
+
+  using namespace expected_lite;
+
+  // using expected_lite::expected;
+  // using ...
+
+} // namespace nonstd
+
+namespace std {
+
+// expected: hash support
+
+template <typename T, typename E> struct hash<nonstd::expected<T, E>> {
+  using result_type = std::size_t;
+  using argument_type = nonstd::expected<T, E>;
+
+  constexpr result_type operator()(argument_type const &arg) const {
+    return arg ? std::hash<T>{}(*arg) : result_type{};
+  }
 };
 
-// expected_delete_ctor_base will conditionally delete copy and move
-// constructors depending on whether T is copy/move constructible
-template<class T,
-         class E,
-         bool EnableCopy = (is_copy_constructible_or_void<T>::value && std::is_copy_constructible<E>::value),
-         bool EnableMove = (is_move_constructible_or_void<T>::value && std::is_move_constructible<E>::value)>
-struct expected_delete_ctor_base {
-    expected_delete_ctor_base()                                                 = default;
-    expected_delete_ctor_base(const expected_delete_ctor_base &)                = default;
-    expected_delete_ctor_base(expected_delete_ctor_base &&) noexcept            = default;
-    expected_delete_ctor_base &operator=(const expected_delete_ctor_base &)     = default;
-    expected_delete_ctor_base &operator=(expected_delete_ctor_base &&) noexcept = default;
+// TBD - ?? remove? see spec.
+template <typename T, typename E> struct hash<nonstd::expected<T &, E>> {
+  using result_type = std::size_t;
+  using argument_type = nonstd::expected<T &, E>;
+
+  constexpr result_type operator()(argument_type const &arg) const {
+    return arg ? std::hash<T>{}(*arg) : result_type{};
+  }
 };
 
-template<class T, class E>
-struct expected_delete_ctor_base<T, E, true, false> {
-    expected_delete_ctor_base()                                                 = default;
-    expected_delete_ctor_base(const expected_delete_ctor_base &)                = default;
-    expected_delete_ctor_base(expected_delete_ctor_base &&) noexcept            = delete;
-    expected_delete_ctor_base &operator=(const expected_delete_ctor_base &)     = default;
-    expected_delete_ctor_base &operator=(expected_delete_ctor_base &&) noexcept = default;
-};
+// TBD - implement
+// bool(e), hash<expected<void,E>>()(e) shall evaluate to the hashing true;
+// otherwise it evaluates to an unspecified value if E is exception_ptr or
+// a combination of hashing false and hash<E>()(e.error()).
 
-template<class T, class E>
-struct expected_delete_ctor_base<T, E, false, true> {
-    expected_delete_ctor_base()                                                 = default;
-    expected_delete_ctor_base(const expected_delete_ctor_base &)                = delete;
-    expected_delete_ctor_base(expected_delete_ctor_base &&) noexcept            = default;
-    expected_delete_ctor_base &operator=(const expected_delete_ctor_base &)     = default;
-    expected_delete_ctor_base &operator=(expected_delete_ctor_base &&) noexcept = default;
-};
+template <typename E> struct hash<nonstd::expected<void, E>> {};
 
-template<class T, class E>
-struct expected_delete_ctor_base<T, E, false, false> {
-    expected_delete_ctor_base()                                                 = default;
-    expected_delete_ctor_base(const expected_delete_ctor_base &)                = delete;
-    expected_delete_ctor_base(expected_delete_ctor_base &&) noexcept            = delete;
-    expected_delete_ctor_base &operator=(const expected_delete_ctor_base &)     = default;
-    expected_delete_ctor_base &operator=(expected_delete_ctor_base &&) noexcept = default;
-};
+} // namespace std
 
-// expected_delete_assign_base will conditionally delete copy and move
-// constructors depending on whether T and E are copy/move constructible +
-// assignable
-template<class T,
-         class E,
-         bool EnableCopy = (is_copy_constructible_or_void<T>::value && std::is_copy_constructible<E>::value
-                            && is_copy_assignable_or_void<T>::value && std::is_copy_assignable<E>::value),
-         bool EnableMove = (is_move_constructible_or_void<T>::value && std::is_move_constructible<E>::value
-                            && is_move_assignable_or_void<T>::value && std::is_move_assignable<E>::value)>
-struct expected_delete_assign_base {
-    expected_delete_assign_base()                                                   = default;
-    expected_delete_assign_base(const expected_delete_assign_base &)                = default;
-    expected_delete_assign_base(expected_delete_assign_base &&) noexcept            = default;
-    expected_delete_assign_base &operator=(const expected_delete_assign_base &)     = default;
-    expected_delete_assign_base &operator=(expected_delete_assign_base &&) noexcept = default;
-};
+namespace nonstd {
 
-template<class T, class E>
-struct expected_delete_assign_base<T, E, true, false> {
-    expected_delete_assign_base()                                                   = default;
-    expected_delete_assign_base(const expected_delete_assign_base &)                = default;
-    expected_delete_assign_base(expected_delete_assign_base &&) noexcept            = default;
-    expected_delete_assign_base &operator=(const expected_delete_assign_base &)     = default;
-    expected_delete_assign_base &operator=(expected_delete_assign_base &&) noexcept = delete;
-};
+// void unexpected() is deprecated && removed in C++17
 
-template<class T, class E>
-struct expected_delete_assign_base<T, E, false, true> {
-    expected_delete_assign_base()                                                   = default;
-    expected_delete_assign_base(const expected_delete_assign_base &)                = default;
-    expected_delete_assign_base(expected_delete_assign_base &&) noexcept            = default;
-    expected_delete_assign_base &operator=(const expected_delete_assign_base &)     = delete;
-    expected_delete_assign_base &operator=(expected_delete_assign_base &&) noexcept = default;
-};
-
-template<class T, class E>
-struct expected_delete_assign_base<T, E, false, false> {
-    expected_delete_assign_base()                                                   = default;
-    expected_delete_assign_base(const expected_delete_assign_base &)                = default;
-    expected_delete_assign_base(expected_delete_assign_base &&) noexcept            = default;
-    expected_delete_assign_base &operator=(const expected_delete_assign_base &)     = delete;
-    expected_delete_assign_base &operator=(expected_delete_assign_base &&) noexcept = delete;
-};
-
-// This is needed to be able to construct the expected_default_ctor_base which
-// follows, while still conditionally deleting the default constructor.
-struct default_constructor_tag {
-    explicit constexpr default_constructor_tag() = default;
-};
-
-// expected_default_ctor_base will ensure that expected has a deleted default
-// consturctor if T is not default constructible.
-// This specialization is for when T is default constructible
-template<class T, class E, bool Enable = std::is_default_constructible<T>::value || std::is_void<T>::value>
-struct expected_default_ctor_base {
-    constexpr expected_default_ctor_base() noexcept                                    = default;
-    constexpr expected_default_ctor_base(expected_default_ctor_base const &) noexcept  = default;
-    constexpr expected_default_ctor_base(expected_default_ctor_base &&) noexcept       = default;
-    expected_default_ctor_base &operator=(expected_default_ctor_base const &) noexcept = default;
-    expected_default_ctor_base &operator=(expected_default_ctor_base &&) noexcept      = default;
-
-    constexpr explicit expected_default_ctor_base(default_constructor_tag) {}
-};
-
-// This specialization is for when T is not default constructible
-template<class T, class E>
-struct expected_default_ctor_base<T, E, false> {
-    constexpr expected_default_ctor_base() noexcept                                    = delete;
-    constexpr expected_default_ctor_base(expected_default_ctor_base const &) noexcept  = default;
-    constexpr expected_default_ctor_base(expected_default_ctor_base &&) noexcept       = default;
-    expected_default_ctor_base &operator=(expected_default_ctor_base const &) noexcept = default;
-    expected_default_ctor_base &operator=(expected_default_ctor_base &&) noexcept      = default;
-
-    constexpr explicit expected_default_ctor_base(default_constructor_tag) {}
-};
-}// namespace detail
-
-template<class E>
-class bad_expected_access : public std::exception {
-public:
-    explicit bad_expected_access(E e) : m_val(std::move(e)) {}
-
-    virtual const char *what() const noexcept override { return "Bad expected access"; }
-
-    const E &error() const & { return m_val; }
-
-    E &error() & { return m_val; }
-
-    const E &&error() const && { return std::move(m_val); }
-
-    E &&error() && { return std::move(m_val); }
-
-private:
-    E m_val;
-};
-
-/// An `expected<T, E>` object is an object that contains the storage for
-/// another object and manages the lifetime of this contained object `T`.
-/// Alternatively it could contain the storage for another unexpected object
-/// `E`. The contained object may not be initialized after the expected object
-/// has been initialized, and may not be destroyed before the expected object
-/// has been destroyed. The initialization state of the contained object is
-/// tracked by the expected object.
-template<class T, class E>
-class expected
-    : private detail::expected_move_assign_base<T, E>,
-      private detail::expected_delete_ctor_base<T, E>,
-      private detail::expected_delete_assign_base<T, E>,
-      private detail::expected_default_ctor_base<T, E> {
-    static_assert(!std::is_reference<T>::value, "T must not be a reference");
-    static_assert(!std::is_same<T, std::remove_cv<in_place_t>::type>::value, "T must not be in_place_t");
-    static_assert(!std::is_same<T, std::remove_cv<unexpect_t>::type>::value, "T must not be unexpect_t");
-    static_assert(!std::is_same<T, typename std::remove_cv<unexpected<E>>::type>::value, "T must not be unexpected<E>");
-    static_assert(!std::is_reference<E>::value, "E must not be a reference");
-
-    T *valptr() { return std::addressof(this->m_val); }
-
-    const T *valptr() const { return std::addressof(this->m_val); }
-
-    unexpected<E> *errptr() { return std::addressof(this->m_unexpect); }
-
-    const unexpected<E> *errptr() const { return std::addressof(this->m_unexpect); }
-
-    template<class U = T, detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
-    TL_EXPECTED_11_CONSTEXPR U &val()
-    {
-        return this->m_val;
-    }
-
-    TL_EXPECTED_11_CONSTEXPR unexpected<E> &err() { return this->m_unexpect; }
-
-    template<class U = T, detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
-    constexpr const U &val() const
-    {
-        return this->m_val;
-    }
-
-    constexpr const unexpected<E> &err() const { return this->m_unexpect; }
-
-    using impl_base = detail::expected_move_assign_base<T, E>;
-    using ctor_base = detail::expected_default_ctor_base<T, E>;
-
-public:
-    typedef T value_type;
-    typedef E error_type;
-    typedef unexpected<E> unexpected_type;
-
-#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) && !defined(TL_EXPECTED_GCC54)                           \
-    && !defined(TL_EXPECTED_GCC55)
-    template<class F>
-    TL_EXPECTED_11_CONSTEXPR auto and_then(F &&f) &
-    {
-        return and_then_impl(*this, std::forward<F>(f));
-    }
-
-    template<class F>
-    TL_EXPECTED_11_CONSTEXPR auto and_then(F &&f) &&
-    {
-        return and_then_impl(std::move(*this), std::forward<F>(f));
-    }
-
-    template<class F>
-    constexpr auto and_then(F &&f) const &
-    {
-        return and_then_impl(*this, std::forward<F>(f));
-    }
-
-#ifndef TL_EXPECTED_NO_CONSTRR
-    template<class F>
-    constexpr auto and_then(F &&f) const &&
-    {
-        return and_then_impl(std::move(*this), std::forward<F>(f));
-    }
+#if nsel_CPP17_OR_GREATER || nsel_COMPILER_MSVC_VERSION > 141
+template <typename E> using unexpected = unexpected_type<E>;
 #endif
 
-#else
-    template<class F>
-    TL_EXPECTED_11_CONSTEXPR auto
-    and_then(F &&f) & -> decltype(and_then_impl(std::declval<expected &>(), std::forward<F>(f)))
-    {
-        return and_then_impl(*this, std::forward<F>(f));
-    }
+} // namespace nonstd
 
-    template<class F>
-    TL_EXPECTED_11_CONSTEXPR auto
-    and_then(F &&f) && -> decltype(and_then_impl(std::declval<expected &&>(), std::forward<F>(f)))
-    {
-        return and_then_impl(std::move(*this), std::forward<F>(f));
-    }
+#undef nsel_REQUIRES
+#undef nsel_REQUIRES_0
+#undef nsel_REQUIRES_T
 
-    template<class F>
-    constexpr auto
-    and_then(F &&f) const & -> decltype(and_then_impl(std::declval<expected const &>(), std::forward<F>(f)))
-    {
-        return and_then_impl(*this, std::forward<F>(f));
-    }
+nsel_RESTORE_WARNINGS()
 
-#ifndef TL_EXPECTED_NO_CONSTRR
-    template<class F>
-    constexpr auto
-    and_then(F &&f) const && -> decltype(and_then_impl(std::declval<expected const &&>(), std::forward<F>(f)))
-    {
-        return and_then_impl(std::move(*this), std::forward<F>(f));
-    }
-#endif
-#endif
-
-#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) && !defined(TL_EXPECTED_GCC54)                           \
-    && !defined(TL_EXPECTED_GCC55)
-    template<class F>
-    TL_EXPECTED_11_CONSTEXPR auto map(F &&f) &
-    {
-        return expected_map_impl(*this, std::forward<F>(f));
-    }
-
-    template<class F>
-    TL_EXPECTED_11_CONSTEXPR auto map(F &&f) &&
-    {
-        return expected_map_impl(std::move(*this), std::forward<F>(f));
-    }
-
-    template<class F>
-    constexpr auto map(F &&f) const &
-    {
-        return expected_map_impl(*this, std::forward<F>(f));
-    }
-
-    template<class F>
-    constexpr auto map(F &&f) const &&
-    {
-        return expected_map_impl(std::move(*this), std::forward<F>(f));
-    }
-#else
-    template<class F>
-    TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl(std::declval<expected &>(), std::declval<F &&>())) map(F &&f) &
-    {
-        return expected_map_impl(*this, std::forward<F>(f));
-    }
-
-    template<class F>
-    TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl(std::declval<expected>(), std::declval<F &&>())) map(F &&f) &&
-    {
-        return expected_map_impl(std::move(*this), std::forward<F>(f));
-    }
-
-    template<class F>
-    constexpr decltype(expected_map_impl(std::declval<const expected &>(), std::declval<F &&>())) map(F &&f) const &
-    {
-        return expected_map_impl(*this, std::forward<F>(f));
-    }
-
-#ifndef TL_EXPECTED_NO_CONSTRR
-    template<class F>
-    constexpr decltype(expected_map_impl(std::declval<const expected &&>(), std::declval<F &&>())) map(F &&f) const &&
-    {
-        return expected_map_impl(std::move(*this), std::forward<F>(f));
-    }
-#endif
-#endif
-
-#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) && !defined(TL_EXPECTED_GCC54)                           \
-    && !defined(TL_EXPECTED_GCC55)
-    template<class F>
-    TL_EXPECTED_11_CONSTEXPR auto transform(F &&f) &
-    {
-        return expected_map_impl(*this, std::forward<F>(f));
-    }
-
-    template<class F>
-    TL_EXPECTED_11_CONSTEXPR auto transform(F &&f) &&
-    {
-        return expected_map_impl(std::move(*this), std::forward<F>(f));
-    }
-
-    template<class F>
-    constexpr auto transform(F &&f) const &
-    {
-        return expected_map_impl(*this, std::forward<F>(f));
-    }
-
-    template<class F>
-    constexpr auto transform(F &&f) const &&
-    {
-        return expected_map_impl(std::move(*this), std::forward<F>(f));
-    }
-#else
-    template<class F>
-    TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl(std::declval<expected &>(), std::declval<F &&>()))
-    transform(F &&f) &
-    {
-        return expected_map_impl(*this, std::forward<F>(f));
-    }
-
-    template<class F>
-    TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl(std::declval<expected>(), std::declval<F &&>()))
-    transform(F &&f) &&
-    {
-        return expected_map_impl(std::move(*this), std::forward<F>(f));
-    }
-
-    template<class F>
-    constexpr decltype(expected_map_impl(std::declval<const expected &>(), std::declval<F &&>()))
-    transform(F &&f) const &
-    {
-        return expected_map_impl(*this, std::forward<F>(f));
-    }
-
-#ifndef TL_EXPECTED_NO_CONSTRR
-    template<class F>
-    constexpr decltype(expected_map_impl(std::declval<const expected &&>(), std::declval<F &&>()))
-    transform(F &&f) const &&
-    {
-        return expected_map_impl(std::move(*this), std::forward<F>(f));
-    }
-#endif
-#endif
-
-#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) && !defined(TL_EXPECTED_GCC54)                           \
-    && !defined(TL_EXPECTED_GCC55)
-    template<class F>
-    TL_EXPECTED_11_CONSTEXPR auto map_error(F &&f) &
-    {
-        return map_error_impl(*this, std::forward<F>(f));
-    }
-
-    template<class F>
-    TL_EXPECTED_11_CONSTEXPR auto map_error(F &&f) &&
-    {
-        return map_error_impl(std::move(*this), std::forward<F>(f));
-    }
-
-    template<class F>
-    constexpr auto map_error(F &&f) const &
-    {
-        return map_error_impl(*this, std::forward<F>(f));
-    }
-
-    template<class F>
-    constexpr auto map_error(F &&f) const &&
-    {
-        return map_error_impl(std::move(*this), std::forward<F>(f));
-    }
-#else
-    template<class F>
-    TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &>(), std::declval<F &&>()))
-    map_error(F &&f) &
-    {
-        return map_error_impl(*this, std::forward<F>(f));
-    }
-
-    template<class F>
-    TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &&>(), std::declval<F &&>()))
-    map_error(F &&f) &&
-    {
-        return map_error_impl(std::move(*this), std::forward<F>(f));
-    }
-
-    template<class F>
-    constexpr decltype(map_error_impl(std::declval<const expected &>(), std::declval<F &&>())) map_error(F &&f) const &
-    {
-        return map_error_impl(*this, std::forward<F>(f));
-    }
-
-#ifndef TL_EXPECTED_NO_CONSTRR
-    template<class F>
-    constexpr decltype(map_error_impl(std::declval<const expected &&>(), std::declval<F &&>()))
-    map_error(F &&f) const &&
-    {
-        return map_error_impl(std::move(*this), std::forward<F>(f));
-    }
-#endif
-#endif
-#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) && !defined(TL_EXPECTED_GCC54)                           \
-    && !defined(TL_EXPECTED_GCC55)
-    template<class F>
-    TL_EXPECTED_11_CONSTEXPR auto transform_error(F &&f) &
-    {
-        return map_error_impl(*this, std::forward<F>(f));
-    }
-
-    template<class F>
-    TL_EXPECTED_11_CONSTEXPR auto transform_error(F &&f) &&
-    {
-        return map_error_impl(std::move(*this), std::forward<F>(f));
-    }
-
-    template<class F>
-    constexpr auto transform_error(F &&f) const &
-    {
-        return map_error_impl(*this, std::forward<F>(f));
-    }
-
-    template<class F>
-    constexpr auto transform_error(F &&f) const &&
-    {
-        return map_error_impl(std::move(*this), std::forward<F>(f));
-    }
-#else
-    template<class F>
-    TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &>(), std::declval<F &&>()))
-    transform_error(F &&f) &
-    {
-        return map_error_impl(*this, std::forward<F>(f));
-    }
-
-    template<class F>
-    TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &&>(), std::declval<F &&>()))
-    transform_error(F &&f) &&
-    {
-        return map_error_impl(std::move(*this), std::forward<F>(f));
-    }
-
-    template<class F>
-    constexpr decltype(map_error_impl(std::declval<const expected &>(), std::declval<F &&>()))
-    transform_error(F &&f) const &
-    {
-        return map_error_impl(*this, std::forward<F>(f));
-    }
-
-#ifndef TL_EXPECTED_NO_CONSTRR
-    template<class F>
-    constexpr decltype(map_error_impl(std::declval<const expected &&>(), std::declval<F &&>()))
-    transform_error(F &&f) const &&
-    {
-        return map_error_impl(std::move(*this), std::forward<F>(f));
-    }
-#endif
-#endif
-    template<class F>
-    expected TL_EXPECTED_11_CONSTEXPR or_else(F &&f) &
-    {
-        return or_else_impl(*this, std::forward<F>(f));
-    }
-
-    template<class F>
-    expected TL_EXPECTED_11_CONSTEXPR or_else(F &&f) &&
-    {
-        return or_else_impl(std::move(*this), std::forward<F>(f));
-    }
-
-    template<class F>
-    expected constexpr or_else(F &&f) const &
-    {
-        return or_else_impl(*this, std::forward<F>(f));
-    }
-
-#ifndef TL_EXPECTED_NO_CONSTRR
-    template<class F>
-    expected constexpr or_else(F &&f) const &&
-    {
-        return or_else_impl(std::move(*this), std::forward<F>(f));
-    }
-#endif
-    constexpr expected()                     = default;
-    constexpr expected(const expected &rhs)  = default;
-    constexpr expected(expected &&rhs)       = default;
-    expected &operator=(const expected &rhs) = default;
-    expected &operator=(expected &&rhs)      = default;
-
-    template<class... Args, detail::enable_if_t<std::is_constructible<T, Args &&...>::value> * = nullptr>
-    constexpr expected(in_place_t, Args &&...args)
-        : impl_base(in_place, std::forward<Args>(args)...),
-          ctor_base(detail::default_constructor_tag{})
-    {}
-
-    template<class U,
-             class... Args,
-             detail::enable_if_t<std::is_constructible<T, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
-    constexpr expected(in_place_t, std::initializer_list<U> il, Args &&...args)
-        : impl_base(in_place, il, std::forward<Args>(args)...),
-          ctor_base(detail::default_constructor_tag{})
-    {}
-
-    template<class G                                                           = E,
-             detail::enable_if_t<std::is_constructible<E, const G &>::value> * = nullptr,
-             detail::enable_if_t<!std::is_convertible<const G &, E>::value>  * = nullptr>
-    explicit constexpr expected(const unexpected<G> &e)
-        : impl_base(unexpect, e.value()),
-          ctor_base(detail::default_constructor_tag{})
-    {}
-
-    template<class G                                                           = E,
-             detail::enable_if_t<std::is_constructible<E, const G &>::value> * = nullptr,
-             detail::enable_if_t<std::is_convertible<const G &, E>::value>   * = nullptr>
-    constexpr expected(unexpected<G> const &e)
-        : impl_base(unexpect, e.value()),
-          ctor_base(detail::default_constructor_tag{})
-    {}
-
-    template<class G                                                      = E,
-             detail::enable_if_t<std::is_constructible<E, G &&>::value> * = nullptr,
-             detail::enable_if_t<!std::is_convertible<G &&, E>::value>  * = nullptr>
-    explicit constexpr expected(unexpected<G> &&e) noexcept(std::is_nothrow_constructible<E, G &&>::value)
-        : impl_base(unexpect, std::move(e.value())),
-          ctor_base(detail::default_constructor_tag{})
-    {}
-
-    template<class G                                                      = E,
-             detail::enable_if_t<std::is_constructible<E, G &&>::value> * = nullptr,
-             detail::enable_if_t<std::is_convertible<G &&, E>::value>   * = nullptr>
-    constexpr expected(unexpected<G> &&e) noexcept(std::is_nothrow_constructible<E, G &&>::value)
-        : impl_base(unexpect, std::move(e.value())),
-          ctor_base(detail::default_constructor_tag{})
-    {}
-
-    template<class... Args, detail::enable_if_t<std::is_constructible<E, Args &&...>::value> * = nullptr>
-    constexpr explicit expected(unexpect_t, Args &&...args)
-        : impl_base(unexpect, std::forward<Args>(args)...),
-          ctor_base(detail::default_constructor_tag{})
-    {}
-
-    template<class U,
-             class... Args,
-             detail::enable_if_t<std::is_constructible<E, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
-    constexpr explicit expected(unexpect_t, std::initializer_list<U> il, Args &&...args)
-        : impl_base(unexpect, il, std::forward<Args>(args)...),
-          ctor_base(detail::default_constructor_tag{})
-    {}
-
-    template<class U,
-             class G,
-             detail::enable_if_t<!(std::is_convertible<U const &, T>::value
-                                   && std::is_convertible<G const &, E>::value)>  * = nullptr,
-             detail::expected_enable_from_other<T, E, U, G, const U &, const G &> * = nullptr>
-    explicit TL_EXPECTED_11_CONSTEXPR expected(const expected<U, G> &rhs) : ctor_base(detail::default_constructor_tag{})
-    {
-        if (rhs.has_value()) {
-            this->construct(*rhs);
-        } else {
-            this->construct_error(rhs.error());
-        }
-    }
-
-    template<class U,
-             class G,
-             detail::enable_if_t<(std::is_convertible<U const &, T>::value && std::is_convertible<G const &, E>::value)>
-                                                                                  * = nullptr,
-             detail::expected_enable_from_other<T, E, U, G, const U &, const G &> * = nullptr>
-    TL_EXPECTED_11_CONSTEXPR expected(const expected<U, G> &rhs) : ctor_base(detail::default_constructor_tag{})
-    {
-        if (rhs.has_value()) {
-            this->construct(*rhs);
-        } else {
-            this->construct_error(rhs.error());
-        }
-    }
-
-    template<
-        class U,
-        class G,
-        detail::enable_if_t<!(std::is_convertible<U &&, T>::value && std::is_convertible<G &&, E>::value)> * = nullptr,
-        detail::expected_enable_from_other<T, E, U, G, U &&, G &&>                                         * = nullptr>
-    explicit TL_EXPECTED_11_CONSTEXPR expected(expected<U, G> &&rhs) : ctor_base(detail::default_constructor_tag{})
-    {
-        if (rhs.has_value()) {
-            this->construct(std::move(*rhs));
-        } else {
-            this->construct_error(std::move(rhs.error()));
-        }
-    }
-
-    template<
-        class U,
-        class G,
-        detail::enable_if_t<(std::is_convertible<U &&, T>::value && std::is_convertible<G &&, E>::value)> * = nullptr,
-        detail::expected_enable_from_other<T, E, U, G, U &&, G &&>                                        * = nullptr>
-    TL_EXPECTED_11_CONSTEXPR expected(expected<U, G> &&rhs) : ctor_base(detail::default_constructor_tag{})
-    {
-        if (rhs.has_value()) {
-            this->construct(std::move(*rhs));
-        } else {
-            this->construct_error(std::move(rhs.error()));
-        }
-    }
-
-    template<class U                                                     = T,
-             detail::enable_if_t<!std::is_convertible<U &&, T>::value> * = nullptr,
-             detail::expected_enable_forward_value<T, E, U>            * = nullptr>
-    explicit TL_EXPECTED_MSVC2015_CONSTEXPR expected(U &&v) : expected(in_place, std::forward<U>(v))
-    {}
-
-    template<class U                                                    = T,
-             detail::enable_if_t<std::is_convertible<U &&, T>::value> * = nullptr,
-             detail::expected_enable_forward_value<T, E, U>           * = nullptr>
-    TL_EXPECTED_MSVC2015_CONSTEXPR expected(U &&v) : expected(in_place, std::forward<U>(v))
-    {}
-
-    template<class U                                                                  = T,
-             class G                                                                  = T,
-             detail::enable_if_t<std::is_nothrow_constructible<T, U &&>::value>     * = nullptr,
-             detail::enable_if_t<!std::is_void<G>::value>                           * = nullptr,
-             detail::enable_if_t<(!std::is_same<expected<T, E>, detail::decay_t<U>>::value
-                                  && !detail::conjunction<std::is_scalar<T>, std::is_same<T, detail::decay_t<U>>>::value
-                                  && std::is_constructible<T, U>::value && std::is_assignable<G &, U>::value
-                                  && std::is_nothrow_move_constructible<E>::value)> * = nullptr>
-    expected &operator=(U &&v)
-    {
-        if (has_value()) {
-            val() = std::forward<U>(v);
-        } else {
-            err().~unexpected<E>();
-            ::new (valptr()) T(std::forward<U>(v));
-            this->m_has_val = true;
-        }
-
-        return *this;
-    }
-
-    template<class U                                                                  = T,
-             class G                                                                  = T,
-             detail::enable_if_t<!std::is_nothrow_constructible<T, U &&>::value>    * = nullptr,
-             detail::enable_if_t<!std::is_void<U>::value>                           * = nullptr,
-             detail::enable_if_t<(!std::is_same<expected<T, E>, detail::decay_t<U>>::value
-                                  && !detail::conjunction<std::is_scalar<T>, std::is_same<T, detail::decay_t<U>>>::value
-                                  && std::is_constructible<T, U>::value && std::is_assignable<G &, U>::value
-                                  && std::is_nothrow_move_constructible<E>::value)> * = nullptr>
-    expected &operator=(U &&v)
-    {
-        if (has_value()) {
-            val() = std::forward<U>(v);
-        } else {
-            auto tmp = std::move(err());
-            err().~unexpected<E>();
-
-#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED
-            try {
-                ::new (valptr()) T(std::forward<U>(v));
-                this->m_has_val = true;
-            } catch (...) {
-                err() = std::move(tmp);
-                throw;
-            }
-#else
-            ::new (valptr()) T(std::forward<U>(v));
-            this->m_has_val = true;
-#endif
-        }
-
-        return *this;
-    }
-
-    template<class G = E,
-             detail::enable_if_t<std::is_nothrow_copy_constructible<G>::value && std::is_assignable<G &, G>::value>
-                 * = nullptr>
-    expected &operator=(const unexpected<G> &rhs)
-    {
-        if (!has_value()) {
-            err() = rhs;
-        } else {
-            this->destroy_val();
-            ::new (errptr()) unexpected<E>(rhs);
-            this->m_has_val = false;
-        }
-
-        return *this;
-    }
-
-    template<class G = E,
-             detail::enable_if_t<std::is_nothrow_move_constructible<G>::value && std::is_move_assignable<G>::value>
-                 * = nullptr>
-    expected &operator=(unexpected<G> &&rhs) noexcept
-    {
-        if (!has_value()) {
-            err() = std::move(rhs);
-        } else {
-            this->destroy_val();
-            ::new (errptr()) unexpected<E>(std::move(rhs));
-            this->m_has_val = false;
-        }
-
-        return *this;
-    }
-
-    template<class... Args, detail::enable_if_t<std::is_nothrow_constructible<T, Args &&...>::value> * = nullptr>
-    void emplace(Args &&...args)
-    {
-        if (has_value()) {
-            val().~T();
-        } else {
-            err().~unexpected<E>();
-            this->m_has_val = true;
-        }
-        ::new (valptr()) T(std::forward<Args>(args)...);
-    }
-
-    template<class... Args, detail::enable_if_t<!std::is_nothrow_constructible<T, Args &&...>::value> * = nullptr>
-    void emplace(Args &&...args)
-    {
-        if (has_value()) {
-            val().~T();
-            ::new (valptr()) T(std::forward<Args>(args)...);
-        } else {
-            auto tmp = std::move(err());
-            err().~unexpected<E>();
-
-#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED
-            try {
-                ::new (valptr()) T(std::forward<Args>(args)...);
-                this->m_has_val = true;
-            } catch (...) {
-                err() = std::move(tmp);
-                throw;
-            }
-#else
-            ::new (valptr()) T(std::forward<Args>(args)...);
-            this->m_has_val = true;
-#endif
-        }
-    }
-
-    template<class U,
-             class... Args,
-             detail::enable_if_t<std::is_nothrow_constructible<T, std::initializer_list<U> &, Args &&...>::value>
-                 * = nullptr>
-    void emplace(std::initializer_list<U> il, Args &&...args)
-    {
-        if (has_value()) {
-            T t(il, std::forward<Args>(args)...);
-            val() = std::move(t);
-        } else {
-            err().~unexpected<E>();
-            ::new (valptr()) T(il, std::forward<Args>(args)...);
-            this->m_has_val = true;
-        }
-    }
-
-    template<class U,
-             class... Args,
-             detail::enable_if_t<!std::is_nothrow_constructible<T, std::initializer_list<U> &, Args &&...>::value>
-                 * = nullptr>
-    void emplace(std::initializer_list<U> il, Args &&...args)
-    {
-        if (has_value()) {
-            T t(il, std::forward<Args>(args)...);
-            val() = std::move(t);
-        } else {
-            auto tmp = std::move(err());
-            err().~unexpected<E>();
-
-#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED
-            try {
-                ::new (valptr()) T(il, std::forward<Args>(args)...);
-                this->m_has_val = true;
-            } catch (...) {
-                err() = std::move(tmp);
-                throw;
-            }
-#else
-            ::new (valptr()) T(il, std::forward<Args>(args)...);
-            this->m_has_val = true;
-#endif
-        }
-    }
-
-private:
-    using t_is_void                       = std::true_type;
-    using t_is_not_void                   = std::false_type;
-    using t_is_nothrow_move_constructible = std::true_type;
-    using move_constructing_t_can_throw   = std::false_type;
-    using e_is_nothrow_move_constructible = std::true_type;
-    using move_constructing_e_can_throw   = std::false_type;
-
-    void swap_where_both_have_value(expected & /*rhs*/, t_is_void) noexcept
-    {
-        // swapping void is a no-op
-    }
-
-    void swap_where_both_have_value(expected &rhs, t_is_not_void)
-    {
-        using std::swap;
-        swap(val(), rhs.val());
-    }
-
-    void swap_where_only_one_has_value(expected &rhs, t_is_void) noexcept(std::is_nothrow_move_constructible<E>::value)
-    {
-        ::new (errptr()) unexpected_type(std::move(rhs.err()));
-        rhs.err().~unexpected_type();
-        std::swap(this->m_has_val, rhs.m_has_val);
-    }
-
-    void swap_where_only_one_has_value(expected &rhs, t_is_not_void)
-    {
-        swap_where_only_one_has_value_and_t_is_not_void(
-            rhs,
-            typename std::is_nothrow_move_constructible<T>::type{},
-            typename std::is_nothrow_move_constructible<E>::type{});
-    }
-
-    void swap_where_only_one_has_value_and_t_is_not_void(expected &rhs,
-                                                         t_is_nothrow_move_constructible,
-                                                         e_is_nothrow_move_constructible) noexcept
-    {
-        auto temp = std::move(val());
-        val().~T();
-        ::new (errptr()) unexpected_type(std::move(rhs.err()));
-        rhs.err().~unexpected_type();
-        ::new (rhs.valptr()) T(std::move(temp));
-        std::swap(this->m_has_val, rhs.m_has_val);
-    }
-
-    void swap_where_only_one_has_value_and_t_is_not_void(expected &rhs,
-                                                         t_is_nothrow_move_constructible,
-                                                         move_constructing_e_can_throw)
-    {
-        auto temp = std::move(val());
-        val().~T();
-#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED
-        try {
-            ::new (errptr()) unexpected_type(std::move(rhs.err()));
-            rhs.err().~unexpected_type();
-            ::new (rhs.valptr()) T(std::move(temp));
-            std::swap(this->m_has_val, rhs.m_has_val);
-        } catch (...) {
-            val() = std::move(temp);
-            throw;
-        }
-#else
-        ::new (errptr()) unexpected_type(std::move(rhs.err()));
-        rhs.err().~unexpected_type();
-        ::new (rhs.valptr()) T(std::move(temp));
-        std::swap(this->m_has_val, rhs.m_has_val);
-#endif
-    }
-
-    void swap_where_only_one_has_value_and_t_is_not_void(expected &rhs,
-                                                         move_constructing_t_can_throw,
-                                                         e_is_nothrow_move_constructible)
-    {
-        auto temp = std::move(rhs.err());
-        rhs.err().~unexpected_type();
-#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED
-        try {
-            ::new (rhs.valptr()) T(std::move(val()));
-            val().~T();
-            ::new (errptr()) unexpected_type(std::move(temp));
-            std::swap(this->m_has_val, rhs.m_has_val);
-        } catch (...) {
-            rhs.err() = std::move(temp);
-            throw;
-        }
-#else
-        ::new (rhs.valptr()) T(std::move(val()));
-        val().~T();
-        ::new (errptr()) unexpected_type(std::move(temp));
-        std::swap(this->m_has_val, rhs.m_has_val);
-#endif
-    }
-
-public:
-    template<class OT = T, class OE = E>
-    detail::enable_if_t<detail::is_swappable<OT>::value && detail::is_swappable<OE>::value
-                        && (std::is_nothrow_move_constructible<OT>::value
-                            || std::is_nothrow_move_constructible<OE>::value)>
-    swap(expected &rhs) noexcept(std::is_nothrow_move_constructible<T>::value && detail::is_nothrow_swappable<T>::value
-                                 && std::is_nothrow_move_constructible<E>::value
-                                 && detail::is_nothrow_swappable<E>::value)
-    {
-        if (has_value() && rhs.has_value()) {
-            swap_where_both_have_value(rhs, typename std::is_void<T>::type{});
-        } else if (!has_value() && rhs.has_value()) {
-            rhs.swap(*this);
-        } else if (has_value()) {
-            swap_where_only_one_has_value(rhs, typename std::is_void<T>::type{});
-        } else {
-            using std::swap;
-            swap(err(), rhs.err());
-        }
-    }
-
-    constexpr const T *operator->() const
-    {
-        TL_ASSERT(has_value());
-        return valptr();
-    }
-
-    TL_EXPECTED_11_CONSTEXPR T *operator->()
-    {
-        TL_ASSERT(has_value());
-        return valptr();
-    }
-
-    template<class U = T, detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
-    constexpr const U &operator*() const &
-    {
-        TL_ASSERT(has_value());
-        return val();
-    }
-
-    template<class U = T, detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
-    TL_EXPECTED_11_CONSTEXPR U &operator*() &
-    {
-        TL_ASSERT(has_value());
-        return val();
-    }
-
-    template<class U = T, detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
-    constexpr const U &&operator*() const &&
-    {
-        TL_ASSERT(has_value());
-        return std::move(val());
-    }
-
-    template<class U = T, detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
-    TL_EXPECTED_11_CONSTEXPR U &&operator*() &&
-    {
-        TL_ASSERT(has_value());
-        return std::move(val());
-    }
-
-    constexpr bool has_value() const noexcept { return this->m_has_val; }
-
-    constexpr explicit operator bool() const noexcept { return this->m_has_val; }
-
-    template<class U = T, detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
-    TL_EXPECTED_11_CONSTEXPR const U &value() const &
-    {
-        if (!has_value()) detail::throw_exception(bad_expected_access<E>(err().value()));
-        return val();
-    }
-
-    template<class U = T, detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
-    TL_EXPECTED_11_CONSTEXPR U &value() &
-    {
-        if (!has_value()) detail::throw_exception(bad_expected_access<E>(err().value()));
-        return val();
-    }
-
-    template<class U = T, detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
-    TL_EXPECTED_11_CONSTEXPR const U &&value() const &&
-    {
-        if (!has_value()) detail::throw_exception(bad_expected_access<E>(std::move(err()).value()));
-        return std::move(val());
-    }
-
-    template<class U = T, detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
-    TL_EXPECTED_11_CONSTEXPR U &&value() &&
-    {
-        if (!has_value()) detail::throw_exception(bad_expected_access<E>(std::move(err()).value()));
-        return std::move(val());
-    }
-
-    constexpr const E &error() const &
-    {
-        TL_ASSERT(!has_value());
-        return err().value();
-    }
-
-    TL_EXPECTED_11_CONSTEXPR E &error() &
-    {
-        TL_ASSERT(!has_value());
-        return err().value();
-    }
-
-    constexpr const E &&error() const &&
-    {
-        TL_ASSERT(!has_value());
-        return std::move(err().value());
-    }
-
-    TL_EXPECTED_11_CONSTEXPR E &&error() &&
-    {
-        TL_ASSERT(!has_value());
-        return std::move(err().value());
-    }
-
-    template<class U>
-    constexpr T value_or(U &&v) const &
-    {
-        static_assert(std::is_copy_constructible<T>::value && std::is_convertible<U &&, T>::value,
-                      "T must be copy-constructible and convertible to from U&&");
-        return bool(*this) ? **this : static_cast<T>(std::forward<U>(v));
-    }
-
-    template<class U>
-    TL_EXPECTED_11_CONSTEXPR T value_or(U &&v) &&
-    {
-        static_assert(std::is_move_constructible<T>::value && std::is_convertible<U &&, T>::value,
-                      "T must be move-constructible and convertible to from U&&");
-        return bool(*this) ? std::move(**this) : static_cast<T>(std::forward<U>(v));
-    }
-};
-
-namespace detail {
-template<class Exp>
-using exp_t = typename detail::decay_t<Exp>::value_type;
-template<class Exp>
-using err_t = typename detail::decay_t<Exp>::error_type;
-template<class Exp, class Ret>
-using ret_t = expected<Ret, err_t<Exp>>;
-
-#ifdef TL_EXPECTED_CXX14
-template<class Exp,
-         class F,
-         detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
-         class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Exp>()))>
-constexpr auto
-and_then_impl(Exp &&exp, F &&f)
-{
-    static_assert(detail::is_expected<Ret>::value, "F must return an expected");
-
-    return exp.has_value() ? detail::invoke(std::forward<F>(f), *std::forward<Exp>(exp))
-                           : Ret(unexpect, std::forward<Exp>(exp).error());
+#endif // nsel_USES_STD_EXPECTED
+namespace std {
+using namespace nonstd;
 }
 
-template<class Exp,
-         class F,
-         detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
-         class Ret                                              = decltype(detail::invoke(std::declval<F>()))>
-constexpr auto
-and_then_impl(Exp &&exp, F &&f)
-{
-    static_assert(detail::is_expected<Ret>::value, "F must return an expected");
-
-    return exp.has_value() ? detail::invoke(std::forward<F>(f)) : Ret(unexpect, std::forward<Exp>(exp).error());
-}
-#else
-template<class>
-struct TC;
-
-template<class Exp,
-         class F,
-         class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Exp>())),
-         detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr>
-auto
-and_then_impl(Exp &&exp, F &&f) -> Ret
-{
-    static_assert(detail::is_expected<Ret>::value, "F must return an expected");
-
-    return exp.has_value() ? detail::invoke(std::forward<F>(f), *std::forward<Exp>(exp))
-                           : Ret(unexpect, std::forward<Exp>(exp).error());
-}
-
-template<class Exp,
-         class F,
-         class Ret                                              = decltype(detail::invoke(std::declval<F>())),
-         detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr>
-constexpr auto
-and_then_impl(Exp &&exp, F &&f) -> Ret
-{
-    static_assert(detail::is_expected<Ret>::value, "F must return an expected");
-
-    return exp.has_value() ? detail::invoke(std::forward<F>(f)) : Ret(unexpect, std::forward<Exp>(exp).error());
-}
-#endif
-
-#ifdef TL_EXPECTED_CXX14
-template<class Exp,
-         class F,
-         detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
-         class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Exp>())),
-         detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-constexpr auto
-expected_map_impl(Exp &&exp, F &&f)
-{
-    using result = ret_t<Exp, detail::decay_t<Ret>>;
-    return exp.has_value() ? result(detail::invoke(std::forward<F>(f), *std::forward<Exp>(exp)))
-                           : result(unexpect, std::forward<Exp>(exp).error());
-}
-
-template<class Exp,
-         class F,
-         detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
-         class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Exp>())),
-         detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-auto
-expected_map_impl(Exp &&exp, F &&f)
-{
-    using result = expected<void, err_t<Exp>>;
-    if (exp.has_value()) {
-        detail::invoke(std::forward<F>(f), *std::forward<Exp>(exp));
-        return result();
-    }
-
-    return result(unexpect, std::forward<Exp>(exp).error());
-}
-
-template<class Exp,
-         class F,
-         detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
-         class Ret                                              = decltype(detail::invoke(std::declval<F>())),
-         detail::enable_if_t<!std::is_void<Ret>::value>       * = nullptr>
-constexpr auto
-expected_map_impl(Exp &&exp, F &&f)
-{
-    using result = ret_t<Exp, detail::decay_t<Ret>>;
-    return exp.has_value() ? result(detail::invoke(std::forward<F>(f)))
-                           : result(unexpect, std::forward<Exp>(exp).error());
-}
-
-template<class Exp,
-         class F,
-         detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
-         class Ret                                              = decltype(detail::invoke(std::declval<F>())),
-         detail::enable_if_t<std::is_void<Ret>::value>        * = nullptr>
-auto
-expected_map_impl(Exp &&exp, F &&f)
-{
-    using result = expected<void, err_t<Exp>>;
-    if (exp.has_value()) {
-        detail::invoke(std::forward<F>(f));
-        return result();
-    }
-
-    return result(unexpect, std::forward<Exp>(exp).error());
-}
-#else
-template<class Exp,
-         class F,
-         detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
-         class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Exp>())),
-         detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-
-constexpr auto
-expected_map_impl(Exp &&exp, F &&f) -> ret_t<Exp, detail::decay_t<Ret>>
-{
-    using result = ret_t<Exp, detail::decay_t<Ret>>;
-
-    return exp.has_value() ? result(detail::invoke(std::forward<F>(f), *std::forward<Exp>(exp)))
-                           : result(unexpect, std::forward<Exp>(exp).error());
-}
-
-template<class Exp,
-         class F,
-         detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
-         class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Exp>())),
-         detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-
-auto
-expected_map_impl(Exp &&exp, F &&f) -> expected<void, err_t<Exp>>
-{
-    if (exp.has_value()) {
-        detail::invoke(std::forward<F>(f), *std::forward<Exp>(exp));
-        return {};
-    }
-
-    return unexpected<err_t<Exp>>(std::forward<Exp>(exp).error());
-}
-
-template<class Exp,
-         class F,
-         detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
-         class Ret                                              = decltype(detail::invoke(std::declval<F>())),
-         detail::enable_if_t<!std::is_void<Ret>::value>       * = nullptr>
-
-constexpr auto
-expected_map_impl(Exp &&exp, F &&f) -> ret_t<Exp, detail::decay_t<Ret>>
-{
-    using result = ret_t<Exp, detail::decay_t<Ret>>;
-
-    return exp.has_value() ? result(detail::invoke(std::forward<F>(f)))
-                           : result(unexpect, std::forward<Exp>(exp).error());
-}
-
-template<class Exp,
-         class F,
-         detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
-         class Ret                                              = decltype(detail::invoke(std::declval<F>())),
-         detail::enable_if_t<std::is_void<Ret>::value>        * = nullptr>
-
-auto
-expected_map_impl(Exp &&exp, F &&f) -> expected<void, err_t<Exp>>
-{
-    if (exp.has_value()) {
-        detail::invoke(std::forward<F>(f));
-        return {};
-    }
-
-    return unexpected<err_t<Exp>>(std::forward<Exp>(exp).error());
-}
-#endif
-
-#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) && !defined(TL_EXPECTED_GCC54)                           \
-    && !defined(TL_EXPECTED_GCC55)
-template<class Exp,
-         class F,
-         detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
-         class Ret = decltype(detail::invoke(std::declval<F>(), std::declval<Exp>().error())),
-         detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-constexpr auto
-map_error_impl(Exp &&exp, F &&f)
-{
-    using result = expected<exp_t<Exp>, detail::decay_t<Ret>>;
-    return exp.has_value() ? result(*std::forward<Exp>(exp))
-                           : result(unexpect, detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error()));
-}
-
-template<class Exp,
-         class F,
-         detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
-         class Ret = decltype(detail::invoke(std::declval<F>(), std::declval<Exp>().error())),
-         detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-auto
-map_error_impl(Exp &&exp, F &&f)
-{
-    using result = expected<exp_t<Exp>, monostate>;
-    if (exp.has_value()) { return result(*std::forward<Exp>(exp)); }
-
-    detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error());
-    return result(unexpect, monostate{});
-}
-
-template<class Exp,
-         class F,
-         detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
-         class Ret = decltype(detail::invoke(std::declval<F>(), std::declval<Exp>().error())),
-         detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-constexpr auto
-map_error_impl(Exp &&exp, F &&f)
-{
-    using result = expected<exp_t<Exp>, detail::decay_t<Ret>>;
-    return exp.has_value() ? result()
-                           : result(unexpect, detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error()));
-}
-
-template<class Exp,
-         class F,
-         detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
-         class Ret = decltype(detail::invoke(std::declval<F>(), std::declval<Exp>().error())),
-         detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-auto
-map_error_impl(Exp &&exp, F &&f)
-{
-    using result = expected<exp_t<Exp>, monostate>;
-    if (exp.has_value()) { return result(); }
-
-    detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error());
-    return result(unexpect, monostate{});
-}
-#else
-template<class Exp,
-         class F,
-         detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
-         class Ret = decltype(detail::invoke(std::declval<F>(), std::declval<Exp>().error())),
-         detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-constexpr auto
-map_error_impl(Exp &&exp, F &&f) -> expected<exp_t<Exp>, detail::decay_t<Ret>>
-{
-    using result = expected<exp_t<Exp>, detail::decay_t<Ret>>;
-
-    return exp.has_value() ? result(*std::forward<Exp>(exp))
-                           : result(unexpect, detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error()));
-}
-
-template<class Exp,
-         class F,
-         detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
-         class Ret = decltype(detail::invoke(std::declval<F>(), std::declval<Exp>().error())),
-         detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-auto
-map_error_impl(Exp &&exp, F &&f) -> expected<exp_t<Exp>, monostate>
-{
-    using result = expected<exp_t<Exp>, monostate>;
-    if (exp.has_value()) { return result(*std::forward<Exp>(exp)); }
-
-    detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error());
-    return result(unexpect, monostate{});
-}
-
-template<class Exp,
-         class F,
-         detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
-         class Ret = decltype(detail::invoke(std::declval<F>(), std::declval<Exp>().error())),
-         detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-constexpr auto
-map_error_impl(Exp &&exp, F &&f) -> expected<exp_t<Exp>, detail::decay_t<Ret>>
-{
-    using result = expected<exp_t<Exp>, detail::decay_t<Ret>>;
-
-    return exp.has_value() ? result()
-                           : result(unexpect, detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error()));
-}
-
-template<class Exp,
-         class F,
-         detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
-         class Ret = decltype(detail::invoke(std::declval<F>(), std::declval<Exp>().error())),
-         detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-auto
-map_error_impl(Exp &&exp, F &&f) -> expected<exp_t<Exp>, monostate>
-{
-    using result = expected<exp_t<Exp>, monostate>;
-    if (exp.has_value()) { return result(); }
-
-    detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error());
-    return result(unexpect, monostate{});
-}
-#endif
-
-#ifdef TL_EXPECTED_CXX14
-template<class Exp,
-         class F,
-         class Ret = decltype(detail::invoke(std::declval<F>(), std::declval<Exp>().error())),
-         detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-constexpr auto
-or_else_impl(Exp &&exp, F &&f)
-{
-    static_assert(detail::is_expected<Ret>::value, "F must return an expected");
-    return exp.has_value() ? std::forward<Exp>(exp)
-                           : detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error());
-}
-
-template<class Exp,
-         class F,
-         class Ret = decltype(detail::invoke(std::declval<F>(), std::declval<Exp>().error())),
-         detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-detail::decay_t<Exp>
-or_else_impl(Exp &&exp, F &&f)
-{
-    return exp.has_value()
-               ? std::forward<Exp>(exp)
-               : (detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error()), std::forward<Exp>(exp));
-}
-#else
-template<class Exp,
-         class F,
-         class Ret = decltype(detail::invoke(std::declval<F>(), std::declval<Exp>().error())),
-         detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
-auto
-or_else_impl(Exp &&exp, F &&f) -> Ret
-{
-    static_assert(detail::is_expected<Ret>::value, "F must return an expected");
-    return exp.has_value() ? std::forward<Exp>(exp)
-                           : detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error());
-}
-
-template<class Exp,
-         class F,
-         class Ret = decltype(detail::invoke(std::declval<F>(), std::declval<Exp>().error())),
-         detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
-detail::decay_t<Exp>
-or_else_impl(Exp &&exp, F &&f)
-{
-    return exp.has_value()
-               ? std::forward<Exp>(exp)
-               : (detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error()), std::forward<Exp>(exp));
-}
-#endif
-}// namespace detail
-
-template<class T, class E, class U, class F>
-constexpr bool
-operator==(const expected<T, E> &lhs, const expected<U, F> &rhs)
-{
-    return (lhs.has_value() != rhs.has_value()) ? false
-                                                : (!lhs.has_value() ? lhs.error() == rhs.error() : *lhs == *rhs);
-}
-
-template<class T, class E, class U, class F>
-constexpr bool
-operator!=(const expected<T, E> &lhs, const expected<U, F> &rhs)
-{
-    return (lhs.has_value() != rhs.has_value()) ? true : (!lhs.has_value() ? lhs.error() != rhs.error() : *lhs != *rhs);
-}
-
-template<class E, class F>
-constexpr bool
-operator==(const expected<void, E> &lhs, const expected<void, F> &rhs)
-{
-    return (lhs.has_value() != rhs.has_value()) ? false : (!lhs.has_value() ? lhs.error() == rhs.error() : true);
-}
-
-template<class E, class F>
-constexpr bool
-operator!=(const expected<void, E> &lhs, const expected<void, F> &rhs)
-{
-    return (lhs.has_value() != rhs.has_value()) ? true : (!lhs.has_value() ? lhs.error() == rhs.error() : false);
-}
-
-template<class T, class E, class U>
-constexpr bool
-operator==(const expected<T, E> &x, const U &v)
-{
-    return x.has_value() ? *x == v : false;
-}
-
-template<class T, class E, class U>
-constexpr bool
-operator==(const U &v, const expected<T, E> &x)
-{
-    return x.has_value() ? *x == v : false;
-}
-
-template<class T, class E, class U>
-constexpr bool
-operator!=(const expected<T, E> &x, const U &v)
-{
-    return x.has_value() ? *x != v : true;
-}
-
-template<class T, class E, class U>
-constexpr bool
-operator!=(const U &v, const expected<T, E> &x)
-{
-    return x.has_value() ? *x != v : true;
-}
-
-template<class T, class E>
-constexpr bool
-operator==(const expected<T, E> &x, const unexpected<E> &e)
-{
-    return x.has_value() ? false : x.error() == e.value();
-}
-
-template<class T, class E>
-constexpr bool
-operator==(const unexpected<E> &e, const expected<T, E> &x)
-{
-    return x.has_value() ? false : x.error() == e.value();
-}
-
-template<class T, class E>
-constexpr bool
-operator!=(const expected<T, E> &x, const unexpected<E> &e)
-{
-    return x.has_value() ? true : x.error() != e.value();
-}
-
-template<class T, class E>
-constexpr bool
-operator!=(const unexpected<E> &e, const expected<T, E> &x)
-{
-    return x.has_value() ? true : x.error() != e.value();
-}
-
-template<class T,
-         class E,
-         detail::enable_if_t<(std::is_void<T>::value || std::is_move_constructible<T>::value)
-                             && detail::is_swappable<T>::value && std::is_move_constructible<E>::value
-                             && detail::is_swappable<E>::value> * = nullptr>
-void
-swap(expected<T, E> &lhs, expected<T, E> &rhs) noexcept(noexcept(lhs.swap(rhs)))
-{
-    lhs.swap(rhs);
-}
-}// namespace tl
-
-namespace sled {
-using namespace tl;
-}
-
-#endif
+#endif // NONSTD_EXPECTED_LITE_HPP
diff --git a/src/sled/operations_chain.h b/src/sled/operations_chain.h
index 7a80e6d..3db7029 100644
--- a/src/sled/operations_chain.h
+++ b/src/sled/operations_chain.h
@@ -38,7 +38,7 @@ public:
 
     void Run() override
     {
-        has_run_ = true;
+        has_run_     = true;
         auto functor = std::move(functor_);
         functor(std::move(callback_));
     }
@@ -54,7 +54,7 @@ class OperationsChain final : public RefCountedNonVirtual<OperationsChain> {
 public:
     static scoped_refptr<OperationsChain> Create();
     ~OperationsChain();
-    OperationsChain(const OperationsChain &) = delete;
+    OperationsChain(const OperationsChain &)           = delete;
     OperationsChain operator=(const OperationsChain &) = delete;
 
     void SetOnChainEmptyCallback(std::function<void()> on_chain_empty_callback);
@@ -79,7 +79,7 @@ private:
         explicit CallbackHandle(scoped_refptr<OperationsChain> operations_chain);
         ~CallbackHandle();
 
-        CallbackHandle(const CallbackHandle &) = delete;
+        CallbackHandle(const CallbackHandle &)            = delete;
         CallbackHandle &operator=(const CallbackHandle &) = delete;
         void OnOperationComplete();
 
@@ -93,7 +93,7 @@ private:
     void OnOperationComplete();
 
     std::queue<std::unique_ptr<internal::Operation>> chained_operations_;
-    sled::optional<std::function<void()>> on_chain_empty_callback_;
+    tl::optional<std::function<void()>> on_chain_empty_callback_;
 };
 
 }// namespace sled
diff --git a/src/sled/optional.h b/src/sled/optional.h
index 1419fed..4e593fd 100644
--- a/src/sled/optional.h
+++ b/src/sled/optional.h
@@ -2178,6 +2178,12 @@ struct hash<tl::optional<T>> {
 };
 }// namespace std
 
+#endif
+
+#ifndef SLED_OPTIONAL_H
+#define SLED_OPTIONAL_H
+
+// TODO: Remove this
 namespace sled {
 using namespace tl;
 }
diff --git a/src/sled/status_or.h b/src/sled/status_or.h
index 207e314..e8256d0 100644
--- a/src/sled/status_or.h
+++ b/src/sled/status_or.h
@@ -143,7 +143,7 @@ private:
     }
 
     Status status_;
-    sled::optional<T> value_;
+    tl::optional<T> value_;
 };
 
 template<typename T>
diff --git a/src/sled/system/hot_reloader.cc b/src/sled/system/hot_reloader.cc
index 85f7528..c71eb52 100644
--- a/src/sled/system/hot_reloader.cc
+++ b/src/sled/system/hot_reloader.cc
@@ -66,9 +66,9 @@ public:
         return false;
     }
 
-    sled::optional<Failure> Update(bool force_reload)
+    tl::optional<Failure> Update(bool force_reload)
     {
-        if (cr_plugin_update(ctx_, force_reload) == 0) { return sled::nullopt; }
+        if (cr_plugin_update(ctx_, force_reload) == 0) { return tl::nullopt; }
         return detail::TranslateFailure(ctx_.failure);
     }
 
@@ -97,7 +97,7 @@ HotReloader::Initialize()
     return impl_->Initialize();
 }
 
-sled::optional<HotReloader::Failure>
+tl::optional<HotReloader::Failure>
 HotReloader::UpdateOrError(bool force_reload)
 {
     return impl_->Update(force_reload);
diff --git a/src/sled/system/hot_reloader.h b/src/sled/system/hot_reloader.h
index e3433e0..9ef2127 100644
--- a/src/sled/system/hot_reloader.h
+++ b/src/sled/system/hot_reloader.h
@@ -76,7 +76,7 @@ public:
      * @force_reload: 如果当前库已经加载，是否reload当前库
      * @ status: 如果不为nullptr，返回当前加载状态
     **/
-    sled::optional<Failure> UpdateOrError(bool force_reload = true);
+    tl::optional<Failure> UpdateOrError(bool force_reload = true);
     // bool Rollback();
 
     void set_userdata(void *data);
diff --git a/src/sled/variant.h b/src/sled/variant.h
index bed846d..990a44c 100644
--- a/src/sled/variant.h
+++ b/src/sled/variant.h
@@ -5,9 +5,8 @@
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
 
-#pragma once
-#ifndef SLED_MPARK_VARIANT_HPP
-#define SLED_MPARK_VARIANT_HPP
+#ifndef MPARK_VARIANT_HPP
+#define MPARK_VARIANT_HPP
 
 /*
    variant synopsis
@@ -242,8 +241,8 @@ namespace std {
 #define MPARK_ALWAYS_INLINE inline
 #endif
 
-#if __has_builtin(__builtin_addressof) || (defined(__GNUC__) && __GNUC__ >= 7) \
-    || defined(_MSC_VER)
+#if __has_builtin(__builtin_addressof) || \
+    (defined(__GNUC__) && __GNUC__ >= 7) || defined(_MSC_VER)
 #define MPARK_BUILTIN_ADDRESSOF
 #endif
 
@@ -259,8 +258,8 @@ namespace std {
 #define MPARK_TYPE_PACK_ELEMENT
 #endif
 
-#if defined(__cpp_constexpr) && __cpp_constexpr >= 200704                      \
-    && !(defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 9)
+#if defined(__cpp_constexpr) && __cpp_constexpr >= 200704 && \
+    !(defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 9)
 #define MPARK_CPP11_CONSTEXPR
 #endif
 
@@ -268,8 +267,8 @@ namespace std {
 #define MPARK_CPP14_CONSTEXPR
 #endif
 
-#if __has_feature(cxx_exceptions) || defined(__cpp_exceptions)                 \
-    || (defined(_MSC_VER) && defined(_CPPUNWIND))
+#if __has_feature(cxx_exceptions) || defined(__cpp_exceptions) || \
+    (defined(_MSC_VER) && defined(_CPPUNWIND))
 #define MPARK_EXCEPTIONS
 #endif
 
@@ -293,12 +292,12 @@ namespace std {
 #define MPARK_VARIABLE_TEMPLATES
 #endif
 
-#if !defined(__GLIBCXX__) || __has_include(<codecvt>)// >= libstdc++-5
+#if !defined(__GLIBCXX__) || __has_include(<codecvt>)  // >= libstdc++-5
 #define MPARK_TRIVIALITY_TYPE_TRAITS
 #define MPARK_INCOMPLETE_TYPE_TRAITS
 #endif
 
-#endif// MPARK_CONFIG_HPP
+#endif  // MPARK_CONFIG_HPP
 
 // MPark.Variant
 //
@@ -312,35 +311,28 @@ namespace std {
 
 #include <cstddef>
 
+
 namespace mpark {
 
-struct in_place_t {
-    explicit in_place_t() = default;
-};
+  struct in_place_t { explicit in_place_t() = default; };
 
-template<std::size_t I>
-struct in_place_index_t {
-    explicit in_place_index_t() = default;
-};
+  template <std::size_t I>
+  struct in_place_index_t { explicit in_place_index_t() = default; };
 
-template<typename T>
-struct in_place_type_t {
-    explicit in_place_type_t() = default;
-};
+  template <typename T>
+  struct in_place_type_t { explicit in_place_type_t() = default; };
 
 #ifdef MPARK_VARIABLE_TEMPLATES
-constexpr in_place_t in_place{};
+  constexpr in_place_t in_place{};
 
-template<std::size_t I>
-constexpr in_place_index_t<I> in_place_index{};
+  template <std::size_t I> constexpr in_place_index_t<I> in_place_index{};
 
-template<typename T>
-constexpr in_place_type_t<T> in_place_type{};
+  template <typename T> constexpr in_place_type_t<T> in_place_type{};
 #endif
 
-}// namespace mpark
+}  // namespace mpark
 
-#endif// MPARK_IN_PLACE_HPP
+#endif  // MPARK_IN_PLACE_HPP
 
 // MPark.Variant
 //
@@ -352,930 +344,883 @@ constexpr in_place_type_t<T> in_place_type{};
 #ifndef MPARK_LIB_HPP
 #define MPARK_LIB_HPP
 
-#include <functional>
 #include <memory>
+#include <functional>
 #include <type_traits>
 #include <utility>
 
-#define MPARK_RETURN(...)                                                      \
-    noexcept(noexcept(__VA_ARGS__))->decltype(__VA_ARGS__)                     \
-    {                                                                          \
-        return __VA_ARGS__;                                                    \
-    }
+
+#define MPARK_RETURN(...) \
+  noexcept(noexcept(__VA_ARGS__)) -> decltype(__VA_ARGS__) { return __VA_ARGS__; }
 
 namespace mpark {
-namespace lib {
-template<typename T>
-struct identity {
-    using type = T;
-};
+  namespace lib {
+    template <typename T>
+    struct identity { using type = T; };
 
-inline namespace cpp14 {
-template<typename T, std::size_t N>
-struct array {
-    constexpr const T &operator[](std::size_t index) const
-    {
-        return data[index];
-    }
+    inline namespace cpp14 {
+      template <typename T, std::size_t N>
+      struct array {
+        constexpr const T &operator[](std::size_t index) const {
+          return data[index];
+        }
 
-    T data[N == 0 ? 1 : N];
-};
+        T data[N == 0 ? 1 : N];
+      };
 
-template<typename T>
-using add_pointer_t = typename std::add_pointer<T>::type;
+      template <typename T>
+      using add_pointer_t = typename std::add_pointer<T>::type;
 
-template<typename... Ts>
-using common_type_t = typename std::common_type<Ts...>::type;
+      template <typename... Ts>
+      using common_type_t = typename std::common_type<Ts...>::type;
 
-template<typename T>
-using decay_t = typename std::decay<T>::type;
+      template <typename T>
+      using decay_t = typename std::decay<T>::type;
 
-template<bool B, typename T = void>
-using enable_if_t = typename std::enable_if<B, T>::type;
+      template <bool B, typename T = void>
+      using enable_if_t = typename std::enable_if<B, T>::type;
 
-template<typename T>
-using remove_const_t = typename std::remove_const<T>::type;
+      template <typename T>
+      using remove_const_t = typename std::remove_const<T>::type;
 
-template<typename T>
-using remove_reference_t = typename std::remove_reference<T>::type;
+      template <typename T>
+      using remove_reference_t = typename std::remove_reference<T>::type;
 
-template<typename T>
-inline constexpr T &&
-forward(remove_reference_t<T> &t) noexcept
-{
-    return static_cast<T &&>(t);
-}
+      template <typename T>
+      inline constexpr T &&forward(remove_reference_t<T> &t) noexcept {
+        return static_cast<T &&>(t);
+      }
 
-template<typename T>
-inline constexpr T &&
-forward(remove_reference_t<T> &&t) noexcept
-{
-    static_assert(!std::is_lvalue_reference<T>::value,
-                  "can not forward an rvalue as an lvalue");
-    return static_cast<T &&>(t);
-}
+      template <typename T>
+      inline constexpr T &&forward(remove_reference_t<T> &&t) noexcept {
+        static_assert(!std::is_lvalue_reference<T>::value,
+                      "can not forward an rvalue as an lvalue");
+        return static_cast<T &&>(t);
+      }
 
-template<typename T>
-inline constexpr remove_reference_t<T> &&
-move(T &&t) noexcept
-{
-    return static_cast<remove_reference_t<T> &&>(t);
-}
+      template <typename T>
+      inline constexpr remove_reference_t<T> &&move(T &&t) noexcept {
+        return static_cast<remove_reference_t<T> &&>(t);
+      }
 
 #ifdef MPARK_INTEGER_SEQUENCE
-using std::index_sequence;
-using std::index_sequence_for;
-using std::integer_sequence;
-using std::make_index_sequence;
+      using std::integer_sequence;
+      using std::index_sequence;
+      using std::make_index_sequence;
+      using std::index_sequence_for;
 #else
-template<typename T, T... Is>
-struct integer_sequence {
-    using value_type = T;
+      template <typename T, T... Is>
+      struct integer_sequence {
+        using value_type = T;
+        static constexpr std::size_t size() noexcept { return sizeof...(Is); }
+      };
 
-    static constexpr std::size_t size() noexcept { return sizeof...(Is); }
-};
+      template <std::size_t... Is>
+      using index_sequence = integer_sequence<std::size_t, Is...>;
 
-template<std::size_t... Is>
-using index_sequence = integer_sequence<std::size_t, Is...>;
+      template <typename Lhs, typename Rhs>
+      struct make_index_sequence_concat;
 
-template<typename Lhs, typename Rhs>
-struct make_index_sequence_concat;
+      template <std::size_t... Lhs, std::size_t... Rhs>
+      struct make_index_sequence_concat<index_sequence<Lhs...>,
+                                        index_sequence<Rhs...>>
+          : identity<index_sequence<Lhs..., (sizeof...(Lhs) + Rhs)...>> {};
 
-template<std::size_t... Lhs, std::size_t... Rhs>
-struct make_index_sequence_concat<index_sequence<Lhs...>,
-                                  index_sequence<Rhs...>>
-    : identity<index_sequence<Lhs..., (sizeof...(Lhs) + Rhs)...>> {};
+      template <std::size_t N>
+      struct make_index_sequence_impl;
 
-template<std::size_t N>
-struct make_index_sequence_impl;
+      template <std::size_t N>
+      using make_index_sequence = typename make_index_sequence_impl<N>::type;
 
-template<std::size_t N>
-using make_index_sequence = typename make_index_sequence_impl<N>::type;
+      template <std::size_t N>
+      struct make_index_sequence_impl
+          : make_index_sequence_concat<make_index_sequence<N / 2>,
+                                       make_index_sequence<N - (N / 2)>> {};
 
-template<std::size_t N>
-struct make_index_sequence_impl
-    : make_index_sequence_concat<make_index_sequence<N / 2>,
-                                 make_index_sequence<N - (N / 2)>> {};
+      template <>
+      struct make_index_sequence_impl<0> : identity<index_sequence<>> {};
 
-template<>
-struct make_index_sequence_impl<0> : identity<index_sequence<>> {};
+      template <>
+      struct make_index_sequence_impl<1> : identity<index_sequence<0>> {};
 
-template<>
-struct make_index_sequence_impl<1> : identity<index_sequence<0>> {};
-
-template<typename... Ts>
-using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
+      template <typename... Ts>
+      using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
 #endif
 
-// <functional>
+      // <functional>
 #ifdef MPARK_TRANSPARENT_OPERATORS
-using equal_to = std::equal_to<>;
+      using equal_to = std::equal_to<>;
 #else
-struct equal_to {
-    template<typename Lhs, typename Rhs>
-    inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-        MPARK_RETURN(lib::forward<Lhs>(lhs) == lib::forward<Rhs>(rhs))
-};
+      struct equal_to {
+        template <typename Lhs, typename Rhs>
+        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
+          MPARK_RETURN(lib::forward<Lhs>(lhs) == lib::forward<Rhs>(rhs))
+      };
 #endif
 
 #ifdef MPARK_TRANSPARENT_OPERATORS
-using not_equal_to = std::not_equal_to<>;
+      using not_equal_to = std::not_equal_to<>;
 #else
-struct not_equal_to {
-    template<typename Lhs, typename Rhs>
-    inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-        MPARK_RETURN(lib::forward<Lhs>(lhs) != lib::forward<Rhs>(rhs))
-};
+      struct not_equal_to {
+        template <typename Lhs, typename Rhs>
+        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
+          MPARK_RETURN(lib::forward<Lhs>(lhs) != lib::forward<Rhs>(rhs))
+      };
 #endif
 
 #ifdef MPARK_TRANSPARENT_OPERATORS
-using less = std::less<>;
+      using less = std::less<>;
 #else
-struct less {
-    template<typename Lhs, typename Rhs>
-    inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-        MPARK_RETURN(lib::forward<Lhs>(lhs) < lib::forward<Rhs>(rhs))
-};
+      struct less {
+        template <typename Lhs, typename Rhs>
+        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
+          MPARK_RETURN(lib::forward<Lhs>(lhs) < lib::forward<Rhs>(rhs))
+      };
 #endif
 
 #ifdef MPARK_TRANSPARENT_OPERATORS
-using greater = std::greater<>;
+      using greater = std::greater<>;
 #else
-struct greater {
-    template<typename Lhs, typename Rhs>
-    inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-        MPARK_RETURN(lib::forward<Lhs>(lhs) > lib::forward<Rhs>(rhs))
-};
+      struct greater {
+        template <typename Lhs, typename Rhs>
+        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
+          MPARK_RETURN(lib::forward<Lhs>(lhs) > lib::forward<Rhs>(rhs))
+      };
 #endif
 
 #ifdef MPARK_TRANSPARENT_OPERATORS
-using less_equal = std::less_equal<>;
+      using less_equal = std::less_equal<>;
 #else
-struct less_equal {
-    template<typename Lhs, typename Rhs>
-    inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-        MPARK_RETURN(lib::forward<Lhs>(lhs) <= lib::forward<Rhs>(rhs))
-};
+      struct less_equal {
+        template <typename Lhs, typename Rhs>
+        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
+          MPARK_RETURN(lib::forward<Lhs>(lhs) <= lib::forward<Rhs>(rhs))
+      };
 #endif
 
 #ifdef MPARK_TRANSPARENT_OPERATORS
-using greater_equal = std::greater_equal<>;
+      using greater_equal = std::greater_equal<>;
 #else
-struct greater_equal {
-    template<typename Lhs, typename Rhs>
-    inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-        MPARK_RETURN(lib::forward<Lhs>(lhs) >= lib::forward<Rhs>(rhs))
-};
+      struct greater_equal {
+        template <typename Lhs, typename Rhs>
+        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
+          MPARK_RETURN(lib::forward<Lhs>(lhs) >= lib::forward<Rhs>(rhs))
+      };
 #endif
-}// namespace cpp14
+    }  // namespace cpp14
 
-inline namespace cpp17 {
+    inline namespace cpp17 {
 
-// <type_traits>
-template<bool B>
-using bool_constant = std::integral_constant<bool, B>;
+      // <type_traits>
+      template <bool B>
+      using bool_constant = std::integral_constant<bool, B>;
 
-template<typename...>
-struct voider : identity<void> {};
+      template <typename...>
+      struct voider : identity<void> {};
 
-template<typename... Ts>
-using void_t = typename voider<Ts...>::type;
+      template <typename... Ts>
+      using void_t = typename voider<Ts...>::type;
 
-namespace detail {
-namespace swappable {
+      namespace detail {
+        namespace swappable {
 
-using std::swap;
+          using std::swap;
 
-template<typename T>
-struct is_swappable {
-private:
-    template<typename U,
-             typename = decltype(swap(std::declval<U &>(),
-                                      std::declval<U &>()))>
-    inline static std::true_type test(int);
+          template <typename T>
+          struct is_swappable {
+            private:
+            template <typename U,
+                      typename = decltype(swap(std::declval<U &>(),
+                                               std::declval<U &>()))>
+            inline static std::true_type test(int);
 
-    template<typename U>
-    inline static std::false_type test(...);
+            template <typename U>
+            inline static std::false_type test(...);
 
-public:
-    static constexpr bool value = decltype(test<T>(0))::value;
-};
+            public:
+            static constexpr bool value = decltype(test<T>(0))::value;
+          };
 
-template<bool IsSwappable, typename T>
-struct is_nothrow_swappable {
-    static constexpr bool value =
-        noexcept(swap(std::declval<T &>(), std::declval<T &>()));
-};
+          template <bool IsSwappable, typename T>
+          struct is_nothrow_swappable {
+            static constexpr bool value =
+                noexcept(swap(std::declval<T &>(), std::declval<T &>()));
+          };
 
-template<typename T>
-struct is_nothrow_swappable<false, T> : std::false_type {};
+          template <typename T>
+          struct is_nothrow_swappable<false, T> : std::false_type {};
 
-}// namespace swappable
-}// namespace detail
+        }  // namespace swappable
+      }  // namespace detail
 
-using detail::swappable::is_swappable;
+      using detail::swappable::is_swappable;
 
-template<typename T>
-using is_nothrow_swappable =
-    detail::swappable::is_nothrow_swappable<is_swappable<T>::value, T>;
+      template <typename T>
+      using is_nothrow_swappable =
+          detail::swappable::is_nothrow_swappable<is_swappable<T>::value, T>;
 
-// <functional>
-namespace detail {
+      // <functional>
+      namespace detail {
 
-template<typename T>
-struct is_reference_wrapper : std::false_type {};
+        template <typename T>
+        struct is_reference_wrapper : std::false_type {};
 
-template<typename T>
-struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};
+        template <typename T>
+        struct is_reference_wrapper<std::reference_wrapper<T>>
+            : std::true_type {};
 
-template<bool, int>
-struct Invoke;
+        template <bool, int>
+        struct Invoke;
 
-template<>
-struct Invoke<true /* pmf */, 0 /* is_base_of */> {
-    template<typename R, typename T, typename Arg, typename... Args>
-    inline static constexpr auto invoke(R T::*pmf, Arg &&arg, Args &&...args)
-        MPARK_RETURN((lib::forward<Arg>(arg).*pmf)(lib::forward<Args>(args)...))
-};
+        template <>
+        struct Invoke<true /* pmf */, 0 /* is_base_of */> {
+          template <typename R, typename T, typename Arg, typename... Args>
+          inline static constexpr auto invoke(R T::*pmf, Arg &&arg, Args &&... args)
+            MPARK_RETURN((lib::forward<Arg>(arg).*pmf)(lib::forward<Args>(args)...))
+        };
 
-template<>
-struct Invoke<true /* pmf */, 1 /* is_reference_wrapper */> {
-    template<typename R, typename T, typename Arg, typename... Args>
-    inline static constexpr auto invoke(R T::*pmf, Arg &&arg, Args &&...args)
-        MPARK_RETURN((lib::forward<Arg>(arg).get()
-                      .*pmf)(lib::forward<Args>(args)...))
-};
+        template <>
+        struct Invoke<true /* pmf */, 1 /* is_reference_wrapper */> {
+          template <typename R, typename T, typename Arg, typename... Args>
+          inline static constexpr auto invoke(R T::*pmf, Arg &&arg, Args &&... args)
+            MPARK_RETURN((lib::forward<Arg>(arg).get().*pmf)(lib::forward<Args>(args)...))
+        };
 
-template<>
-struct Invoke<true /* pmf */, 2 /* otherwise */> {
-    template<typename R, typename T, typename Arg, typename... Args>
-    inline static constexpr auto invoke(R T::*pmf, Arg &&arg, Args &&...args)
-        MPARK_RETURN(((*lib::forward<Arg>(arg))
-                      .*pmf)(lib::forward<Args>(args)...))
-};
+        template <>
+        struct Invoke<true /* pmf */, 2 /* otherwise */> {
+          template <typename R, typename T, typename Arg, typename... Args>
+          inline static constexpr auto invoke(R T::*pmf, Arg &&arg, Args &&... args)
+            MPARK_RETURN(((*lib::forward<Arg>(arg)).*pmf)(lib::forward<Args>(args)...))
+        };
 
-template<>
-struct Invoke<false /* pmo */, 0 /* is_base_of */> {
-    template<typename R, typename T, typename Arg>
-    inline static constexpr auto invoke(R T::*pmo, Arg &&arg)
-        MPARK_RETURN(lib::forward<Arg>(arg).*pmo)
-};
+        template <>
+        struct Invoke<false /* pmo */, 0 /* is_base_of */> {
+          template <typename R, typename T, typename Arg>
+          inline static constexpr auto invoke(R T::*pmo, Arg &&arg)
+            MPARK_RETURN(lib::forward<Arg>(arg).*pmo)
+        };
 
-template<>
-struct Invoke<false /* pmo */, 1 /* is_reference_wrapper */> {
-    template<typename R, typename T, typename Arg>
-    inline static constexpr auto invoke(R T::*pmo, Arg &&arg)
-        MPARK_RETURN(lib::forward<Arg>(arg).get().*pmo)
-};
+        template <>
+        struct Invoke<false /* pmo */, 1 /* is_reference_wrapper */> {
+          template <typename R, typename T, typename Arg>
+          inline static constexpr auto invoke(R T::*pmo, Arg &&arg)
+            MPARK_RETURN(lib::forward<Arg>(arg).get().*pmo)
+        };
 
-template<>
-struct Invoke<false /* pmo */, 2 /* otherwise */> {
-    template<typename R, typename T, typename Arg>
-    inline static constexpr auto invoke(R T::*pmo, Arg &&arg)
-        MPARK_RETURN((*lib::forward<Arg>(arg)).*pmo)
-};
+        template <>
+        struct Invoke<false /* pmo */, 2 /* otherwise */> {
+          template <typename R, typename T, typename Arg>
+          inline static constexpr auto invoke(R T::*pmo, Arg &&arg)
+              MPARK_RETURN((*lib::forward<Arg>(arg)).*pmo)
+        };
 
-template<typename R, typename T, typename Arg, typename... Args>
-inline constexpr auto
-invoke(R T::*f, Arg &&arg, Args &&...args)
-    MPARK_RETURN(Invoke<std::is_function<R>::value,
-                        (std::is_base_of<T, lib::decay_t<Arg>>::value ? 0
-                             : is_reference_wrapper<lib::decay_t<Arg>>::value
-                             ? 1
-                             : 2)>::invoke(f,
-                                           lib::forward<Arg>(arg),
-                                           lib::forward<Args>(args)...))
+        template <typename R, typename T, typename Arg, typename... Args>
+        inline constexpr auto invoke(R T::*f, Arg &&arg, Args &&... args)
+          MPARK_RETURN(
+              Invoke<std::is_function<R>::value,
+                     (std::is_base_of<T, lib::decay_t<Arg>>::value
+                          ? 0
+                          : is_reference_wrapper<lib::decay_t<Arg>>::value
+                                ? 1
+                                : 2)>::invoke(f,
+                                              lib::forward<Arg>(arg),
+                                              lib::forward<Args>(args)...))
 
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable : 4100)
 #endif
-        template<typename F, typename... Args>
-        inline constexpr auto invoke(F &&f, Args &&...args)
-            MPARK_RETURN(lib::forward<F>(f)(lib::forward<Args>(args)...))
+        template <typename F, typename... Args>
+        inline constexpr auto invoke(F &&f, Args &&... args)
+          MPARK_RETURN(lib::forward<F>(f)(lib::forward<Args>(args)...))
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
-}// namespace detail
+      }  // namespace detail
 
-template<typename F, typename... Args>
-inline constexpr auto
-invoke(F &&f, Args &&...args)
-    MPARK_RETURN(detail::invoke(lib::forward<F>(f),
-                                lib::forward<Args>(args)...))
+      template <typename F, typename... Args>
+      inline constexpr auto invoke(F &&f, Args &&... args)
+        MPARK_RETURN(detail::invoke(lib::forward<F>(f),
+                                    lib::forward<Args>(args)...))
 
-        namespace detail
-{
+      namespace detail {
 
-    template<typename Void, typename, typename...>
-    struct invoke_result {};
+        template <typename Void, typename, typename...>
+        struct invoke_result {};
 
-    template<typename F, typename... Args>
-    struct invoke_result<void_t<decltype(lib::invoke(std::declval<F>(),
-                                                     std::declval<Args>()...))>,
-                         F, Args...>
-        : identity<decltype(lib::invoke(std::declval<F>(),
-                                        std::declval<Args>()...))> {};
+        template <typename F, typename... Args>
+        struct invoke_result<void_t<decltype(lib::invoke(
+                                 std::declval<F>(), std::declval<Args>()...))>,
+                             F,
+                             Args...>
+            : identity<decltype(
+                  lib::invoke(std::declval<F>(), std::declval<Args>()...))> {};
 
-}// namespace detail
+      }  // namespace detail
 
-template<typename F, typename... Args>
-using invoke_result = detail::invoke_result<void, F, Args...>;
+      template <typename F, typename... Args>
+      using invoke_result = detail::invoke_result<void, F, Args...>;
 
-template<typename F, typename... Args>
-using invoke_result_t = typename invoke_result<F, Args...>::type;
+      template <typename F, typename... Args>
+      using invoke_result_t = typename invoke_result<F, Args...>::type;
 
-namespace detail {
+      namespace detail {
 
-template<typename Void, typename, typename...>
-struct is_invocable : std::false_type {};
+        template <typename Void, typename, typename...>
+        struct is_invocable : std::false_type {};
 
-template<typename F, typename... Args>
-struct is_invocable<void_t<invoke_result_t<F, Args...>>, F, Args...>
-    : std::true_type {};
+        template <typename F, typename... Args>
+        struct is_invocable<void_t<invoke_result_t<F, Args...>>, F, Args...>
+            : std::true_type {};
 
-template<typename Void, typename, typename, typename...>
-struct is_invocable_r : std::false_type {};
+        template <typename Void, typename, typename, typename...>
+        struct is_invocable_r : std::false_type {};
 
-template<typename R, typename F, typename... Args>
-struct is_invocable_r<void_t<invoke_result_t<F, Args...>>, R, F, Args...>
-    : std::is_convertible<invoke_result_t<F, Args...>, R> {};
+        template <typename R, typename F, typename... Args>
+        struct is_invocable_r<void_t<invoke_result_t<F, Args...>>,
+                              R,
+                              F,
+                              Args...>
+            : std::is_convertible<invoke_result_t<F, Args...>, R> {};
 
-}// namespace detail
+      }  // namespace detail
 
-template<typename F, typename... Args>
-using is_invocable = detail::is_invocable<void, F, Args...>;
+      template <typename F, typename... Args>
+      using is_invocable = detail::is_invocable<void, F, Args...>;
 
-template<typename R, typename F, typename... Args>
-using is_invocable_r = detail::is_invocable_r<void, R, F, Args...>;
+      template <typename R, typename F, typename... Args>
+      using is_invocable_r = detail::is_invocable_r<void, R, F, Args...>;
 
-namespace detail {
+      namespace detail {
 
-template<bool Invocable, typename F, typename... Args>
-struct is_nothrow_invocable {
-    static constexpr bool value =
-        noexcept(lib::invoke(std::declval<F>(), std::declval<Args>()...));
-};
+        template <bool Invocable, typename F, typename... Args>
+        struct is_nothrow_invocable {
+          static constexpr bool value =
+              noexcept(lib::invoke(std::declval<F>(), std::declval<Args>()...));
+        };
 
-template<typename F, typename... Args>
-struct is_nothrow_invocable<false, F, Args...> : std::false_type {};
+        template <typename F, typename... Args>
+        struct is_nothrow_invocable<false, F, Args...> : std::false_type {};
 
-template<bool Invocable, typename R, typename F, typename... Args>
-struct is_nothrow_invocable_r {
-private:
-    inline static R impl()
-    {
-        return lib::invoke(std::declval<F>(), std::declval<Args>()...);
-    }
+        template <bool Invocable, typename R, typename F, typename... Args>
+        struct is_nothrow_invocable_r {
+          private:
+          inline static R impl() {
+            return lib::invoke(std::declval<F>(), std::declval<Args>()...);
+          }
 
-public:
-    static constexpr bool value = noexcept(impl());
-};
+          public:
+          static constexpr bool value = noexcept(impl());
+        };
 
-template<typename R, typename F, typename... Args>
-struct is_nothrow_invocable_r<false, R, F, Args...> : std::false_type {};
+        template <typename R, typename F, typename... Args>
+        struct is_nothrow_invocable_r<false, R, F, Args...> : std::false_type {};
 
-}// namespace detail
+      }  // namespace detail
 
-template<typename F, typename... Args>
-using is_nothrow_invocable =
-    detail::is_nothrow_invocable<is_invocable<F, Args...>::value, F, Args...>;
+      template <typename F, typename... Args>
+      using is_nothrow_invocable = detail::
+          is_nothrow_invocable<is_invocable<F, Args...>::value, F, Args...>;
 
-template<typename R, typename F, typename... Args>
-using is_nothrow_invocable_r = detail::
-    is_nothrow_invocable_r<is_invocable_r<R, F, Args...>::value, R, F, Args...>;
+      template <typename R, typename F, typename... Args>
+      using is_nothrow_invocable_r =
+          detail::is_nothrow_invocable_r<is_invocable_r<R, F, Args...>::value,
+                                         R,
+                                         F,
+                                         Args...>;
 
-// <memory>
+      // <memory>
 #ifdef MPARK_BUILTIN_ADDRESSOF
-template<typename T>
-inline constexpr T *
-addressof(T &arg) noexcept
-{
-    return __builtin_addressof(arg);
-}
+      template <typename T>
+      inline constexpr T *addressof(T &arg) noexcept {
+        return __builtin_addressof(arg);
+      }
 #else
-namespace detail {
+      namespace detail {
 
-namespace has_addressof_impl {
+        namespace has_addressof_impl {
 
-struct fail;
+          struct fail;
 
-template<typename T>
-inline fail operator&(T &&);
+          template <typename T>
+          inline fail operator&(T &&);
 
-template<typename T>
-inline static constexpr bool
-impl()
-{
-    return (std::is_class<T>::value || std::is_union<T>::value)
-        && !std::is_same<decltype(&std::declval<T &>()), fail>::value;
-}
+          template <typename T>
+          inline static constexpr bool impl() {
+            return (std::is_class<T>::value || std::is_union<T>::value) &&
+                   !std::is_same<decltype(&std::declval<T &>()), fail>::value;
+          }
 
-}// namespace has_addressof_impl
+        }  // namespace has_addressof_impl
 
-template<typename T>
-using has_addressof = bool_constant<has_addressof_impl::impl<T>()>;
+        template <typename T>
+        using has_addressof = bool_constant<has_addressof_impl::impl<T>()>;
 
-template<typename T>
-inline constexpr T *
-addressof(T &arg, std::true_type) noexcept
-{
-    return std::addressof(arg);
-}
+        template <typename T>
+        inline constexpr T *addressof(T &arg, std::true_type) noexcept {
+          return std::addressof(arg);
+        }
 
-template<typename T>
-inline constexpr T *
-addressof(T &arg, std::false_type) noexcept
-{
-    return &arg;
-}
+        template <typename T>
+        inline constexpr T *addressof(T &arg, std::false_type) noexcept {
+          return &arg;
+        }
 
-}// namespace detail
+      }  // namespace detail
 
-template<typename T>
-inline constexpr T *
-addressof(T &arg) noexcept
-{
-    return detail::addressof(arg, detail::has_addressof<T>{});
-}
+      template <typename T>
+      inline constexpr T *addressof(T &arg) noexcept {
+        return detail::addressof(arg, detail::has_addressof<T>{});
+      }
 #endif
 
-template<typename T>
-inline constexpr T *addressof(const T &&) = delete;
+      template <typename T>
+      inline constexpr T *addressof(const T &&) = delete;
 
-}// namespace cpp17
+    }  // namespace cpp17
 
-template<typename T>
-struct remove_all_extents : identity<T> {};
+    template <typename T>
+    struct remove_all_extents : identity<T> {};
 
-template<typename T, std::size_t N>
-struct remove_all_extents<array<T, N>> : remove_all_extents<T> {};
+    template <typename T, std::size_t N>
+    struct remove_all_extents<array<T, N>> : remove_all_extents<T> {};
 
-template<typename T>
-using remove_all_extents_t = typename remove_all_extents<T>::type;
+    template <typename T>
+    using remove_all_extents_t = typename remove_all_extents<T>::type;
 
-template<std::size_t N>
-using size_constant = std::integral_constant<std::size_t, N>;
+    template <std::size_t N>
+    using size_constant = std::integral_constant<std::size_t, N>;
 
-template<std::size_t I, typename T>
-struct indexed_type : size_constant<I> {
-    using type = T;
-};
+    template <std::size_t I, typename T>
+    struct indexed_type : size_constant<I> { using type = T; };
 
-template<bool... Bs>
-using all = std::is_same<integer_sequence<bool, true, Bs...>,
-                         integer_sequence<bool, Bs..., true>>;
+    template <bool... Bs>
+    using all = std::is_same<integer_sequence<bool, true, Bs...>,
+                             integer_sequence<bool, Bs..., true>>;
 
 #ifdef MPARK_TYPE_PACK_ELEMENT
-template<std::size_t I, typename... Ts>
-using type_pack_element_t = __type_pack_element<I, Ts...>;
+    template <std::size_t I, typename... Ts>
+    using type_pack_element_t = __type_pack_element<I, Ts...>;
 #else
-template<std::size_t I, typename... Ts>
-struct type_pack_element_impl {
-private:
-    template<typename>
-    struct set;
+    template <std::size_t I, typename... Ts>
+    struct type_pack_element_impl {
+      private:
+      template <typename>
+      struct set;
 
-    template<std::size_t... Is>
-    struct set<index_sequence<Is...>> : indexed_type<Is, Ts>... {};
+      template <std::size_t... Is>
+      struct set<index_sequence<Is...>> : indexed_type<Is, Ts>... {};
 
-    template<typename T>
-    inline static std::enable_if<true, T> impl(indexed_type<I, T>);
+      template <typename T>
+      inline static std::enable_if<true, T> impl(indexed_type<I, T>);
 
-    inline static std::enable_if<false> impl(...);
+      inline static std::enable_if<false> impl(...);
 
-public:
-    using type = decltype(impl(set<index_sequence_for<Ts...>>{}));
-};
+      public:
+      using type = decltype(impl(set<index_sequence_for<Ts...>>{}));
+    };
 
-template<std::size_t I, typename... Ts>
-using type_pack_element = typename type_pack_element_impl<I, Ts...>::type;
+    template <std::size_t I, typename... Ts>
+    using type_pack_element = typename type_pack_element_impl<I, Ts...>::type;
 
-template<std::size_t I, typename... Ts>
-using type_pack_element_t = typename type_pack_element<I, Ts...>::type;
+    template <std::size_t I, typename... Ts>
+    using type_pack_element_t = typename type_pack_element<I, Ts...>::type;
 #endif
 
 #ifdef MPARK_TRIVIALITY_TYPE_TRAITS
-using std::is_trivially_copy_assignable;
-using std::is_trivially_copy_constructible;
-using std::is_trivially_move_assignable;
-using std::is_trivially_move_constructible;
+    using std::is_trivially_copy_constructible;
+    using std::is_trivially_move_constructible;
+    using std::is_trivially_copy_assignable;
+    using std::is_trivially_move_assignable;
 #else
-template<typename T>
-struct is_trivially_copy_constructible
-    : bool_constant<std::is_copy_constructible<T>::value &&__has_trivial_copy(
-          T)> {};
+    template <typename T>
+    struct is_trivially_copy_constructible
+        : bool_constant<
+              std::is_copy_constructible<T>::value && __has_trivial_copy(T)> {};
 
-template<typename T>
-struct is_trivially_move_constructible : bool_constant<__is_trivial(T)> {};
+    template <typename T>
+    struct is_trivially_move_constructible : bool_constant<__is_trivial(T)> {};
 
-template<typename T>
-struct is_trivially_copy_assignable
-    : bool_constant<std::is_copy_assignable<T>::value &&__has_trivial_assign(
-          T)> {};
+    template <typename T>
+    struct is_trivially_copy_assignable
+        : bool_constant<
+              std::is_copy_assignable<T>::value && __has_trivial_assign(T)> {};
 
-template<typename T>
-struct is_trivially_move_assignable : bool_constant<__is_trivial(T)> {};
+    template <typename T>
+    struct is_trivially_move_assignable : bool_constant<__is_trivial(T)> {};
 #endif
 
-template<typename T, bool>
-struct dependent_type : T {};
+    template <typename T, bool>
+    struct dependent_type : T {};
 
-template<typename Is, std::size_t J>
-struct push_back;
+    template <typename Is, std::size_t J>
+    struct push_back;
 
-template<typename Is, std::size_t J>
-using push_back_t = typename push_back<Is, J>::type;
+    template <typename Is, std::size_t J>
+    using push_back_t = typename push_back<Is, J>::type;
 
-template<std::size_t... Is, std::size_t J>
-struct push_back<index_sequence<Is...>, J> {
-    using type = index_sequence<Is..., J>;
-};
+    template <std::size_t... Is, std::size_t J>
+    struct push_back<index_sequence<Is...>, J> {
+      using type = index_sequence<Is..., J>;
+    };
 
-}// namespace lib
-}// namespace mpark
+  }  // namespace lib
+}  // namespace mpark
 
 #undef MPARK_RETURN
 
-#endif// MPARK_LIB_HPP
+#endif  // MPARK_LIB_HPP
+
 
 namespace mpark {
 
 #ifdef MPARK_RETURN_TYPE_DEDUCTION
 
 #define AUTO auto
-#define AUTO_RETURN(...)                                                       \
-    {                                                                          \
-        return __VA_ARGS__;                                                    \
-    }
+#define AUTO_RETURN(...) { return __VA_ARGS__; }
 
 #define AUTO_REFREF auto &&
-#define AUTO_REFREF_RETURN(...)                                                \
-    {                                                                          \
-        return __VA_ARGS__;                                                    \
-    }
+#define AUTO_REFREF_RETURN(...) { return __VA_ARGS__; }
 
 #define DECLTYPE_AUTO decltype(auto)
-#define DECLTYPE_AUTO_RETURN(...)                                              \
-    {                                                                          \
-        return __VA_ARGS__;                                                    \
-    }
+#define DECLTYPE_AUTO_RETURN(...) { return __VA_ARGS__; }
 
 #else
 
 #define AUTO auto
-#define AUTO_RETURN(...)                                                       \
-    ->lib::decay_t<decltype(__VA_ARGS__)> { return __VA_ARGS__; }
+#define AUTO_RETURN(...) \
+  -> lib::decay_t<decltype(__VA_ARGS__)> { return __VA_ARGS__; }
 
 #define AUTO_REFREF auto
-#define AUTO_REFREF_RETURN(...)                                                \
-    ->decltype((__VA_ARGS__))                                                  \
-    {                                                                          \
-        static_assert(std::is_reference<decltype((__VA_ARGS__))>::value, "");  \
-        return __VA_ARGS__;                                                    \
-    }
+#define AUTO_REFREF_RETURN(...)                                           \
+  -> decltype((__VA_ARGS__)) {                                            \
+    static_assert(std::is_reference<decltype((__VA_ARGS__))>::value, ""); \
+    return __VA_ARGS__;                                                   \
+  }
 
 #define DECLTYPE_AUTO auto
-#define DECLTYPE_AUTO_RETURN(...)                                              \
-    ->decltype(__VA_ARGS__) { return __VA_ARGS__; }
+#define DECLTYPE_AUTO_RETURN(...) \
+  -> decltype(__VA_ARGS__) { return __VA_ARGS__; }
 
 #endif
 
-class bad_variant_access : public std::exception {
-public:
-    virtual const char *what() const noexcept override
-    {
-        return "bad_variant_access";
-    }
-};
+  class bad_variant_access : public std::exception {
+    public:
+    virtual const char *what() const noexcept override { return "bad_variant_access"; }
+  };
 
-[[noreturn]] inline void
-throw_bad_variant_access()
-{
+  [[noreturn]] inline void throw_bad_variant_access() {
 #ifdef MPARK_EXCEPTIONS
     throw bad_variant_access{};
 #else
     std::terminate();
     MPARK_BUILTIN_UNREACHABLE;
 #endif
-}
+  }
 
-template<typename... Ts>
-class variant;
+  template <typename... Ts>
+  class variant;
 
-template<typename T>
-struct variant_size;
+  template <typename T>
+  struct variant_size;
 
 #ifdef MPARK_VARIABLE_TEMPLATES
-template<typename T>
-constexpr std::size_t variant_size_v = variant_size<T>::value;
+  template <typename T>
+  constexpr std::size_t variant_size_v = variant_size<T>::value;
 #endif
 
-template<typename T>
-struct variant_size<const T> : variant_size<T> {};
+  template <typename T>
+  struct variant_size<const T> : variant_size<T> {};
 
-template<typename T>
-struct variant_size<volatile T> : variant_size<T> {};
+  template <typename T>
+  struct variant_size<volatile T> : variant_size<T> {};
 
-template<typename T>
-struct variant_size<const volatile T> : variant_size<T> {};
+  template <typename T>
+  struct variant_size<const volatile T> : variant_size<T> {};
 
-template<typename... Ts>
-struct variant_size<variant<Ts...>> : lib::size_constant<sizeof...(Ts)> {};
+  template <typename... Ts>
+  struct variant_size<variant<Ts...>> : lib::size_constant<sizeof...(Ts)> {};
 
-template<std::size_t I, typename T>
-struct variant_alternative;
+  template <std::size_t I, typename T>
+  struct variant_alternative;
 
-template<std::size_t I, typename T>
-using variant_alternative_t = typename variant_alternative<I, T>::type;
+  template <std::size_t I, typename T>
+  using variant_alternative_t = typename variant_alternative<I, T>::type;
 
-template<std::size_t I, typename T>
-struct variant_alternative<I, const T>
-    : std::add_const<variant_alternative_t<I, T>> {};
+  template <std::size_t I, typename T>
+  struct variant_alternative<I, const T>
+      : std::add_const<variant_alternative_t<I, T>> {};
 
-template<std::size_t I, typename T>
-struct variant_alternative<I, volatile T>
-    : std::add_volatile<variant_alternative_t<I, T>> {};
+  template <std::size_t I, typename T>
+  struct variant_alternative<I, volatile T>
+      : std::add_volatile<variant_alternative_t<I, T>> {};
 
-template<std::size_t I, typename T>
-struct variant_alternative<I, const volatile T>
-    : std::add_cv<variant_alternative_t<I, T>> {};
+  template <std::size_t I, typename T>
+  struct variant_alternative<I, const volatile T>
+      : std::add_cv<variant_alternative_t<I, T>> {};
 
-template<std::size_t I, typename... Ts>
-struct variant_alternative<I, variant<Ts...>> {
+  template <std::size_t I, typename... Ts>
+  struct variant_alternative<I, variant<Ts...>> {
     static_assert(I < sizeof...(Ts),
                   "index out of bounds in `std::variant_alternative<>`");
     using type = lib::type_pack_element_t<I, Ts...>;
-};
+  };
 
-constexpr std::size_t variant_npos = static_cast<std::size_t>(-1);
+  constexpr std::size_t variant_npos = static_cast<std::size_t>(-1);
 
-namespace detail {
+  namespace detail {
 
-constexpr std::size_t not_found = static_cast<std::size_t>(-1);
-constexpr std::size_t ambiguous = static_cast<std::size_t>(-2);
+    constexpr std::size_t not_found = static_cast<std::size_t>(-1);
+    constexpr std::size_t ambiguous = static_cast<std::size_t>(-2);
 
 #ifdef MPARK_CPP14_CONSTEXPR
-template<typename T, typename... Ts>
-inline constexpr std::size_t
-find_index()
-{
-    constexpr lib::array<bool, sizeof...(Ts)> matches = {
-        {std::is_same<T, Ts>::value...}};
-    std::size_t result = not_found;
-    for (std::size_t i = 0; i < sizeof...(Ts); ++i) {
+    template <typename T, typename... Ts>
+    inline constexpr std::size_t find_index() {
+      constexpr lib::array<bool, sizeof...(Ts)> matches = {
+          {std::is_same<T, Ts>::value...}
+      };
+      std::size_t result = not_found;
+      for (std::size_t i = 0; i < sizeof...(Ts); ++i) {
         if (matches[i]) {
-            if (result != not_found) { return ambiguous; }
-            result = i;
+          if (result != not_found) {
+            return ambiguous;
+          }
+          result = i;
         }
+      }
+      return result;
     }
-    return result;
-}
 #else
-inline constexpr std::size_t
-find_index_impl(std::size_t result, std::size_t)
-{
-    return result;
-}
+    inline constexpr std::size_t find_index_impl(std::size_t result,
+                                                 std::size_t) {
+      return result;
+    }
 
-template<typename... Bs>
-inline constexpr std::size_t
-find_index_impl(std::size_t result, std::size_t idx, bool b, Bs... bs)
-{
-    return b ? (result != not_found ? ambiguous
-                                    : find_index_impl(idx, idx + 1, bs...))
-             : find_index_impl(result, idx + 1, bs...);
-}
+    template <typename... Bs>
+    inline constexpr std::size_t find_index_impl(std::size_t result,
+                                                 std::size_t idx,
+                                                 bool b,
+                                                 Bs... bs) {
+      return b ? (result != not_found ? ambiguous
+                                      : find_index_impl(idx, idx + 1, bs...))
+               : find_index_impl(result, idx + 1, bs...);
+    }
 
-template<typename T, typename... Ts>
-inline constexpr std::size_t
-find_index()
-{
-    return find_index_impl(not_found, 0, std::is_same<T, Ts>::value...);
-}
+    template <typename T, typename... Ts>
+    inline constexpr std::size_t find_index() {
+      return find_index_impl(not_found, 0, std::is_same<T, Ts>::value...);
+    }
 #endif
 
-template<std::size_t I>
-using find_index_sfinae_impl =
-    lib::enable_if_t<I != not_found && I != ambiguous, lib::size_constant<I>>;
+    template <std::size_t I>
+    using find_index_sfinae_impl =
+        lib::enable_if_t<I != not_found && I != ambiguous,
+                         lib::size_constant<I>>;
 
-template<typename T, typename... Ts>
-using find_index_sfinae = find_index_sfinae_impl<find_index<T, Ts...>()>;
+    template <typename T, typename... Ts>
+    using find_index_sfinae = find_index_sfinae_impl<find_index<T, Ts...>()>;
 
-template<std::size_t I>
-struct find_index_checked_impl : lib::size_constant<I> {
-    static_assert(I != not_found, "the specified type is not found.");
-    static_assert(I != ambiguous, "the specified type is ambiguous.");
-};
+    template <std::size_t I>
+    struct find_index_checked_impl : lib::size_constant<I> {
+      static_assert(I != not_found, "the specified type is not found.");
+      static_assert(I != ambiguous, "the specified type is ambiguous.");
+    };
 
-template<typename T, typename... Ts>
-using find_index_checked = find_index_checked_impl<find_index<T, Ts...>()>;
+    template <typename T, typename... Ts>
+    using find_index_checked = find_index_checked_impl<find_index<T, Ts...>()>;
 
-struct valueless_t {};
+    struct valueless_t {};
 
-enum class Trait { TriviallyAvailable, Available, Unavailable };
+    enum class Trait { TriviallyAvailable, Available, Unavailable };
 
-template<typename T,
-         template<typename>
-         class IsTriviallyAvailable,
-         template<typename>
-         class IsAvailable>
-inline constexpr Trait
-trait()
-{
-    return IsTriviallyAvailable<T>::value ? Trait::TriviallyAvailable
-        : IsAvailable<T>::value           ? Trait::Available
-                                          : Trait::Unavailable;
-}
+    template <typename T,
+              template <typename> class IsTriviallyAvailable,
+              template <typename> class IsAvailable>
+    inline constexpr Trait trait() {
+      return IsTriviallyAvailable<T>::value
+                 ? Trait::TriviallyAvailable
+                 : IsAvailable<T>::value ? Trait::Available
+                                         : Trait::Unavailable;
+    }
 
 #ifdef MPARK_CPP14_CONSTEXPR
-template<typename... Traits>
-inline constexpr Trait
-common_trait(Traits... traits_)
-{
-    Trait result = Trait::TriviallyAvailable;
-    lib::array<Trait, sizeof...(Traits)> traits = {{traits_...}};
-    for (std::size_t i = 0; i < sizeof...(Traits); ++i) {
+    template <typename... Traits>
+    inline constexpr Trait common_trait(Traits... traits_) {
+      Trait result = Trait::TriviallyAvailable;
+      lib::array<Trait, sizeof...(Traits)> traits = {{traits_...}};
+      for (std::size_t i = 0; i < sizeof...(Traits); ++i) {
         Trait t = traits[i];
-        if (static_cast<int>(t) > static_cast<int>(result)) { result = t; }
+        if (static_cast<int>(t) > static_cast<int>(result)) {
+          result = t;
+        }
+      }
+      return result;
     }
-    return result;
-}
 #else
-inline constexpr Trait
-common_trait_impl(Trait result)
-{
-    return result;
-}
+    inline constexpr Trait common_trait_impl(Trait result) { return result; }
 
-template<typename... Traits>
-inline constexpr Trait
-common_trait_impl(Trait result, Trait t, Traits... ts)
-{
-    return static_cast<int>(t) > static_cast<int>(result)
-        ? common_trait_impl(t, ts...)
-        : common_trait_impl(result, ts...);
-}
+    template <typename... Traits>
+    inline constexpr Trait common_trait_impl(Trait result,
+                                             Trait t,
+                                             Traits... ts) {
+      return static_cast<int>(t) > static_cast<int>(result)
+                 ? common_trait_impl(t, ts...)
+                 : common_trait_impl(result, ts...);
+    }
 
-template<typename... Traits>
-inline constexpr Trait
-common_trait(Traits... ts)
-{
-    return common_trait_impl(Trait::TriviallyAvailable, ts...);
-}
+    template <typename... Traits>
+    inline constexpr Trait common_trait(Traits... ts) {
+      return common_trait_impl(Trait::TriviallyAvailable, ts...);
+    }
 #endif
 
-template<typename... Ts>
-struct traits {
-    static constexpr Trait copy_constructible_trait =
-        common_trait(trait<Ts,
-                           lib::is_trivially_copy_constructible,
-                           std::is_copy_constructible>()...);
+    template <typename... Ts>
+    struct traits {
+      static constexpr Trait copy_constructible_trait =
+          common_trait(trait<Ts,
+                             lib::is_trivially_copy_constructible,
+                             std::is_copy_constructible>()...);
 
-    static constexpr Trait move_constructible_trait =
-        common_trait(trait<Ts,
-                           lib::is_trivially_move_constructible,
-                           std::is_move_constructible>()...);
+      static constexpr Trait move_constructible_trait =
+          common_trait(trait<Ts,
+                             lib::is_trivially_move_constructible,
+                             std::is_move_constructible>()...);
 
-    static constexpr Trait copy_assignable_trait =
-        common_trait(copy_constructible_trait,
-                     trait<Ts,
-                           lib::is_trivially_copy_assignable,
-                           std::is_copy_assignable>()...);
+      static constexpr Trait copy_assignable_trait =
+          common_trait(copy_constructible_trait,
+                       trait<Ts,
+                             lib::is_trivially_copy_assignable,
+                             std::is_copy_assignable>()...);
 
-    static constexpr Trait move_assignable_trait =
-        common_trait(move_constructible_trait,
-                     trait<Ts,
-                           lib::is_trivially_move_assignable,
-                           std::is_move_assignable>()...);
+      static constexpr Trait move_assignable_trait =
+          common_trait(move_constructible_trait,
+                       trait<Ts,
+                             lib::is_trivially_move_assignable,
+                             std::is_move_assignable>()...);
 
-    static constexpr Trait destructible_trait = common_trait(
-        trait<Ts, std::is_trivially_destructible, std::is_destructible>()...);
-};
+      static constexpr Trait destructible_trait =
+          common_trait(trait<Ts,
+                             std::is_trivially_destructible,
+                             std::is_destructible>()...);
+    };
 
-namespace access {
+    namespace access {
 
-struct recursive_union {
+      struct recursive_union {
 #ifdef MPARK_RETURN_TYPE_DEDUCTION
-    template<typename V>
-    inline static constexpr auto &&get_alt(V &&v, in_place_index_t<0>)
-    {
-        return lib::forward<V>(v).head_;
-    }
+        template <typename V>
+        inline static constexpr auto &&get_alt(V &&v, in_place_index_t<0>) {
+          return lib::forward<V>(v).head_;
+        }
 
-    template<typename V, std::size_t I>
-    inline static constexpr auto &&get_alt(V &&v, in_place_index_t<I>)
-    {
-        return get_alt(lib::forward<V>(v).tail_, in_place_index_t<I - 1>{});
-    }
+        template <typename V, std::size_t I>
+        inline static constexpr auto &&get_alt(V &&v, in_place_index_t<I>) {
+          return get_alt(lib::forward<V>(v).tail_, in_place_index_t<I - 1>{});
+        }
 #else
-    template<std::size_t I, bool Dummy = true>
-    struct get_alt_impl {
-        template<typename V>
-        inline constexpr AUTO_REFREF operator()(V &&v) const
+        template <std::size_t I, bool Dummy = true>
+        struct get_alt_impl {
+          template <typename V>
+          inline constexpr AUTO_REFREF operator()(V &&v) const
             AUTO_REFREF_RETURN(get_alt_impl<I - 1>{}(lib::forward<V>(v).tail_))
-    };
+        };
 
-    template<bool Dummy>
-    struct get_alt_impl<0, Dummy> {
-        template<typename V>
-        inline constexpr AUTO_REFREF operator()(V &&v) const
+        template <bool Dummy>
+        struct get_alt_impl<0, Dummy> {
+          template <typename V>
+          inline constexpr AUTO_REFREF operator()(V &&v) const
             AUTO_REFREF_RETURN(lib::forward<V>(v).head_)
-    };
+        };
 
-    template<typename V, std::size_t I>
-    inline static constexpr AUTO_REFREF get_alt(V &&v, in_place_index_t<I>)
-        AUTO_REFREF_RETURN(get_alt_impl<I>{}(lib::forward<V>(v)))
+        template <typename V, std::size_t I>
+        inline static constexpr AUTO_REFREF get_alt(V &&v, in_place_index_t<I>)
+          AUTO_REFREF_RETURN(get_alt_impl<I>{}(lib::forward<V>(v)))
 #endif
-};
+      };
 
-struct base {
-    template<std::size_t I, typename V>
-    inline static constexpr AUTO_REFREF get_alt(V &&v)
+      struct base {
+        template <std::size_t I, typename V>
+        inline static constexpr AUTO_REFREF get_alt(V &&v)
 #ifdef _MSC_VER
-        AUTO_REFREF_RETURN(recursive_union::get_alt(lib::forward<V>(v).data_,
-                                                    in_place_index_t<I>{}))
+          AUTO_REFREF_RETURN(recursive_union::get_alt(
+              lib::forward<V>(v).data_, in_place_index_t<I>{}))
 #else
-        AUTO_REFREF_RETURN(recursive_union::get_alt(data(lib::forward<V>(v)),
-                                                    in_place_index_t<I>{}))
+          AUTO_REFREF_RETURN(recursive_union::get_alt(
+              data(lib::forward<V>(v)), in_place_index_t<I>{}))
 #endif
-};
+      };
 
-struct variant {
-    template<std::size_t I, typename V>
-    inline static constexpr AUTO_REFREF get_alt(V &&v)
-        AUTO_REFREF_RETURN(base::get_alt<I>(lib::forward<V>(v).impl_))
-};
+      struct variant {
+        template <std::size_t I, typename V>
+        inline static constexpr AUTO_REFREF get_alt(V &&v)
+          AUTO_REFREF_RETURN(base::get_alt<I>(lib::forward<V>(v).impl_))
+      };
 
-}// namespace access
+    }  // namespace access
 
-namespace visitation {
+    namespace visitation {
 
 #if defined(MPARK_CPP14_CONSTEXPR) && !defined(_MSC_VER)
 #define MPARK_VARIANT_SWITCH_VISIT
 #endif
 
-struct base {
-    template<typename Visitor, typename... Vs>
-    using dispatch_result_t =
-        decltype(lib::invoke(std::declval<Visitor>(),
-                             access::base::get_alt<0>(std::declval<Vs>())...));
+      struct base {
+        template <typename Visitor, typename... Vs>
+        using dispatch_result_t = decltype(
+            lib::invoke(std::declval<Visitor>(),
+                        access::base::get_alt<0>(std::declval<Vs>())...));
 
-    template<typename Expected>
-    struct expected {
-        template<typename Actual>
-        inline static constexpr bool but_got()
-        {
+        template <typename Expected>
+        struct expected {
+          template <typename Actual>
+          inline static constexpr bool but_got() {
             return std::is_same<Expected, Actual>::value;
-        }
-    };
+          }
+        };
 
-    template<typename Expected, typename Actual>
-    struct visit_return_type_check {
-        static_assert(
-            expected<Expected>::template but_got<Actual>(),
-            "`visit` requires the visitor to have a single return type");
+        template <typename Expected, typename Actual>
+        struct visit_return_type_check {
+          static_assert(
+              expected<Expected>::template but_got<Actual>(),
+              "`visit` requires the visitor to have a single return type");
 
-        template<typename Visitor, typename... Alts>
-        inline static constexpr DECLTYPE_AUTO invoke(Visitor &&visitor,
-                                                     Alts &&...alts)
+          template <typename Visitor, typename... Alts>
+          inline static constexpr DECLTYPE_AUTO invoke(Visitor &&visitor,
+                                                       Alts &&... alts)
             DECLTYPE_AUTO_RETURN(lib::invoke(lib::forward<Visitor>(visitor),
                                              lib::forward<Alts>(alts)...))
-    };
+        };
 
 #ifdef MPARK_VARIANT_SWITCH_VISIT
-    template<bool B, typename R, typename... ITs>
-    struct dispatcher;
+        template <bool B, typename R, typename... ITs>
+        struct dispatcher;
 
-    template<typename R, typename... ITs>
-    struct dispatcher<false, R, ITs...> {
-        template<std::size_t B, typename F, typename... Vs>
-        MPARK_ALWAYS_INLINE static constexpr R
-        dispatch(F &&, typename ITs::type &&..., Vs &&...)
-        {
+        template <typename R, typename... ITs>
+        struct dispatcher<false, R, ITs...> {
+          template <std::size_t B, typename F, typename... Vs>
+          MPARK_ALWAYS_INLINE static constexpr R dispatch(
+              F &&, typename ITs::type &&..., Vs &&...) {
             MPARK_BUILTIN_UNREACHABLE;
-        }
+          }
 
-        template<std::size_t I, typename F, typename... Vs>
-        MPARK_ALWAYS_INLINE static constexpr R dispatch_case(F &&, Vs &&...)
-        {
+          template <std::size_t I, typename F, typename... Vs>
+          MPARK_ALWAYS_INLINE static constexpr R dispatch_case(F &&, Vs &&...) {
             MPARK_BUILTIN_UNREACHABLE;
-        }
+          }
 
-        template<std::size_t B, typename F, typename... Vs>
-        MPARK_ALWAYS_INLINE static constexpr R
-        dispatch_at(std::size_t, F &&, Vs &&...)
-        {
+          template <std::size_t B, typename F, typename... Vs>
+          MPARK_ALWAYS_INLINE static constexpr R dispatch_at(std::size_t,
+                                                             F &&,
+                                                             Vs &&...) {
             MPARK_BUILTIN_UNREACHABLE;
-        }
-    };
+          }
+        };
 
-    template<typename R, typename... ITs>
-    struct dispatcher<true, R, ITs...> {
-        template<std::size_t B, typename F>
-        MPARK_ALWAYS_INLINE static constexpr R
-        dispatch(F &&f, typename ITs::type &&...visited_vs)
-        {
+        template <typename R, typename... ITs>
+        struct dispatcher<true, R, ITs...> {
+          template <std::size_t B, typename F>
+          MPARK_ALWAYS_INLINE static constexpr R dispatch(
+              F &&f, typename ITs::type &&... visited_vs) {
             using Expected = R;
             using Actual = decltype(lib::invoke(
                 lib::forward<F>(f),
@@ -1285,227 +1230,160 @@ struct base {
                 lib::forward<F>(f),
                 access::base::get_alt<ITs::value>(
                     lib::forward<typename ITs::type>(visited_vs))...);
-        }
+          }
 
-        template<std::size_t B, typename F, typename V, typename... Vs>
-        MPARK_ALWAYS_INLINE static constexpr R
-        dispatch(F &&f, typename ITs::type &&...visited_vs, V &&v, Vs &&...vs)
-        {
-#define MPARK_DISPATCH(I)                                                      \
-    dispatcher<(I < lib::decay_t<V>::size()), R, ITs...,                       \
-               lib::indexed_type<I, V>>::                                      \
-        template dispatch<0>(lib::forward<F>(f),                               \
-                             lib::forward<typename ITs::type>(visited_vs)...,  \
-                             lib::forward<V>(v), lib::forward<Vs>(vs)...)
+          template <std::size_t B, typename F, typename V, typename... Vs>
+          MPARK_ALWAYS_INLINE static constexpr R dispatch(
+              F &&f, typename ITs::type &&... visited_vs, V &&v, Vs &&... vs) {
+#define MPARK_DISPATCH(I)                                                   \
+  dispatcher<(I < lib::decay_t<V>::size()),                                 \
+             R,                                                             \
+             ITs...,                                                        \
+             lib::indexed_type<I, V>>::                                     \
+      template dispatch<0>(lib::forward<F>(f),                              \
+                           lib::forward<typename ITs::type>(visited_vs)..., \
+                           lib::forward<V>(v),                              \
+                           lib::forward<Vs>(vs)...)
 
-#define MPARK_DEFAULT(I)                                                       \
-    dispatcher<(I < lib::decay_t<V>::size()), R, ITs...>::template dispatch<   \
-        I>(lib::forward<F>(f),                                                 \
-           lib::forward<typename ITs::type>(visited_vs)...,                    \
-           lib::forward<V>(v), lib::forward<Vs>(vs)...)
+#define MPARK_DEFAULT(I)                                                      \
+  dispatcher<(I < lib::decay_t<V>::size()), R, ITs...>::template dispatch<I>( \
+      lib::forward<F>(f),                                                     \
+      lib::forward<typename ITs::type>(visited_vs)...,                        \
+      lib::forward<V>(v),                                                     \
+      lib::forward<Vs>(vs)...)
 
             switch (v.index()) {
-            case B + 0:
-                return MPARK_DISPATCH(B + 0);
-            case B + 1:
-                return MPARK_DISPATCH(B + 1);
-            case B + 2:
-                return MPARK_DISPATCH(B + 2);
-            case B + 3:
-                return MPARK_DISPATCH(B + 3);
-            case B + 4:
-                return MPARK_DISPATCH(B + 4);
-            case B + 5:
-                return MPARK_DISPATCH(B + 5);
-            case B + 6:
-                return MPARK_DISPATCH(B + 6);
-            case B + 7:
-                return MPARK_DISPATCH(B + 7);
-            case B + 8:
-                return MPARK_DISPATCH(B + 8);
-            case B + 9:
-                return MPARK_DISPATCH(B + 9);
-            case B + 10:
-                return MPARK_DISPATCH(B + 10);
-            case B + 11:
-                return MPARK_DISPATCH(B + 11);
-            case B + 12:
-                return MPARK_DISPATCH(B + 12);
-            case B + 13:
-                return MPARK_DISPATCH(B + 13);
-            case B + 14:
-                return MPARK_DISPATCH(B + 14);
-            case B + 15:
-                return MPARK_DISPATCH(B + 15);
-            case B + 16:
-                return MPARK_DISPATCH(B + 16);
-            case B + 17:
-                return MPARK_DISPATCH(B + 17);
-            case B + 18:
-                return MPARK_DISPATCH(B + 18);
-            case B + 19:
-                return MPARK_DISPATCH(B + 19);
-            case B + 20:
-                return MPARK_DISPATCH(B + 20);
-            case B + 21:
-                return MPARK_DISPATCH(B + 21);
-            case B + 22:
-                return MPARK_DISPATCH(B + 22);
-            case B + 23:
-                return MPARK_DISPATCH(B + 23);
-            case B + 24:
-                return MPARK_DISPATCH(B + 24);
-            case B + 25:
-                return MPARK_DISPATCH(B + 25);
-            case B + 26:
-                return MPARK_DISPATCH(B + 26);
-            case B + 27:
-                return MPARK_DISPATCH(B + 27);
-            case B + 28:
-                return MPARK_DISPATCH(B + 28);
-            case B + 29:
-                return MPARK_DISPATCH(B + 29);
-            case B + 30:
-                return MPARK_DISPATCH(B + 30);
-            case B + 31:
-                return MPARK_DISPATCH(B + 31);
-            default:
-                return MPARK_DEFAULT(B + 32);
+              case B + 0: return MPARK_DISPATCH(B + 0);
+              case B + 1: return MPARK_DISPATCH(B + 1);
+              case B + 2: return MPARK_DISPATCH(B + 2);
+              case B + 3: return MPARK_DISPATCH(B + 3);
+              case B + 4: return MPARK_DISPATCH(B + 4);
+              case B + 5: return MPARK_DISPATCH(B + 5);
+              case B + 6: return MPARK_DISPATCH(B + 6);
+              case B + 7: return MPARK_DISPATCH(B + 7);
+              case B + 8: return MPARK_DISPATCH(B + 8);
+              case B + 9: return MPARK_DISPATCH(B + 9);
+              case B + 10: return MPARK_DISPATCH(B + 10);
+              case B + 11: return MPARK_DISPATCH(B + 11);
+              case B + 12: return MPARK_DISPATCH(B + 12);
+              case B + 13: return MPARK_DISPATCH(B + 13);
+              case B + 14: return MPARK_DISPATCH(B + 14);
+              case B + 15: return MPARK_DISPATCH(B + 15);
+              case B + 16: return MPARK_DISPATCH(B + 16);
+              case B + 17: return MPARK_DISPATCH(B + 17);
+              case B + 18: return MPARK_DISPATCH(B + 18);
+              case B + 19: return MPARK_DISPATCH(B + 19);
+              case B + 20: return MPARK_DISPATCH(B + 20);
+              case B + 21: return MPARK_DISPATCH(B + 21);
+              case B + 22: return MPARK_DISPATCH(B + 22);
+              case B + 23: return MPARK_DISPATCH(B + 23);
+              case B + 24: return MPARK_DISPATCH(B + 24);
+              case B + 25: return MPARK_DISPATCH(B + 25);
+              case B + 26: return MPARK_DISPATCH(B + 26);
+              case B + 27: return MPARK_DISPATCH(B + 27);
+              case B + 28: return MPARK_DISPATCH(B + 28);
+              case B + 29: return MPARK_DISPATCH(B + 29);
+              case B + 30: return MPARK_DISPATCH(B + 30);
+              case B + 31: return MPARK_DISPATCH(B + 31);
+              default: return MPARK_DEFAULT(B + 32);
             }
 
 #undef MPARK_DEFAULT
 #undef MPARK_DISPATCH
-        }
+          }
 
-        template<std::size_t I, typename F, typename... Vs>
-        MPARK_ALWAYS_INLINE static constexpr R dispatch_case(F &&f, Vs &&...vs)
-        {
+          template <std::size_t I, typename F, typename... Vs>
+          MPARK_ALWAYS_INLINE static constexpr R dispatch_case(F &&f,
+                                                               Vs &&... vs) {
             using Expected = R;
-            using Actual = decltype(lib::invoke(
-                lib::forward<F>(f),
-                access::base::get_alt<I>(lib::forward<Vs>(vs))...));
+            using Actual = decltype(
+                lib::invoke(lib::forward<F>(f),
+                            access::base::get_alt<I>(lib::forward<Vs>(vs))...));
             return visit_return_type_check<Expected, Actual>::invoke(
                 lib::forward<F>(f),
                 access::base::get_alt<I>(lib::forward<Vs>(vs))...);
-        }
+          }
 
-        template<std::size_t B, typename F, typename V, typename... Vs>
-        MPARK_ALWAYS_INLINE static constexpr R
-        dispatch_at(std::size_t index, F &&f, V &&v, Vs &&...vs)
-        {
-            static_assert(lib::all<(lib::decay_t<V>::size()
-                                    == lib::decay_t<Vs>::size())...>::value,
+          template <std::size_t B, typename F, typename V, typename... Vs>
+          MPARK_ALWAYS_INLINE static constexpr R dispatch_at(std::size_t index,
+                                                             F &&f,
+                                                             V &&v,
+                                                             Vs &&... vs) {
+            static_assert(lib::all<(lib::decay_t<V>::size() ==
+                                    lib::decay_t<Vs>::size())...>::value,
                           "all of the variants must be the same size.");
-#define MPARK_DISPATCH_AT(I)                                                   \
-    dispatcher<(I < lib::decay_t<V>::size()), R>::template dispatch_case<I>(   \
-        lib::forward<F>(f), lib::forward<V>(v), lib::forward<Vs>(vs)...)
+#define MPARK_DISPATCH_AT(I)                                               \
+  dispatcher<(I < lib::decay_t<V>::size()), R>::template dispatch_case<I>( \
+      lib::forward<F>(f), lib::forward<V>(v), lib::forward<Vs>(vs)...)
 
-#define MPARK_DEFAULT(I)                                                       \
-    dispatcher<(I < lib::decay_t<V>::size()), R>::template dispatch_at<I>(     \
-        index, lib::forward<F>(f), lib::forward<V>(v),                         \
-        lib::forward<Vs>(vs)...)
+#define MPARK_DEFAULT(I)                                                 \
+  dispatcher<(I < lib::decay_t<V>::size()), R>::template dispatch_at<I>( \
+      index, lib::forward<F>(f), lib::forward<V>(v), lib::forward<Vs>(vs)...)
 
             switch (index) {
-            case B + 0:
-                return MPARK_DISPATCH_AT(B + 0);
-            case B + 1:
-                return MPARK_DISPATCH_AT(B + 1);
-            case B + 2:
-                return MPARK_DISPATCH_AT(B + 2);
-            case B + 3:
-                return MPARK_DISPATCH_AT(B + 3);
-            case B + 4:
-                return MPARK_DISPATCH_AT(B + 4);
-            case B + 5:
-                return MPARK_DISPATCH_AT(B + 5);
-            case B + 6:
-                return MPARK_DISPATCH_AT(B + 6);
-            case B + 7:
-                return MPARK_DISPATCH_AT(B + 7);
-            case B + 8:
-                return MPARK_DISPATCH_AT(B + 8);
-            case B + 9:
-                return MPARK_DISPATCH_AT(B + 9);
-            case B + 10:
-                return MPARK_DISPATCH_AT(B + 10);
-            case B + 11:
-                return MPARK_DISPATCH_AT(B + 11);
-            case B + 12:
-                return MPARK_DISPATCH_AT(B + 12);
-            case B + 13:
-                return MPARK_DISPATCH_AT(B + 13);
-            case B + 14:
-                return MPARK_DISPATCH_AT(B + 14);
-            case B + 15:
-                return MPARK_DISPATCH_AT(B + 15);
-            case B + 16:
-                return MPARK_DISPATCH_AT(B + 16);
-            case B + 17:
-                return MPARK_DISPATCH_AT(B + 17);
-            case B + 18:
-                return MPARK_DISPATCH_AT(B + 18);
-            case B + 19:
-                return MPARK_DISPATCH_AT(B + 19);
-            case B + 20:
-                return MPARK_DISPATCH_AT(B + 20);
-            case B + 21:
-                return MPARK_DISPATCH_AT(B + 21);
-            case B + 22:
-                return MPARK_DISPATCH_AT(B + 22);
-            case B + 23:
-                return MPARK_DISPATCH_AT(B + 23);
-            case B + 24:
-                return MPARK_DISPATCH_AT(B + 24);
-            case B + 25:
-                return MPARK_DISPATCH_AT(B + 25);
-            case B + 26:
-                return MPARK_DISPATCH_AT(B + 26);
-            case B + 27:
-                return MPARK_DISPATCH_AT(B + 27);
-            case B + 28:
-                return MPARK_DISPATCH_AT(B + 28);
-            case B + 29:
-                return MPARK_DISPATCH_AT(B + 29);
-            case B + 30:
-                return MPARK_DISPATCH_AT(B + 30);
-            case B + 31:
-                return MPARK_DISPATCH_AT(B + 31);
-            default:
-                return MPARK_DEFAULT(B + 32);
+              case B + 0: return MPARK_DISPATCH_AT(B + 0);
+              case B + 1: return MPARK_DISPATCH_AT(B + 1);
+              case B + 2: return MPARK_DISPATCH_AT(B + 2);
+              case B + 3: return MPARK_DISPATCH_AT(B + 3);
+              case B + 4: return MPARK_DISPATCH_AT(B + 4);
+              case B + 5: return MPARK_DISPATCH_AT(B + 5);
+              case B + 6: return MPARK_DISPATCH_AT(B + 6);
+              case B + 7: return MPARK_DISPATCH_AT(B + 7);
+              case B + 8: return MPARK_DISPATCH_AT(B + 8);
+              case B + 9: return MPARK_DISPATCH_AT(B + 9);
+              case B + 10: return MPARK_DISPATCH_AT(B + 10);
+              case B + 11: return MPARK_DISPATCH_AT(B + 11);
+              case B + 12: return MPARK_DISPATCH_AT(B + 12);
+              case B + 13: return MPARK_DISPATCH_AT(B + 13);
+              case B + 14: return MPARK_DISPATCH_AT(B + 14);
+              case B + 15: return MPARK_DISPATCH_AT(B + 15);
+              case B + 16: return MPARK_DISPATCH_AT(B + 16);
+              case B + 17: return MPARK_DISPATCH_AT(B + 17);
+              case B + 18: return MPARK_DISPATCH_AT(B + 18);
+              case B + 19: return MPARK_DISPATCH_AT(B + 19);
+              case B + 20: return MPARK_DISPATCH_AT(B + 20);
+              case B + 21: return MPARK_DISPATCH_AT(B + 21);
+              case B + 22: return MPARK_DISPATCH_AT(B + 22);
+              case B + 23: return MPARK_DISPATCH_AT(B + 23);
+              case B + 24: return MPARK_DISPATCH_AT(B + 24);
+              case B + 25: return MPARK_DISPATCH_AT(B + 25);
+              case B + 26: return MPARK_DISPATCH_AT(B + 26);
+              case B + 27: return MPARK_DISPATCH_AT(B + 27);
+              case B + 28: return MPARK_DISPATCH_AT(B + 28);
+              case B + 29: return MPARK_DISPATCH_AT(B + 29);
+              case B + 30: return MPARK_DISPATCH_AT(B + 30);
+              case B + 31: return MPARK_DISPATCH_AT(B + 31);
+              default: return MPARK_DEFAULT(B + 32);
             }
 
 #undef MPARK_DEFAULT
 #undef MPARK_DISPATCH_AT
-        }
-    };
+          }
+        };
 #else
-    template<typename T>
-    inline static constexpr const T &at(const T &elem) noexcept
-    {
-        return elem;
-    }
+        template <typename T>
+        inline static constexpr const T &at(const T &elem) noexcept {
+          return elem;
+        }
 
-    template<typename T, std::size_t N, typename... Is>
-    inline static constexpr const lib::remove_all_extents_t<T> &
-    at(const lib::array<T, N> &elems, std::size_t i, Is... is) noexcept
-    {
-        return at(elems[i], is...);
-    }
+        template <typename T, std::size_t N, typename... Is>
+        inline static constexpr const lib::remove_all_extents_t<T> &at(
+            const lib::array<T, N> &elems, std::size_t i, Is... is) noexcept {
+          return at(elems[i], is...);
+        }
 
-    template<typename F, typename... Fs>
-    inline static constexpr lib::array<lib::decay_t<F>, sizeof...(Fs) + 1>
-    make_farray(F &&f, Fs &&...fs)
-    {
-        return {{lib::forward<F>(f), lib::forward<Fs>(fs)...}};
-    }
+        template <typename F, typename... Fs>
+        inline static constexpr lib::array<lib::decay_t<F>, sizeof...(Fs) + 1>
+        make_farray(F &&f, Fs &&... fs) {
+          return {{lib::forward<F>(f), lib::forward<Fs>(fs)...}};
+        }
 
-    template<typename F, typename... Vs>
-    struct make_fmatrix_impl {
+        template <typename F, typename... Vs>
+        struct make_fmatrix_impl {
 
-        template<std::size_t... Is>
-        inline static constexpr dispatch_result_t<F, Vs...> dispatch(F &&f,
-                                                                     Vs &&...vs)
-        {
+          template <std::size_t... Is>
+          inline static constexpr dispatch_result_t<F, Vs...> dispatch(
+              F &&f, Vs &&... vs) {
             using Expected = dispatch_result_t<F, Vs...>;
             using Actual = decltype(lib::invoke(
                 lib::forward<F>(f),
@@ -1513,859 +1391,823 @@ struct base {
             return visit_return_type_check<Expected, Actual>::invoke(
                 lib::forward<F>(f),
                 access::base::get_alt<Is>(lib::forward<Vs>(vs))...);
-        }
+          }
 
 #ifdef MPARK_RETURN_TYPE_DEDUCTION
-        template<std::size_t... Is>
-        inline static constexpr auto impl(lib::index_sequence<Is...>)
-        {
+          template <std::size_t... Is>
+          inline static constexpr auto impl(lib::index_sequence<Is...>) {
             return &dispatch<Is...>;
-        }
+          }
 
-        template<typename Is, std::size_t... Js, typename... Ls>
-        inline static constexpr auto
-        impl(Is, lib::index_sequence<Js...>, Ls... ls)
-        {
+          template <typename Is, std::size_t... Js, typename... Ls>
+          inline static constexpr auto impl(Is,
+                                            lib::index_sequence<Js...>,
+                                            Ls... ls) {
             return make_farray(impl(lib::push_back_t<Is, Js>{}, ls...)...);
-        }
+          }
 #else
-        template<typename...>
-        struct impl;
+          template <typename...>
+          struct impl;
 
-        template<std::size_t... Is>
-        struct impl<lib::index_sequence<Is...>> {
+          template <std::size_t... Is>
+          struct impl<lib::index_sequence<Is...>> {
             inline constexpr AUTO operator()() const
-                AUTO_RETURN(&dispatch<Is...>)
-        };
+              AUTO_RETURN(&dispatch<Is...>)
+          };
 
-        template<typename Is, std::size_t... Js, typename... Ls>
-        struct impl<Is, lib::index_sequence<Js...>, Ls...> {
-            inline constexpr AUTO operator()() const AUTO_RETURN(
-                make_farray(impl<lib::push_back_t<Is, Js>, Ls...>{}()...))
-        };
+          template <typename Is, std::size_t... Js, typename... Ls>
+          struct impl<Is, lib::index_sequence<Js...>, Ls...> {
+            inline constexpr AUTO operator()() const
+              AUTO_RETURN(
+                  make_farray(impl<lib::push_back_t<Is, Js>, Ls...>{}()...))
+          };
 #endif
-    };
+        };
 
 #ifdef MPARK_RETURN_TYPE_DEDUCTION
-    template<typename F, typename... Vs>
-    inline static constexpr auto make_fmatrix()
-    {
-        return make_fmatrix_impl<F, Vs...>::impl(
-            lib::index_sequence<>{},
-            lib::make_index_sequence<lib::decay_t<Vs>::size()>{}...);
-    }
+        template <typename F, typename... Vs>
+        inline static constexpr auto make_fmatrix() {
+          return make_fmatrix_impl<F, Vs...>::impl(
+              lib::index_sequence<>{},
+              lib::make_index_sequence<lib::decay_t<Vs>::size()>{}...);
+        }
 #else
-    template<typename F, typename... Vs>
-    inline static constexpr AUTO make_fmatrix()
-        AUTO_RETURN(typename make_fmatrix_impl<F, Vs...>::template impl<
-                    lib::index_sequence<>,
-                    lib::make_index_sequence<lib::decay_t<Vs>::size()>...>{}())
+        template <typename F, typename... Vs>
+        inline static constexpr AUTO make_fmatrix()
+          AUTO_RETURN(
+              typename make_fmatrix_impl<F, Vs...>::template impl<
+                  lib::index_sequence<>,
+                  lib::make_index_sequence<lib::decay_t<Vs>::size()>...>{}())
 #endif
 
-    template<typename F, typename... Vs>
-    struct make_fdiagonal_impl {
-        template<std::size_t I>
-        inline static constexpr dispatch_result_t<F, Vs...> dispatch(F &&f,
-                                                                     Vs &&...vs)
-        {
+        template <typename F, typename... Vs>
+        struct make_fdiagonal_impl {
+          template <std::size_t I>
+          inline static constexpr dispatch_result_t<F, Vs...> dispatch(
+              F &&f, Vs &&... vs) {
             using Expected = dispatch_result_t<F, Vs...>;
-            using Actual = decltype(lib::invoke(
-                lib::forward<F>(f),
-                access::base::get_alt<I>(lib::forward<Vs>(vs))...));
+            using Actual = decltype(
+                lib::invoke(lib::forward<F>(f),
+                            access::base::get_alt<I>(lib::forward<Vs>(vs))...));
             return visit_return_type_check<Expected, Actual>::invoke(
                 lib::forward<F>(f),
                 access::base::get_alt<I>(lib::forward<Vs>(vs))...);
-        }
+          }
 
-        template<std::size_t... Is>
-        inline static constexpr AUTO impl(lib::index_sequence<Is...>)
+          template <std::size_t... Is>
+          inline static constexpr AUTO impl(lib::index_sequence<Is...>)
             AUTO_RETURN(make_farray(&dispatch<Is>...))
-    };
+        };
 
-    template<typename F, typename V, typename... Vs>
-    inline static constexpr auto make_fdiagonal()
-        -> decltype(make_fdiagonal_impl<F, V, Vs...>::impl(
-            lib::make_index_sequence<lib::decay_t<V>::size()>{}))
-    {
-        static_assert(lib::all<(lib::decay_t<V>::size()
-                                == lib::decay_t<Vs>::size())...>::value,
-                      "all of the variants must be the same size.");
-        return make_fdiagonal_impl<F, V, Vs...>::impl(
-            lib::make_index_sequence<lib::decay_t<V>::size()>{});
-    }
-#endif
-};
-
-#if !defined(MPARK_VARIANT_SWITCH_VISIT)                                       \
-    && (!defined(_MSC_VER) || _MSC_VER >= 1910)
-template<typename F, typename... Vs>
-using fmatrix_t = decltype(base::make_fmatrix<F, Vs...>());
-
-template<typename F, typename... Vs>
-struct fmatrix {
-    static constexpr fmatrix_t<F, Vs...> value = base::make_fmatrix<F, Vs...>();
-};
-
-template<typename F, typename... Vs>
-constexpr fmatrix_t<F, Vs...> fmatrix<F, Vs...>::value;
-
-template<typename F, typename... Vs>
-using fdiagonal_t = decltype(base::make_fdiagonal<F, Vs...>());
-
-template<typename F, typename... Vs>
-struct fdiagonal {
-    static constexpr fdiagonal_t<F, Vs...> value =
-        base::make_fdiagonal<F, Vs...>();
-};
-
-template<typename F, typename... Vs>
-constexpr fdiagonal_t<F, Vs...> fdiagonal<F, Vs...>::value;
-#endif
-
-struct alt {
-    template<typename Visitor, typename... Vs>
-    inline static constexpr DECLTYPE_AUTO visit_alt(Visitor &&visitor,
-                                                    Vs &&...vs)
-#ifdef MPARK_VARIANT_SWITCH_VISIT
-        DECLTYPE_AUTO_RETURN(
-            base::dispatcher<true,
-                             base::dispatch_result_t<
-                                 Visitor,
-                                 decltype(as_base(lib::forward<Vs>(vs)))...>>::
-                template dispatch<0>(lib::forward<Visitor>(visitor),
-                                     as_base(lib::forward<Vs>(vs))...))
-#elif !defined(_MSC_VER) || _MSC_VER >= 1910
-        DECLTYPE_AUTO_RETURN(
-            base::at(fmatrix<Visitor &&,
-                             decltype(as_base(lib::forward<Vs>(vs)))...>::value,
-                     vs.index()...)(lib::forward<Visitor>(visitor),
-                                    as_base(lib::forward<Vs>(vs))...))
-#else
-        DECLTYPE_AUTO_RETURN(base::at(
-            base::make_fmatrix<Visitor &&,
-                               decltype(as_base(lib::forward<Vs>(vs)))...>(),
-            vs.index()...)(lib::forward<Visitor>(visitor),
-                           as_base(lib::forward<Vs>(vs))...))
-#endif
-
-            template<typename Visitor, typename... Vs>
-            inline static constexpr DECLTYPE_AUTO
-        visit_alt_at(std::size_t index, Visitor &&visitor, Vs &&...vs)
-#ifdef MPARK_VARIANT_SWITCH_VISIT
-            DECLTYPE_AUTO_RETURN(
-                base::dispatcher<
-                    true,
-                    base::dispatch_result_t<
-                        Visitor,
-                        decltype(as_base(lib::forward<Vs>(vs)))...>>::
-                    template dispatch_at<0>(index,
-                                            lib::forward<Visitor>(visitor),
-                                            as_base(lib::forward<Vs>(vs))...))
-#elif !defined(_MSC_VER) || _MSC_VER >= 1910
-            DECLTYPE_AUTO_RETURN(base::at(
-                fdiagonal<Visitor &&,
-                          decltype(as_base(lib::forward<Vs>(vs)))...>::value,
-                index)(lib::forward<Visitor>(visitor),
-                       as_base(lib::forward<Vs>(vs))...))
-#else
-            DECLTYPE_AUTO_RETURN(
-                base::at(base::make_fdiagonal<
-                             Visitor &&,
-                             decltype(as_base(lib::forward<Vs>(vs)))...>(),
-                         index)(lib::forward<Visitor>(visitor),
-                                as_base(lib::forward<Vs>(vs))...))
-#endif
-};
-
-struct variant {
-private:
-    template<typename Visitor>
-    struct visitor {
-        template<typename... Values>
-        inline static constexpr bool does_not_handle()
-        {
-            return lib::is_invocable<Visitor, Values...>::value;
+        template <typename F, typename V, typename... Vs>
+        inline static constexpr auto make_fdiagonal()
+            -> decltype(make_fdiagonal_impl<F, V, Vs...>::impl(
+                lib::make_index_sequence<lib::decay_t<V>::size()>{})) {
+          static_assert(lib::all<(lib::decay_t<V>::size() ==
+                                  lib::decay_t<Vs>::size())...>::value,
+                        "all of the variants must be the same size.");
+          return make_fdiagonal_impl<F, V, Vs...>::impl(
+              lib::make_index_sequence<lib::decay_t<V>::size()>{});
         }
-    };
+#endif
+      };
 
-    template<typename Visitor, typename... Values>
-    struct visit_exhaustiveness_check {
-        static_assert(visitor<Visitor>::template does_not_handle<Values...>(),
-                      "`visit` requires the visitor to be exhaustive.");
+#if !defined(MPARK_VARIANT_SWITCH_VISIT) && \
+    (!defined(_MSC_VER) || _MSC_VER >= 1910)
+      template <typename F, typename... Vs>
+      using fmatrix_t = decltype(base::make_fmatrix<F, Vs...>());
 
-        inline static constexpr DECLTYPE_AUTO invoke(Visitor &&visitor,
-                                                     Values &&...values)
+      template <typename F, typename... Vs>
+      struct fmatrix {
+        static constexpr fmatrix_t<F, Vs...> value =
+            base::make_fmatrix<F, Vs...>();
+      };
+
+      template <typename F, typename... Vs>
+      constexpr fmatrix_t<F, Vs...> fmatrix<F, Vs...>::value;
+
+      template <typename F, typename... Vs>
+      using fdiagonal_t = decltype(base::make_fdiagonal<F, Vs...>());
+
+      template <typename F, typename... Vs>
+      struct fdiagonal {
+        static constexpr fdiagonal_t<F, Vs...> value =
+            base::make_fdiagonal<F, Vs...>();
+      };
+
+      template <typename F, typename... Vs>
+      constexpr fdiagonal_t<F, Vs...> fdiagonal<F, Vs...>::value;
+#endif
+
+      struct alt {
+        template <typename Visitor, typename... Vs>
+        inline static constexpr DECLTYPE_AUTO visit_alt(Visitor &&visitor,
+                                                        Vs &&... vs)
+#ifdef MPARK_VARIANT_SWITCH_VISIT
+          DECLTYPE_AUTO_RETURN(
+              base::dispatcher<
+                  true,
+                  base::dispatch_result_t<Visitor,
+                                          decltype(as_base(
+                                              lib::forward<Vs>(vs)))...>>::
+                  template dispatch<0>(lib::forward<Visitor>(visitor),
+                                       as_base(lib::forward<Vs>(vs))...))
+#elif !defined(_MSC_VER) || _MSC_VER >= 1910
+          DECLTYPE_AUTO_RETURN(base::at(
+              fmatrix<Visitor &&,
+                      decltype(as_base(lib::forward<Vs>(vs)))...>::value,
+              vs.index()...)(lib::forward<Visitor>(visitor),
+                             as_base(lib::forward<Vs>(vs))...))
+#else
+          DECLTYPE_AUTO_RETURN(base::at(
+              base::make_fmatrix<Visitor &&,
+                      decltype(as_base(lib::forward<Vs>(vs)))...>(),
+              vs.index()...)(lib::forward<Visitor>(visitor),
+                             as_base(lib::forward<Vs>(vs))...))
+#endif
+
+        template <typename Visitor, typename... Vs>
+        inline static constexpr DECLTYPE_AUTO visit_alt_at(std::size_t index,
+                                                           Visitor &&visitor,
+                                                           Vs &&... vs)
+#ifdef MPARK_VARIANT_SWITCH_VISIT
+          DECLTYPE_AUTO_RETURN(
+              base::dispatcher<
+                  true,
+                  base::dispatch_result_t<Visitor,
+                                          decltype(as_base(
+                                              lib::forward<Vs>(vs)))...>>::
+                  template dispatch_at<0>(index,
+                                          lib::forward<Visitor>(visitor),
+                                          as_base(lib::forward<Vs>(vs))...))
+#elif !defined(_MSC_VER) || _MSC_VER >= 1910
+          DECLTYPE_AUTO_RETURN(base::at(
+              fdiagonal<Visitor &&,
+                        decltype(as_base(lib::forward<Vs>(vs)))...>::value,
+              index)(lib::forward<Visitor>(visitor),
+                     as_base(lib::forward<Vs>(vs))...))
+#else
+          DECLTYPE_AUTO_RETURN(base::at(
+              base::make_fdiagonal<Visitor &&,
+                        decltype(as_base(lib::forward<Vs>(vs)))...>(),
+              index)(lib::forward<Visitor>(visitor),
+                     as_base(lib::forward<Vs>(vs))...))
+#endif
+      };
+
+      struct variant {
+        private:
+        template <typename Visitor>
+        struct visitor {
+          template <typename... Values>
+          inline static constexpr bool does_not_handle() {
+            return lib::is_invocable<Visitor, Values...>::value;
+          }
+        };
+
+        template <typename Visitor, typename... Values>
+        struct visit_exhaustiveness_check {
+          static_assert(visitor<Visitor>::template does_not_handle<Values...>(),
+                        "`visit` requires the visitor to be exhaustive.");
+
+          inline static constexpr DECLTYPE_AUTO invoke(Visitor &&visitor,
+                                                       Values &&... values)
             DECLTYPE_AUTO_RETURN(lib::invoke(lib::forward<Visitor>(visitor),
                                              lib::forward<Values>(values)...))
-    };
+        };
 
-    template<typename Visitor>
-    struct value_visitor {
-        Visitor &&visitor_;
+        template <typename Visitor>
+        struct value_visitor {
+          Visitor &&visitor_;
 
-        template<typename... Alts>
-        inline constexpr DECLTYPE_AUTO operator()(Alts &&...alts) const
+          template <typename... Alts>
+          inline constexpr DECLTYPE_AUTO operator()(Alts &&... alts) const
             DECLTYPE_AUTO_RETURN(
                 visit_exhaustiveness_check<
                     Visitor,
                     decltype((lib::forward<Alts>(alts).value))...>::
                     invoke(lib::forward<Visitor>(visitor_),
                            lib::forward<Alts>(alts).value...))
-    };
+        };
 
-    template<typename Visitor>
-    inline static constexpr AUTO make_value_visitor(Visitor &&visitor)
-        AUTO_RETURN(value_visitor<Visitor>{lib::forward<Visitor>(visitor)})
+        template <typename Visitor>
+        inline static constexpr AUTO make_value_visitor(Visitor &&visitor)
+          AUTO_RETURN(value_visitor<Visitor>{lib::forward<Visitor>(visitor)})
 
-            public
-        : template<typename Visitor, typename... Vs>
-          inline static constexpr DECLTYPE_AUTO
-          visit_alt(Visitor &&visitor, Vs &&...vs) DECLTYPE_AUTO_RETURN(
-              alt::visit_alt(lib::forward<Visitor>(visitor),
-                             lib::forward<Vs>(vs).impl_...))
+        public:
+        template <typename Visitor, typename... Vs>
+        inline static constexpr DECLTYPE_AUTO visit_alt(Visitor &&visitor,
+                                                        Vs &&... vs)
+          DECLTYPE_AUTO_RETURN(alt::visit_alt(lib::forward<Visitor>(visitor),
+                                              lib::forward<Vs>(vs).impl_...))
 
-              template<typename Visitor, typename... Vs>
-              inline static constexpr DECLTYPE_AUTO
-          visit_alt_at(std::size_t index, Visitor &&visitor, Vs &&...vs)
-              DECLTYPE_AUTO_RETURN(
-                  alt::visit_alt_at(index,
-                                    lib::forward<Visitor>(visitor),
-                                    lib::forward<Vs>(vs).impl_...))
+        template <typename Visitor, typename... Vs>
+        inline static constexpr DECLTYPE_AUTO visit_alt_at(std::size_t index,
+                                                           Visitor &&visitor,
+                                                           Vs &&... vs)
+          DECLTYPE_AUTO_RETURN(
+              alt::visit_alt_at(index,
+                                lib::forward<Visitor>(visitor),
+                                lib::forward<Vs>(vs).impl_...))
 
-                  template<typename Visitor, typename... Vs>
-                  inline static constexpr DECLTYPE_AUTO
-          visit_value(Visitor &&visitor, Vs &&...vs) DECLTYPE_AUTO_RETURN(
+        template <typename Visitor, typename... Vs>
+        inline static constexpr DECLTYPE_AUTO visit_value(Visitor &&visitor,
+                                                          Vs &&... vs)
+          DECLTYPE_AUTO_RETURN(
               visit_alt(make_value_visitor(lib::forward<Visitor>(visitor)),
                         lib::forward<Vs>(vs)...))
 
-              template<typename Visitor, typename... Vs>
-              inline static constexpr DECLTYPE_AUTO
-          visit_value_at(std::size_t index, Visitor &&visitor, Vs &&...vs)
-              DECLTYPE_AUTO_RETURN(visit_alt_at(
-                  index,
-                  make_value_visitor(lib::forward<Visitor>(visitor)),
-                  lib::forward<Vs>(vs)...))
-};
+        template <typename Visitor, typename... Vs>
+        inline static constexpr DECLTYPE_AUTO visit_value_at(std::size_t index,
+                                                             Visitor &&visitor,
+                                                             Vs &&... vs)
+          DECLTYPE_AUTO_RETURN(
+              visit_alt_at(index,
+                           make_value_visitor(lib::forward<Visitor>(visitor)),
+                           lib::forward<Vs>(vs)...))
+      };
 
-}// namespace visitation
+    }  // namespace visitation
 
-template<std::size_t Index, typename T>
-struct alt {
-    using value_type = T;
+    template <std::size_t Index, typename T>
+    struct alt {
+      using value_type = T;
 
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable : 4244)
 #endif
-    template<typename... Args>
-    inline explicit constexpr alt(in_place_t, Args &&...args)
-        : value(lib::forward<Args>(args)...)
-    {}
+      template <typename... Args>
+      inline explicit constexpr alt(in_place_t, Args &&... args)
+          : value(lib::forward<Args>(args)...) {}
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
 
-    T value;
-};
+      T value;
+    };
 
-template<Trait DestructibleTrait, std::size_t Index, typename... Ts>
-union recursive_union;
+    template <Trait DestructibleTrait, std::size_t Index, typename... Ts>
+    union recursive_union;
 
-template<Trait DestructibleTrait, std::size_t Index>
-union recursive_union<DestructibleTrait, Index> {};
+    template <Trait DestructibleTrait, std::size_t Index>
+    union recursive_union<DestructibleTrait, Index> {};
 
-#define MPARK_VARIANT_RECURSIVE_UNION(destructible_trait, destructor)          \
-    template<std::size_t Index, typename T, typename... Ts>                    \
-    union recursive_union<destructible_trait, Index, T, Ts...> {               \
-    public:                                                                    \
-        inline explicit constexpr recursive_union(valueless_t) noexcept        \
-            : dummy_{}                                                         \
-        {}                                                                     \
-                                                                               \
-        template<typename... Args>                                             \
-        inline explicit constexpr recursive_union(in_place_index_t<0>,         \
-                                                  Args &&...args)              \
-            : head_(in_place_t{}, lib::forward<Args>(args)...)                 \
-        {}                                                                     \
-                                                                               \
-        template<std::size_t I, typename... Args>                              \
-        inline explicit constexpr recursive_union(in_place_index_t<I>,         \
-                                                  Args &&...args)              \
-            : tail_(in_place_index_t<I - 1>{}, lib::forward<Args>(args)...)    \
-        {}                                                                     \
-                                                                               \
-        recursive_union(const recursive_union &) = default;                    \
-        recursive_union(recursive_union &&) = default;                         \
-                                                                               \
-        destructor                                                             \
-                                                                               \
-            recursive_union &                                                  \
-            operator=(const recursive_union &) = default;                      \
-        recursive_union &operator=(recursive_union &&) = default;              \
-                                                                               \
-    private:                                                                   \
-        char dummy_;                                                           \
-        alt<Index, T> head_;                                                   \
-        recursive_union<destructible_trait, Index + 1, Ts...> tail_;           \
-                                                                               \
-        friend struct access::recursive_union;                                 \
-    }
+#define MPARK_VARIANT_RECURSIVE_UNION(destructible_trait, destructor)      \
+  template <std::size_t Index, typename T, typename... Ts>                 \
+  union recursive_union<destructible_trait, Index, T, Ts...> {             \
+    public:                                                                \
+    inline explicit constexpr recursive_union(valueless_t) noexcept        \
+        : dummy_{} {}                                                      \
+                                                                           \
+    template <typename... Args>                                            \
+    inline explicit constexpr recursive_union(in_place_index_t<0>,         \
+                                              Args &&... args)             \
+        : head_(in_place_t{}, lib::forward<Args>(args)...) {}              \
+                                                                           \
+    template <std::size_t I, typename... Args>                             \
+    inline explicit constexpr recursive_union(in_place_index_t<I>,         \
+                                              Args &&... args)             \
+        : tail_(in_place_index_t<I - 1>{}, lib::forward<Args>(args)...) {} \
+                                                                           \
+    recursive_union(const recursive_union &) = default;                    \
+    recursive_union(recursive_union &&) = default;                         \
+                                                                           \
+    destructor                                                             \
+                                                                           \
+    recursive_union &operator=(const recursive_union &) = default;         \
+    recursive_union &operator=(recursive_union &&) = default;              \
+                                                                           \
+    private:                                                               \
+    char dummy_;                                                           \
+    alt<Index, T> head_;                                                   \
+    recursive_union<destructible_trait, Index + 1, Ts...> tail_;           \
+                                                                           \
+    friend struct access::recursive_union;                                 \
+  }
 
-MPARK_VARIANT_RECURSIVE_UNION(Trait::TriviallyAvailable,
-                              ~recursive_union() = default;);
-MPARK_VARIANT_RECURSIVE_UNION(Trait::Available, ~recursive_union(){});
-MPARK_VARIANT_RECURSIVE_UNION(Trait::Unavailable, ~recursive_union() = delete;);
+    MPARK_VARIANT_RECURSIVE_UNION(Trait::TriviallyAvailable,
+                                  ~recursive_union() = default;);
+    MPARK_VARIANT_RECURSIVE_UNION(Trait::Available,
+                                  ~recursive_union() {});
+    MPARK_VARIANT_RECURSIVE_UNION(Trait::Unavailable,
+                                  ~recursive_union() = delete;);
 
 #undef MPARK_VARIANT_RECURSIVE_UNION
 
-using index_t = unsigned int;
+    using index_t = unsigned int;
 
-template<Trait DestructibleTrait, typename... Ts>
-class base {
-public:
-    inline explicit constexpr base(valueless_t tag) noexcept
-        : data_(tag),
-          index_(static_cast<index_t>(-1))
-    {}
+    template <Trait DestructibleTrait, typename... Ts>
+    class base {
+      public:
+      inline explicit constexpr base(valueless_t tag) noexcept
+          : data_(tag), index_(static_cast<index_t>(-1)) {}
 
-    template<std::size_t I, typename... Args>
-    inline explicit constexpr base(in_place_index_t<I>, Args &&...args)
-        : data_(in_place_index_t<I>{}, lib::forward<Args>(args)...),
-          index_(I)
-    {}
+      template <std::size_t I, typename... Args>
+      inline explicit constexpr base(in_place_index_t<I>, Args &&... args)
+          : data_(in_place_index_t<I>{}, lib::forward<Args>(args)...),
+            index_(I) {}
 
-    inline constexpr bool valueless_by_exception() const noexcept
-    {
+      inline constexpr bool valueless_by_exception() const noexcept {
         return index_ == static_cast<index_t>(-1);
-    }
+      }
 
-    inline constexpr std::size_t index() const noexcept
-    {
+      inline constexpr std::size_t index() const noexcept {
         return valueless_by_exception() ? variant_npos : index_;
-    }
+      }
 
-protected:
-    using data_t = recursive_union<DestructibleTrait, 0, Ts...>;
+      protected:
+      using data_t = recursive_union<DestructibleTrait, 0, Ts...>;
 
-    friend inline constexpr base &as_base(base &b) { return b; }
+      friend inline constexpr base &as_base(base &b) { return b; }
+      friend inline constexpr const base &as_base(const base &b) { return b; }
+      friend inline constexpr base &&as_base(base &&b) { return lib::move(b); }
+      friend inline constexpr const base &&as_base(const base &&b) { return lib::move(b); }
 
-    friend inline constexpr const base &as_base(const base &b) { return b; }
+      friend inline constexpr data_t &data(base &b) { return b.data_; }
+      friend inline constexpr const data_t &data(const base &b) { return b.data_; }
+      friend inline constexpr data_t &&data(base &&b) { return lib::move(b).data_; }
+      friend inline constexpr const data_t &&data(const base &&b) { return lib::move(b).data_; }
 
-    friend inline constexpr base &&as_base(base &&b) { return lib::move(b); }
+      inline static constexpr std::size_t size() { return sizeof...(Ts); }
 
-    friend inline constexpr const base &&as_base(const base &&b)
-    {
-        return lib::move(b);
-    }
+      data_t data_;
+      index_t index_;
 
-    friend inline constexpr data_t &data(base &b) { return b.data_; }
+      friend struct access::base;
+      friend struct visitation::base;
+    };
 
-    friend inline constexpr const data_t &data(const base &b)
-    {
-        return b.data_;
-    }
-
-    friend inline constexpr data_t &&data(base &&b)
-    {
-        return lib::move(b).data_;
-    }
-
-    friend inline constexpr const data_t &&data(const base &&b)
-    {
-        return lib::move(b).data_;
-    }
-
-    inline static constexpr std::size_t size() { return sizeof...(Ts); }
-
-    data_t data_;
-    index_t index_;
-
-    friend struct access::base;
-    friend struct visitation::base;
-};
-
-struct dtor {
+    struct dtor {
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable : 4100)
 #endif
-    template<typename Alt>
-    inline void operator()(Alt &alt) const noexcept
-    {
-        alt.~Alt();
-    }
+      template <typename Alt>
+      inline void operator()(Alt &alt) const noexcept { alt.~Alt(); }
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
-};
+    };
 
 #if !defined(_MSC_VER) || _MSC_VER >= 1910
 #define MPARK_INHERITING_CTOR(type, base) using base::base;
 #else
-#define MPARK_INHERITING_CTOR(type, base)                                      \
-    template<typename... Args>                                                 \
-    inline explicit constexpr type(Args &&...args)                             \
-        : base(lib::forward<Args>(args)...)                                    \
-    {}
+#define MPARK_INHERITING_CTOR(type, base)         \
+  template <typename... Args>                     \
+  inline explicit constexpr type(Args &&... args) \
+      : base(lib::forward<Args>(args)...) {}
 #endif
 
-template<typename Traits, Trait = Traits::destructible_trait>
-class destructor;
+    template <typename Traits, Trait = Traits::destructible_trait>
+    class destructor;
 
-#define MPARK_VARIANT_DESTRUCTOR(destructible_trait, definition, destroy)      \
-    template<typename... Ts>                                                   \
-    class destructor<traits<Ts...>, destructible_trait>                        \
-        : public base<destructible_trait, Ts...> {                             \
-        using super = base<destructible_trait, Ts...>;                         \
-                                                                               \
-    public:                                                                    \
-        MPARK_INHERITING_CTOR(destructor, super)                               \
-        using super::operator=;                                                \
-                                                                               \
-        destructor(const destructor &) = default;                              \
-        destructor(destructor &&) = default;                                   \
-        definition destructor &operator=(const destructor &) = default;        \
-        destructor &operator=(destructor &&) = default;                        \
-                                                                               \
-    protected:                                                                 \
-        destroy                                                                \
-    }
+#define MPARK_VARIANT_DESTRUCTOR(destructible_trait, definition, destroy) \
+  template <typename... Ts>                                               \
+  class destructor<traits<Ts...>, destructible_trait>                     \
+      : public base<destructible_trait, Ts...> {                          \
+    using super = base<destructible_trait, Ts...>;                        \
+                                                                          \
+    public:                                                               \
+    MPARK_INHERITING_CTOR(destructor, super)                              \
+    using super::operator=;                                               \
+                                                                          \
+    destructor(const destructor &) = default;                             \
+    destructor(destructor &&) = default;                                  \
+    definition                                                            \
+    destructor &operator=(const destructor &) = default;                  \
+    destructor &operator=(destructor &&) = default;                       \
+                                                                          \
+    protected:                                                            \
+    destroy                                                               \
+  }
 
-MPARK_VARIANT_DESTRUCTOR(
-    Trait::TriviallyAvailable, ~destructor() = default;
-    , inline void destroy() noexcept {
-        this->index_ = static_cast<index_t>(-1);
-    });
+    MPARK_VARIANT_DESTRUCTOR(
+        Trait::TriviallyAvailable,
+        ~destructor() = default;,
+        inline void destroy() noexcept {
+          this->index_ = static_cast<index_t>(-1);
+        });
 
-MPARK_VARIANT_DESTRUCTOR(
-    Trait::Available,
-    ~destructor() { destroy(); },
-    inline void destroy() noexcept {
-        if (!this->valueless_by_exception()) {
+    MPARK_VARIANT_DESTRUCTOR(
+        Trait::Available,
+        ~destructor() { destroy(); },
+        inline void destroy() noexcept {
+          if (!this->valueless_by_exception()) {
             visitation::alt::visit_alt(dtor{}, *this);
-        }
-        this->index_ = static_cast<index_t>(-1);
-    });
+          }
+          this->index_ = static_cast<index_t>(-1);
+        });
 
-MPARK_VARIANT_DESTRUCTOR(Trait::Unavailable, ~destructor() = delete;
-                         , inline void destroy() noexcept = delete;);
+    MPARK_VARIANT_DESTRUCTOR(
+        Trait::Unavailable,
+        ~destructor() = delete;,
+        inline void destroy() noexcept = delete;);
 
 #undef MPARK_VARIANT_DESTRUCTOR
 
-template<typename Traits>
-class constructor : public destructor<Traits> {
-    using super = destructor<Traits>;
+    template <typename Traits>
+    class constructor : public destructor<Traits> {
+      using super = destructor<Traits>;
 
-public:
-    MPARK_INHERITING_CTOR(constructor, super)
-    using super::operator=;
+      public:
+      MPARK_INHERITING_CTOR(constructor, super)
+      using super::operator=;
 
-protected:
+      protected:
 #ifndef MPARK_GENERIC_LAMBDAS
-    struct ctor {
-        template<typename LhsAlt, typename RhsAlt>
-        inline void operator()(LhsAlt &lhs_alt, RhsAlt &&rhs_alt) const
-        {
-            constructor::construct_alt(lhs_alt,
-                                       lib::forward<RhsAlt>(rhs_alt).value);
+      struct ctor {
+        template <typename LhsAlt, typename RhsAlt>
+        inline void operator()(LhsAlt &lhs_alt, RhsAlt &&rhs_alt) const {
+          constructor::construct_alt(lhs_alt,
+                                     lib::forward<RhsAlt>(rhs_alt).value);
         }
-    };
+      };
 #endif
 
-    template<std::size_t I, typename T, typename... Args>
-    inline static T &construct_alt(alt<I, T> &a, Args &&...args)
-    {
+      template <std::size_t I, typename T, typename... Args>
+      inline static T &construct_alt(alt<I, T> &a, Args &&... args) {
         auto *result = ::new (static_cast<void *>(lib::addressof(a)))
             alt<I, T>(in_place_t{}, lib::forward<Args>(args)...);
         return result->value;
-    }
+      }
 
-    template<typename Rhs>
-    inline static void generic_construct(constructor &lhs, Rhs &&rhs)
-    {
+      template <typename Rhs>
+      inline static void generic_construct(constructor &lhs, Rhs &&rhs) {
         lhs.destroy();
         if (!rhs.valueless_by_exception()) {
-            visitation::alt::visit_alt_at(
-                rhs.index(),
+          visitation::alt::visit_alt_at(
+              rhs.index(),
 #ifdef MPARK_GENERIC_LAMBDAS
-                [](auto &lhs_alt, auto &&rhs_alt) {
-                    constructor::construct_alt(
-                        lhs_alt,
-                        lib::forward<decltype(rhs_alt)>(rhs_alt).value);
-                }
+              [](auto &lhs_alt, auto &&rhs_alt) {
+                constructor::construct_alt(
+                    lhs_alt, lib::forward<decltype(rhs_alt)>(rhs_alt).value);
+              }
 #else
-                ctor{}
+              ctor{}
 #endif
-                ,
-                lhs, lib::forward<Rhs>(rhs));
-            lhs.index_ = rhs.index_;
+              ,
+              lhs,
+              lib::forward<Rhs>(rhs));
+          lhs.index_ = rhs.index_;
         }
-    }
-};
+      }
+    };
 
-template<typename Traits, Trait = Traits::move_constructible_trait>
-class move_constructor;
+    template <typename Traits, Trait = Traits::move_constructible_trait>
+    class move_constructor;
 
-#define MPARK_VARIANT_MOVE_CONSTRUCTOR(move_constructible_trait, definition)   \
-    template<typename... Ts>                                                   \
-    class move_constructor<traits<Ts...>, move_constructible_trait>            \
-        : public constructor<traits<Ts...>> {                                  \
-        using super = constructor<traits<Ts...>>;                              \
-                                                                               \
-    public:                                                                    \
-        MPARK_INHERITING_CTOR(move_constructor, super)                         \
-        using super::operator=;                                                \
-                                                                               \
-        move_constructor(const move_constructor &) = default;                  \
-        definition ~move_constructor() = default;                              \
-        move_constructor &operator=(const move_constructor &) = default;       \
-        move_constructor &operator=(move_constructor &&) = default;            \
-    }
+#define MPARK_VARIANT_MOVE_CONSTRUCTOR(move_constructible_trait, definition) \
+  template <typename... Ts>                                                  \
+  class move_constructor<traits<Ts...>, move_constructible_trait>            \
+      : public constructor<traits<Ts...>> {                                  \
+    using super = constructor<traits<Ts...>>;                                \
+                                                                             \
+    public:                                                                  \
+    MPARK_INHERITING_CTOR(move_constructor, super)                           \
+    using super::operator=;                                                  \
+                                                                             \
+    move_constructor(const move_constructor &) = default;                    \
+    definition                                                               \
+    ~move_constructor() = default;                                           \
+    move_constructor &operator=(const move_constructor &) = default;         \
+    move_constructor &operator=(move_constructor &&) = default;              \
+  }
 
-MPARK_VARIANT_MOVE_CONSTRUCTOR(
-    Trait::TriviallyAvailable,
-    move_constructor(move_constructor &&that) = default;);
+    MPARK_VARIANT_MOVE_CONSTRUCTOR(
+        Trait::TriviallyAvailable,
+        move_constructor(move_constructor &&that) = default;);
 
-MPARK_VARIANT_MOVE_CONSTRUCTOR(
-    Trait::Available,
-    move_constructor(move_constructor &&that) noexcept(
-        lib::all<std::is_nothrow_move_constructible<Ts>::value...>::value)
-    : move_constructor(valueless_t{}) {
-        this->generic_construct(*this, lib::move(that));
-    });
+    MPARK_VARIANT_MOVE_CONSTRUCTOR(
+        Trait::Available,
+        move_constructor(move_constructor &&that) noexcept(
+            lib::all<std::is_nothrow_move_constructible<Ts>::value...>::value)
+            : move_constructor(valueless_t{}) {
+          this->generic_construct(*this, lib::move(that));
+        });
 
-MPARK_VARIANT_MOVE_CONSTRUCTOR(Trait::Unavailable,
-                               move_constructor(move_constructor &&) = delete;);
+    MPARK_VARIANT_MOVE_CONSTRUCTOR(
+        Trait::Unavailable,
+        move_constructor(move_constructor &&) = delete;);
 
 #undef MPARK_VARIANT_MOVE_CONSTRUCTOR
 
-template<typename Traits, Trait = Traits::copy_constructible_trait>
-class copy_constructor;
+    template <typename Traits, Trait = Traits::copy_constructible_trait>
+    class copy_constructor;
 
-#define MPARK_VARIANT_COPY_CONSTRUCTOR(copy_constructible_trait, definition)   \
-    template<typename... Ts>                                                   \
-    class copy_constructor<traits<Ts...>, copy_constructible_trait>            \
-        : public move_constructor<traits<Ts...>> {                             \
-        using super = move_constructor<traits<Ts...>>;                         \
-                                                                               \
-    public:                                                                    \
-        MPARK_INHERITING_CTOR(copy_constructor, super)                         \
-        using super::operator=;                                                \
-                                                                               \
-        definition copy_constructor(copy_constructor &&) = default;            \
-        ~copy_constructor() = default;                                         \
-        copy_constructor &operator=(const copy_constructor &) = default;       \
-        copy_constructor &operator=(copy_constructor &&) = default;            \
-    }
+#define MPARK_VARIANT_COPY_CONSTRUCTOR(copy_constructible_trait, definition) \
+  template <typename... Ts>                                                  \
+  class copy_constructor<traits<Ts...>, copy_constructible_trait>            \
+      : public move_constructor<traits<Ts...>> {                             \
+    using super = move_constructor<traits<Ts...>>;                           \
+                                                                             \
+    public:                                                                  \
+    MPARK_INHERITING_CTOR(copy_constructor, super)                           \
+    using super::operator=;                                                  \
+                                                                             \
+    definition                                                               \
+    copy_constructor(copy_constructor &&) = default;                         \
+    ~copy_constructor() = default;                                           \
+    copy_constructor &operator=(const copy_constructor &) = default;         \
+    copy_constructor &operator=(copy_constructor &&) = default;              \
+  }
 
-MPARK_VARIANT_COPY_CONSTRUCTOR(
-    Trait::TriviallyAvailable,
-    copy_constructor(const copy_constructor &that) = default;);
+    MPARK_VARIANT_COPY_CONSTRUCTOR(
+        Trait::TriviallyAvailable,
+        copy_constructor(const copy_constructor &that) = default;);
 
-MPARK_VARIANT_COPY_CONSTRUCTOR(
-    Trait::Available, copy_constructor(const copy_constructor &that)
-    : copy_constructor(valueless_t{}) {
-        this->generic_construct(*this, that);
-    });
+    MPARK_VARIANT_COPY_CONSTRUCTOR(
+        Trait::Available,
+        copy_constructor(const copy_constructor &that)
+            : copy_constructor(valueless_t{}) {
+          this->generic_construct(*this, that);
+        });
 
-MPARK_VARIANT_COPY_CONSTRUCTOR(
-    Trait::Unavailable, copy_constructor(const copy_constructor &) = delete;);
+    MPARK_VARIANT_COPY_CONSTRUCTOR(
+        Trait::Unavailable,
+        copy_constructor(const copy_constructor &) = delete;);
 
 #undef MPARK_VARIANT_COPY_CONSTRUCTOR
 
-template<typename Traits>
-class assignment : public copy_constructor<Traits> {
-    using super = copy_constructor<Traits>;
+    template <typename Traits>
+    class assignment : public copy_constructor<Traits> {
+      using super = copy_constructor<Traits>;
 
-public:
-    MPARK_INHERITING_CTOR(assignment, super)
-    using super::operator=;
+      public:
+      MPARK_INHERITING_CTOR(assignment, super)
+      using super::operator=;
 
-    template<std::size_t I, typename... Args>
-    inline /* auto & */ auto emplace(Args &&...args)
-        -> decltype(this->construct_alt(access::base::get_alt<I>(*this),
-                                        lib::forward<Args>(args)...))
-    {
+      template <std::size_t I, typename... Args>
+      inline /* auto & */ auto emplace(Args &&... args)
+          -> decltype(this->construct_alt(access::base::get_alt<I>(*this),
+                                          lib::forward<Args>(args)...)) {
         this->destroy();
         auto &result = this->construct_alt(access::base::get_alt<I>(*this),
                                            lib::forward<Args>(args)...);
         this->index_ = I;
         return result;
-    }
+      }
 
-protected:
+      protected:
 #ifndef MPARK_GENERIC_LAMBDAS
-    template<typename That>
-    struct assigner {
-        template<typename ThisAlt, typename ThatAlt>
-        inline void operator()(ThisAlt &this_alt, ThatAlt &&that_alt) const
-        {
-            self->assign_alt(this_alt, lib::forward<ThatAlt>(that_alt).value);
+      template <typename That>
+      struct assigner {
+        template <typename ThisAlt, typename ThatAlt>
+        inline void operator()(ThisAlt &this_alt, ThatAlt &&that_alt) const {
+          self->assign_alt(this_alt, lib::forward<ThatAlt>(that_alt).value);
         }
-
         assignment *self;
-    };
+      };
 #endif
 
-    template<std::size_t I, typename T, typename Arg>
-    inline void assign_alt(alt<I, T> &a, Arg &&arg)
-    {
+      template <std::size_t I, typename T, typename Arg>
+      inline void assign_alt(alt<I, T> &a, Arg &&arg) {
         if (this->index() == I) {
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable : 4244)
 #endif
-            a.value = lib::forward<Arg>(arg);
+          a.value = lib::forward<Arg>(arg);
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
         } else {
-            struct {
-                void operator()(std::true_type) const
-                {
-                    this_->emplace<I>(lib::forward<Arg>(arg_));
-                }
-
-                void operator()(std::false_type) const
-                {
-                    this_->emplace<I>(T(lib::forward<Arg>(arg_)));
-                }
-
-                assignment *this_;
-                Arg &&arg_;
-            } impl{this, lib::forward<Arg>(arg)};
-
-            impl(lib::bool_constant
-                     < std::is_nothrow_constructible<T, Arg>::value
-                 || !std::is_nothrow_move_constructible<T>::value > {});
+          struct {
+            void operator()(std::true_type) const {
+              this_->emplace<I>(lib::forward<Arg>(arg_));
+            }
+            void operator()(std::false_type) const {
+              this_->emplace<I>(T(lib::forward<Arg>(arg_)));
+            }
+            assignment *this_;
+            Arg &&arg_;
+          } impl{this, lib::forward<Arg>(arg)};
+          impl(lib::bool_constant<
+                   std::is_nothrow_constructible<T, Arg>::value ||
+                   !std::is_nothrow_move_constructible<T>::value>{});
         }
-    }
+      }
 
-    template<typename That>
-    inline void generic_assign(That &&that)
-    {
+      template <typename That>
+      inline void generic_assign(That &&that) {
         if (this->valueless_by_exception() && that.valueless_by_exception()) {
-            // do nothing.
+          // do nothing.
         } else if (that.valueless_by_exception()) {
-            this->destroy();
+          this->destroy();
         } else {
-            visitation::alt::visit_alt_at(
-                that.index(),
+          visitation::alt::visit_alt_at(
+              that.index(),
 #ifdef MPARK_GENERIC_LAMBDAS
-                [this](auto &this_alt, auto &&that_alt) {
-                    this->assign_alt(
-                        this_alt,
-                        lib::forward<decltype(that_alt)>(that_alt).value);
-                }
+              [this](auto &this_alt, auto &&that_alt) {
+                this->assign_alt(
+                    this_alt, lib::forward<decltype(that_alt)>(that_alt).value);
+              }
 #else
-                assigner<That>{this}
+              assigner<That>{this}
 #endif
-                ,
-                *this, lib::forward<That>(that));
+              ,
+              *this,
+              lib::forward<That>(that));
         }
-    }
-};
+      }
+    };
 
-template<typename Traits, Trait = Traits::move_assignable_trait>
-class move_assignment;
+    template <typename Traits, Trait = Traits::move_assignable_trait>
+    class move_assignment;
 
-#define MPARK_VARIANT_MOVE_ASSIGNMENT(move_assignable_trait, definition)       \
-    template<typename... Ts>                                                   \
-    class move_assignment<traits<Ts...>, move_assignable_trait>                \
-        : public assignment<traits<Ts...>> {                                   \
-        using super = assignment<traits<Ts...>>;                               \
-                                                                               \
-    public:                                                                    \
-        MPARK_INHERITING_CTOR(move_assignment, super)                          \
-        using super::operator=;                                                \
-                                                                               \
-        move_assignment(const move_assignment &) = default;                    \
-        move_assignment(move_assignment &&) = default;                         \
-        ~move_assignment() = default;                                          \
-        move_assignment &operator=(const move_assignment &) = default;         \
-        definition                                                             \
-    }
+#define MPARK_VARIANT_MOVE_ASSIGNMENT(move_assignable_trait, definition) \
+  template <typename... Ts>                                              \
+  class move_assignment<traits<Ts...>, move_assignable_trait>            \
+      : public assignment<traits<Ts...>> {                               \
+    using super = assignment<traits<Ts...>>;                             \
+                                                                         \
+    public:                                                              \
+    MPARK_INHERITING_CTOR(move_assignment, super)                        \
+    using super::operator=;                                              \
+                                                                         \
+    move_assignment(const move_assignment &) = default;                  \
+    move_assignment(move_assignment &&) = default;                       \
+    ~move_assignment() = default;                                        \
+    move_assignment &operator=(const move_assignment &) = default;       \
+    definition                                                           \
+  }
 
-MPARK_VARIANT_MOVE_ASSIGNMENT(
-    Trait::TriviallyAvailable,
-    move_assignment &operator=(move_assignment &&that) = default;);
+    MPARK_VARIANT_MOVE_ASSIGNMENT(
+        Trait::TriviallyAvailable,
+        move_assignment &operator=(move_assignment &&that) = default;);
 
-MPARK_VARIANT_MOVE_ASSIGNMENT(
-    Trait::Available,
-    move_assignment &
-    operator=(move_assignment &&that) noexcept(
-        lib::all<(std::is_nothrow_move_constructible<Ts>::value
-                  && std::is_nothrow_move_assignable<Ts>::value)...>::value) {
-        this->generic_assign(lib::move(that));
-        return *this;
-    });
+    MPARK_VARIANT_MOVE_ASSIGNMENT(
+        Trait::Available,
+        move_assignment &
+        operator=(move_assignment &&that) noexcept(
+            lib::all<(std::is_nothrow_move_constructible<Ts>::value &&
+                      std::is_nothrow_move_assignable<Ts>::value)...>::value) {
+          this->generic_assign(lib::move(that));
+          return *this;
+        });
 
-MPARK_VARIANT_MOVE_ASSIGNMENT(
-    Trait::Unavailable,
-    move_assignment &operator=(move_assignment &&) = delete;);
+    MPARK_VARIANT_MOVE_ASSIGNMENT(
+        Trait::Unavailable,
+        move_assignment &operator=(move_assignment &&) = delete;);
 
 #undef MPARK_VARIANT_MOVE_ASSIGNMENT
 
-template<typename Traits, Trait = Traits::copy_assignable_trait>
-class copy_assignment;
+    template <typename Traits, Trait = Traits::copy_assignable_trait>
+    class copy_assignment;
 
-#define MPARK_VARIANT_COPY_ASSIGNMENT(copy_assignable_trait, definition)       \
-    template<typename... Ts>                                                   \
-    class copy_assignment<traits<Ts...>, copy_assignable_trait>                \
-        : public move_assignment<traits<Ts...>> {                              \
-        using super = move_assignment<traits<Ts...>>;                          \
-                                                                               \
-    public:                                                                    \
-        MPARK_INHERITING_CTOR(copy_assignment, super)                          \
-        using super::operator=;                                                \
-                                                                               \
-        copy_assignment(const copy_assignment &) = default;                    \
-        copy_assignment(copy_assignment &&) = default;                         \
-        ~copy_assignment() = default;                                          \
-        definition copy_assignment &operator=(copy_assignment &&) = default;   \
-    }
+#define MPARK_VARIANT_COPY_ASSIGNMENT(copy_assignable_trait, definition) \
+  template <typename... Ts>                                              \
+  class copy_assignment<traits<Ts...>, copy_assignable_trait>            \
+      : public move_assignment<traits<Ts...>> {                          \
+    using super = move_assignment<traits<Ts...>>;                        \
+                                                                         \
+    public:                                                              \
+    MPARK_INHERITING_CTOR(copy_assignment, super)                        \
+    using super::operator=;                                              \
+                                                                         \
+    copy_assignment(const copy_assignment &) = default;                  \
+    copy_assignment(copy_assignment &&) = default;                       \
+    ~copy_assignment() = default;                                        \
+    definition                                                           \
+    copy_assignment &operator=(copy_assignment &&) = default;            \
+  }
 
-MPARK_VARIANT_COPY_ASSIGNMENT(
-    Trait::TriviallyAvailable,
-    copy_assignment &operator=(const copy_assignment &that) = default;);
+    MPARK_VARIANT_COPY_ASSIGNMENT(
+        Trait::TriviallyAvailable,
+        copy_assignment &operator=(const copy_assignment &that) = default;);
 
-MPARK_VARIANT_COPY_ASSIGNMENT(
-    Trait::Available,
-    copy_assignment &
-    operator=(const copy_assignment &that) {
-        this->generic_assign(that);
-        return *this;
-    });
+    MPARK_VARIANT_COPY_ASSIGNMENT(
+        Trait::Available,
+        copy_assignment &operator=(const copy_assignment &that) {
+          this->generic_assign(that);
+          return *this;
+        });
 
-MPARK_VARIANT_COPY_ASSIGNMENT(
-    Trait::Unavailable,
-    copy_assignment &operator=(const copy_assignment &) = delete;);
+    MPARK_VARIANT_COPY_ASSIGNMENT(
+        Trait::Unavailable,
+        copy_assignment &operator=(const copy_assignment &) = delete;);
 
 #undef MPARK_VARIANT_COPY_ASSIGNMENT
 
-template<typename... Ts>
-class impl : public copy_assignment<traits<Ts...>> {
-    using super = copy_assignment<traits<Ts...>>;
+    template <typename... Ts>
+    class impl : public copy_assignment<traits<Ts...>> {
+      using super = copy_assignment<traits<Ts...>>;
 
-public:
-    MPARK_INHERITING_CTOR(impl, super)
-    using super::operator=;
+      public:
+      MPARK_INHERITING_CTOR(impl, super)
+      using super::operator=;
 
-    template<std::size_t I, typename Arg>
-    inline void assign(Arg &&arg)
-    {
+      template <std::size_t I, typename Arg>
+      inline void assign(Arg &&arg) {
         this->assign_alt(access::base::get_alt<I>(*this),
                          lib::forward<Arg>(arg));
-    }
+      }
 
-    inline void swap(impl &that)
-    {
+      inline void swap(impl &that) {
         if (this->valueless_by_exception() && that.valueless_by_exception()) {
-            // do nothing.
+          // do nothing.
         } else if (this->index() == that.index()) {
-            visitation::alt::visit_alt_at(
-                this->index(),
+          visitation::alt::visit_alt_at(this->index(),
 #ifdef MPARK_GENERIC_LAMBDAS
-                [](auto &this_alt, auto &that_alt) {
-                    using std::swap;
-                    swap(this_alt.value, that_alt.value);
-                }
+                                        [](auto &this_alt, auto &that_alt) {
+                                          using std::swap;
+                                          swap(this_alt.value,
+                                               that_alt.value);
+                                        }
 #else
-                swapper{}
+                                        swapper{}
 #endif
-                ,
-                *this, that);
+                                        ,
+                                        *this,
+                                        that);
         } else {
-            impl *lhs = this;
-            impl *rhs = lib::addressof(that);
-            if (lhs->move_nothrow() && !rhs->move_nothrow()) {
-                std::swap(lhs, rhs);
-            }
-            impl tmp(lib::move(*rhs));
+          impl *lhs = this;
+          impl *rhs = lib::addressof(that);
+          if (lhs->move_nothrow() && !rhs->move_nothrow()) {
+            std::swap(lhs, rhs);
+          }
+          impl tmp(lib::move(*rhs));
 #ifdef MPARK_EXCEPTIONS
-            // EXTENSION: When the move construction of `lhs` into `rhs` throws
-            // and `tmp` is nothrow move constructible then we move `tmp` back
-            // into `rhs` and provide the strong exception safety guarantee.
-            try {
-                this->generic_construct(*rhs, lib::move(*lhs));
-            } catch (...) {
-                if (tmp.move_nothrow()) {
-                    this->generic_construct(*rhs, lib::move(tmp));
-                }
-                throw;
-            }
-#else
+          // EXTENSION: When the move construction of `lhs` into `rhs` throws
+          // and `tmp` is nothrow move constructible then we move `tmp` back
+          // into `rhs` and provide the strong exception safety guarantee.
+          try {
             this->generic_construct(*rhs, lib::move(*lhs));
+          } catch (...) {
+            if (tmp.move_nothrow()) {
+              this->generic_construct(*rhs, lib::move(tmp));
+            }
+            throw;
+          }
+#else
+          this->generic_construct(*rhs, lib::move(*lhs));
 #endif
-            this->generic_construct(*lhs, lib::move(tmp));
+          this->generic_construct(*lhs, lib::move(tmp));
         }
-    }
+      }
 
-private:
+      private:
 #ifndef MPARK_GENERIC_LAMBDAS
-    struct swapper {
-        template<typename ThisAlt, typename ThatAlt>
-        inline void operator()(ThisAlt &this_alt, ThatAlt &that_alt) const
-        {
-            using std::swap;
-            swap(this_alt.value, that_alt.value);
+      struct swapper {
+        template <typename ThisAlt, typename ThatAlt>
+        inline void operator()(ThisAlt &this_alt, ThatAlt &that_alt) const {
+          using std::swap;
+          swap(this_alt.value, that_alt.value);
         }
-    };
+      };
 #endif
 
-    inline constexpr bool move_nothrow() const
-    {
-        return this->valueless_by_exception()
-            || lib::array<bool, sizeof...(Ts)>{
-                {std::is_nothrow_move_constructible<
-                    Ts>::value...}}[this->index()];
-    }
-};
+      inline constexpr bool move_nothrow() const {
+        return this->valueless_by_exception() ||
+               lib::array<bool, sizeof...(Ts)>{
+                   {std::is_nothrow_move_constructible<Ts>::value...}
+               }[this->index()];
+      }
+    };
 
 #undef MPARK_INHERITING_CTOR
 
-template<std::size_t I, typename T>
-struct overload_leaf {
-    using F = lib::size_constant<I> (*)(T);
+    template <std::size_t I, typename T>
+    struct overload_leaf {
+      using F = lib::size_constant<I> (*)(T);
+      operator F() const { return nullptr; }
+    };
 
-    operator F() const { return nullptr; }
-};
+    template <typename... Ts>
+    struct overload_impl {
+      private:
+      template <typename>
+      struct impl;
 
-template<typename... Ts>
-struct overload_impl {
-private:
-    template<typename>
-    struct impl;
+      template <std::size_t... Is>
+      struct impl<lib::index_sequence<Is...>> : overload_leaf<Is, Ts>... {};
 
-    template<std::size_t... Is>
-    struct impl<lib::index_sequence<Is...>> : overload_leaf<Is, Ts>... {};
+      public:
+      using type = impl<lib::index_sequence_for<Ts...>>;
+    };
 
-public:
-    using type = impl<lib::index_sequence_for<Ts...>>;
-};
+    template <typename... Ts>
+    using overload = typename overload_impl<Ts...>::type;
 
-template<typename... Ts>
-using overload = typename overload_impl<Ts...>::type;
+    template <typename T, typename... Ts>
+    using best_match = lib::invoke_result_t<overload<Ts...>, T &&>;
 
-template<typename T, typename... Ts>
-using best_match = lib::invoke_result_t<overload<Ts...>, T &&>;
+    template <typename T>
+    struct is_in_place_index : std::false_type {};
 
-template<typename T>
-struct is_in_place_index : std::false_type {};
+    template <std::size_t I>
+    struct is_in_place_index<in_place_index_t<I>> : std::true_type {};
 
-template<std::size_t I>
-struct is_in_place_index<in_place_index_t<I>> : std::true_type {};
+    template <typename T>
+    struct is_in_place_type : std::false_type {};
 
-template<typename T>
-struct is_in_place_type : std::false_type {};
+    template <typename T>
+    struct is_in_place_type<in_place_type_t<T>> : std::true_type {};
 
-template<typename T>
-struct is_in_place_type<in_place_type_t<T>> : std::true_type {};
+  }  // detail
 
-}// namespace detail
-
-template<typename... Ts>
-class variant {
+  template <typename... Ts>
+  class variant {
     static_assert(0 < sizeof...(Ts),
                   "variant must consist of at least one alternative.");
 
@@ -2378,19 +2220,18 @@ class variant {
     static_assert(lib::all<!std::is_void<Ts>::value...>::value,
                   "variant can not have a void type as an alternative.");
 
-public:
-    template<
+    public:
+    template <
         typename Front = lib::type_pack_element_t<0, Ts...>,
         lib::enable_if_t<std::is_default_constructible<Front>::value, int> = 0>
     inline constexpr variant() noexcept(
         std::is_nothrow_default_constructible<Front>::value)
-        : impl_(in_place_index_t<0>{})
-    {}
+        : impl_(in_place_index_t<0>{}) {}
 
     variant(const variant &) = default;
     variant(variant &&) = default;
 
-    template<
+    template <
         typename Arg,
         typename Decayed = lib::decay_t<Arg>,
         lib::enable_if_t<!std::is_same<Decayed, variant>::value, int> = 0,
@@ -2401,318 +2242,285 @@ public:
         lib::enable_if_t<std::is_constructible<T, Arg>::value, int> = 0>
     inline constexpr variant(Arg &&arg) noexcept(
         std::is_nothrow_constructible<T, Arg>::value)
-        : impl_(in_place_index_t<I>{}, lib::forward<Arg>(arg))
-    {}
+        : impl_(in_place_index_t<I>{}, lib::forward<Arg>(arg)) {}
 
-    template<
+    template <
         std::size_t I,
         typename... Args,
         typename T = lib::type_pack_element_t<I, Ts...>,
         lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
     inline explicit constexpr variant(
         in_place_index_t<I>,
-        Args &&...args) noexcept(std::is_nothrow_constructible<T,
-                                                               Args...>::value)
-        : impl_(in_place_index_t<I>{}, lib::forward<Args>(args)...)
-    {}
+        Args &&... args) noexcept(std::is_nothrow_constructible<T,
+                                                                Args...>::value)
+        : impl_(in_place_index_t<I>{}, lib::forward<Args>(args)...) {}
 
-    template<std::size_t I,
-             typename Up,
-             typename... Args,
-             typename T = lib::type_pack_element_t<I, Ts...>,
-             lib::enable_if_t<std::is_constructible<T,
-                                                    std::initializer_list<Up> &,
-                                                    Args...>::value,
-                              int> = 0>
+    template <
+        std::size_t I,
+        typename Up,
+        typename... Args,
+        typename T = lib::type_pack_element_t<I, Ts...>,
+        lib::enable_if_t<std::is_constructible<T,
+                                               std::initializer_list<Up> &,
+                                               Args...>::value,
+                         int> = 0>
     inline explicit constexpr variant(
         in_place_index_t<I>,
         std::initializer_list<Up> il,
-        Args &&...args) noexcept(std::
-                                     is_nothrow_constructible<
-                                         T,
-                                         std::initializer_list<Up> &,
-                                         Args...>::value)
-        : impl_(in_place_index_t<I>{}, il, lib::forward<Args>(args)...)
-    {}
+        Args &&... args) noexcept(std::
+                                      is_nothrow_constructible<
+                                          T,
+                                          std::initializer_list<Up> &,
+                                          Args...>::value)
+        : impl_(in_place_index_t<I>{}, il, lib::forward<Args>(args)...) {}
 
-    template<
+    template <
         typename T,
         typename... Args,
         std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
         lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
     inline explicit constexpr variant(
         in_place_type_t<T>,
-        Args &&...args) noexcept(std::is_nothrow_constructible<T,
-                                                               Args...>::value)
-        : impl_(in_place_index_t<I>{}, lib::forward<Args>(args)...)
-    {}
+        Args &&... args) noexcept(std::is_nothrow_constructible<T,
+                                                                Args...>::value)
+        : impl_(in_place_index_t<I>{}, lib::forward<Args>(args)...) {}
 
-    template<typename T,
-             typename Up,
-             typename... Args,
-             std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
-             lib::enable_if_t<std::is_constructible<T,
-                                                    std::initializer_list<Up> &,
-                                                    Args...>::value,
-                              int> = 0>
+    template <
+        typename T,
+        typename Up,
+        typename... Args,
+        std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
+        lib::enable_if_t<std::is_constructible<T,
+                                               std::initializer_list<Up> &,
+                                               Args...>::value,
+                         int> = 0>
     inline explicit constexpr variant(
         in_place_type_t<T>,
         std::initializer_list<Up> il,
-        Args &&...args) noexcept(std::
-                                     is_nothrow_constructible<
-                                         T,
-                                         std::initializer_list<Up> &,
-                                         Args...>::value)
-        : impl_(in_place_index_t<I>{}, il, lib::forward<Args>(args)...)
-    {}
+        Args &&... args) noexcept(std::
+                                      is_nothrow_constructible<
+                                          T,
+                                          std::initializer_list<Up> &,
+                                          Args...>::value)
+        : impl_(in_place_index_t<I>{}, il, lib::forward<Args>(args)...) {}
 
     ~variant() = default;
 
     variant &operator=(const variant &) = default;
     variant &operator=(variant &&) = default;
 
-    template<typename Arg,
-             lib::enable_if_t<!std::is_same<lib::decay_t<Arg>, variant>::value,
-                              int> = 0,
-             std::size_t I = detail::best_match<Arg, Ts...>::value,
-             typename T = lib::type_pack_element_t<I, Ts...>,
-             lib::enable_if_t<(std::is_assignable<T &, Arg>::value
-                               && std::is_constructible<T, Arg>::value),
-                              int> = 0>
+    template <typename Arg,
+              lib::enable_if_t<!std::is_same<lib::decay_t<Arg>, variant>::value,
+                               int> = 0,
+              std::size_t I = detail::best_match<Arg, Ts...>::value,
+              typename T = lib::type_pack_element_t<I, Ts...>,
+              lib::enable_if_t<(std::is_assignable<T &, Arg>::value &&
+                                std::is_constructible<T, Arg>::value),
+                               int> = 0>
     inline variant &operator=(Arg &&arg) noexcept(
-        (std::is_nothrow_assignable<T &, Arg>::value
-         && std::is_nothrow_constructible<T, Arg>::value))
-    {
-        impl_.template assign<I>(lib::forward<Arg>(arg));
-        return *this;
+        (std::is_nothrow_assignable<T &, Arg>::value &&
+         std::is_nothrow_constructible<T, Arg>::value)) {
+      impl_.template assign<I>(lib::forward<Arg>(arg));
+      return *this;
     }
 
-    template<
+    template <
         std::size_t I,
         typename... Args,
         typename T = lib::type_pack_element_t<I, Ts...>,
         lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
-    inline T &emplace(Args &&...args)
-    {
-        return impl_.template emplace<I>(lib::forward<Args>(args)...);
+    inline T &emplace(Args &&... args) {
+      return impl_.template emplace<I>(lib::forward<Args>(args)...);
     }
 
-    template<std::size_t I,
-             typename Up,
-             typename... Args,
-             typename T = lib::type_pack_element_t<I, Ts...>,
-             lib::enable_if_t<std::is_constructible<T,
-                                                    std::initializer_list<Up> &,
-                                                    Args...>::value,
-                              int> = 0>
-    inline T &emplace(std::initializer_list<Up> il, Args &&...args)
-    {
-        return impl_.template emplace<I>(il, lib::forward<Args>(args)...);
+    template <
+        std::size_t I,
+        typename Up,
+        typename... Args,
+        typename T = lib::type_pack_element_t<I, Ts...>,
+        lib::enable_if_t<std::is_constructible<T,
+                                               std::initializer_list<Up> &,
+                                               Args...>::value,
+                         int> = 0>
+    inline T &emplace(std::initializer_list<Up> il, Args &&... args) {
+      return impl_.template emplace<I>(il, lib::forward<Args>(args)...);
     }
 
-    template<
+    template <
         typename T,
         typename... Args,
         std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
         lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
-    inline T &emplace(Args &&...args)
-    {
-        return impl_.template emplace<I>(lib::forward<Args>(args)...);
+    inline T &emplace(Args &&... args) {
+      return impl_.template emplace<I>(lib::forward<Args>(args)...);
     }
 
-    template<typename T,
-             typename Up,
-             typename... Args,
-             std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
-             lib::enable_if_t<std::is_constructible<T,
-                                                    std::initializer_list<Up> &,
-                                                    Args...>::value,
-                              int> = 0>
-    inline T &emplace(std::initializer_list<Up> il, Args &&...args)
-    {
-        return impl_.template emplace<I>(il, lib::forward<Args>(args)...);
+    template <
+        typename T,
+        typename Up,
+        typename... Args,
+        std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
+        lib::enable_if_t<std::is_constructible<T,
+                                               std::initializer_list<Up> &,
+                                               Args...>::value,
+                         int> = 0>
+    inline T &emplace(std::initializer_list<Up> il, Args &&... args) {
+      return impl_.template emplace<I>(il, lib::forward<Args>(args)...);
     }
 
-    inline constexpr bool valueless_by_exception() const noexcept
-    {
-        return impl_.valueless_by_exception();
+    inline constexpr bool valueless_by_exception() const noexcept {
+      return impl_.valueless_by_exception();
     }
 
-    inline constexpr std::size_t index() const noexcept
-    {
-        return impl_.index();
+    inline constexpr std::size_t index() const noexcept {
+      return impl_.index();
     }
 
-    template<bool Dummy = true,
-             lib::enable_if_t<
-                 lib::all<Dummy,
-                          (lib::dependent_type<std::is_move_constructible<Ts>,
-                                               Dummy>::value
-                           && lib::dependent_type<lib::is_swappable<Ts>,
-                                                  Dummy>::value)...>::value,
-                 int> = 0>
+    template <bool Dummy = true,
+              lib::enable_if_t<
+                  lib::all<Dummy,
+                           (lib::dependent_type<std::is_move_constructible<Ts>,
+                                                Dummy>::value &&
+                            lib::dependent_type<lib::is_swappable<Ts>,
+                                                Dummy>::value)...>::value,
+                  int> = 0>
     inline void swap(variant &that) noexcept(
-        lib::all<(std::is_nothrow_move_constructible<Ts>::value
-                  && lib::is_nothrow_swappable<Ts>::value)...>::value)
-    {
-        impl_.swap(that.impl_);
+        lib::all<(std::is_nothrow_move_constructible<Ts>::value &&
+                  lib::is_nothrow_swappable<Ts>::value)...>::value) {
+      impl_.swap(that.impl_);
     }
 
-private:
+    private:
     detail::impl<Ts...> impl_;
 
     friend struct detail::access::variant;
     friend struct detail::visitation::variant;
-};
+  };
 
-template<std::size_t I, typename... Ts>
-inline constexpr bool
-holds_alternative(const variant<Ts...> &v) noexcept
-{
+  template <std::size_t I, typename... Ts>
+  inline constexpr bool holds_alternative(const variant<Ts...> &v) noexcept {
     return v.index() == I;
-}
+  }
 
-template<typename T, typename... Ts>
-inline constexpr bool
-holds_alternative(const variant<Ts...> &v) noexcept
-{
+  template <typename T, typename... Ts>
+  inline constexpr bool holds_alternative(const variant<Ts...> &v) noexcept {
     return holds_alternative<detail::find_index_checked<T, Ts...>::value>(v);
-}
+  }
 
-namespace detail {
-template<std::size_t I, typename V>
-struct generic_get_impl {
-    constexpr generic_get_impl(int) noexcept {}
+  namespace detail {
+    template <std::size_t I, typename V>
+    struct generic_get_impl {
+      constexpr generic_get_impl(int) noexcept {}
 
-    constexpr AUTO_REFREF operator()(V &&v) const AUTO_REFREF_RETURN(
-        access::variant::get_alt<I>(lib::forward<V>(v)).value)
-};
+      constexpr AUTO_REFREF operator()(V &&v) const
+        AUTO_REFREF_RETURN(
+            access::variant::get_alt<I>(lib::forward<V>(v)).value)
+    };
 
-template<std::size_t I, typename V>
-inline constexpr AUTO_REFREF
-generic_get(V &&v)
-    AUTO_REFREF_RETURN(generic_get_impl<I, V>(holds_alternative<I>(v)
-                                                  ? 0
-                                                  : (throw_bad_variant_access(),
-                                                     0))(lib::forward<V>(v)))
-}// namespace detail
+    template <std::size_t I, typename V>
+    inline constexpr AUTO_REFREF generic_get(V &&v)
+      AUTO_REFREF_RETURN(generic_get_impl<I, V>(
+          holds_alternative<I>(v) ? 0 : (throw_bad_variant_access(), 0))(
+          lib::forward<V>(v)))
+  }  // namespace detail
 
-template<std::size_t I, typename... Ts>
-inline constexpr variant_alternative_t<I, variant<Ts...>> &
-get(variant<Ts...> &v)
-{
+  template <std::size_t I, typename... Ts>
+  inline constexpr variant_alternative_t<I, variant<Ts...>> &get(
+      variant<Ts...> &v) {
     return detail::generic_get<I>(v);
-}
+  }
 
-template<std::size_t I, typename... Ts>
-inline constexpr variant_alternative_t<I, variant<Ts...>> &&
-get(variant<Ts...> &&v)
-{
+  template <std::size_t I, typename... Ts>
+  inline constexpr variant_alternative_t<I, variant<Ts...>> &&get(
+      variant<Ts...> &&v) {
     return detail::generic_get<I>(lib::move(v));
-}
+  }
 
-template<std::size_t I, typename... Ts>
-inline constexpr const variant_alternative_t<I, variant<Ts...>> &
-get(const variant<Ts...> &v)
-{
+  template <std::size_t I, typename... Ts>
+  inline constexpr const variant_alternative_t<I, variant<Ts...>> &get(
+      const variant<Ts...> &v) {
     return detail::generic_get<I>(v);
-}
+  }
 
-template<std::size_t I, typename... Ts>
-inline constexpr const variant_alternative_t<I, variant<Ts...>> &&
-get(const variant<Ts...> &&v)
-{
+  template <std::size_t I, typename... Ts>
+  inline constexpr const variant_alternative_t<I, variant<Ts...>> &&get(
+      const variant<Ts...> &&v) {
     return detail::generic_get<I>(lib::move(v));
-}
+  }
 
-template<typename T, typename... Ts>
-inline constexpr T &
-get(variant<Ts...> &v)
-{
+  template <typename T, typename... Ts>
+  inline constexpr T &get(variant<Ts...> &v) {
     return get<detail::find_index_checked<T, Ts...>::value>(v);
-}
+  }
 
-template<typename T, typename... Ts>
-inline constexpr T &&
-get(variant<Ts...> &&v)
-{
+  template <typename T, typename... Ts>
+  inline constexpr T &&get(variant<Ts...> &&v) {
     return get<detail::find_index_checked<T, Ts...>::value>(lib::move(v));
-}
+  }
 
-template<typename T, typename... Ts>
-inline constexpr const T &
-get(const variant<Ts...> &v)
-{
+  template <typename T, typename... Ts>
+  inline constexpr const T &get(const variant<Ts...> &v) {
     return get<detail::find_index_checked<T, Ts...>::value>(v);
-}
+  }
 
-template<typename T, typename... Ts>
-inline constexpr const T &&
-get(const variant<Ts...> &&v)
-{
+  template <typename T, typename... Ts>
+  inline constexpr const T &&get(const variant<Ts...> &&v) {
     return get<detail::find_index_checked<T, Ts...>::value>(lib::move(v));
-}
+  }
 
-namespace detail {
+  namespace detail {
 
-template<std::size_t I, typename V>
-inline constexpr /* auto * */ AUTO
-generic_get_if(V *v) noexcept
-    AUTO_RETURN(v &&holds_alternative<I>(*v)
-                    ? lib::addressof(access::variant::get_alt<I>(*v).value)
-                    : nullptr)
+    template <std::size_t I, typename V>
+    inline constexpr /* auto * */ AUTO generic_get_if(V *v) noexcept
+      AUTO_RETURN(v && holds_alternative<I>(*v)
+                      ? lib::addressof(access::variant::get_alt<I>(*v).value)
+                      : nullptr)
 
-}// namespace detail
+  }  // namespace detail
 
-template<std::size_t I, typename... Ts>
-inline constexpr lib::add_pointer_t<variant_alternative_t<I, variant<Ts...>>>
-get_if(variant<Ts...> *v) noexcept
-{
+  template <std::size_t I, typename... Ts>
+  inline constexpr lib::add_pointer_t<variant_alternative_t<I, variant<Ts...>>>
+  get_if(variant<Ts...> *v) noexcept {
     return detail::generic_get_if<I>(v);
-}
+  }
 
-template<std::size_t I, typename... Ts>
-inline constexpr lib::add_pointer_t<
-    const variant_alternative_t<I, variant<Ts...>>>
-get_if(const variant<Ts...> *v) noexcept
-{
+  template <std::size_t I, typename... Ts>
+  inline constexpr lib::add_pointer_t<
+      const variant_alternative_t<I, variant<Ts...>>>
+  get_if(const variant<Ts...> *v) noexcept {
     return detail::generic_get_if<I>(v);
-}
+  }
 
-template<typename T, typename... Ts>
-inline constexpr lib::add_pointer_t<T>
-get_if(variant<Ts...> *v) noexcept
-{
+  template <typename T, typename... Ts>
+  inline constexpr lib::add_pointer_t<T>
+  get_if(variant<Ts...> *v) noexcept {
     return get_if<detail::find_index_checked<T, Ts...>::value>(v);
-}
+  }
 
-template<typename T, typename... Ts>
-inline constexpr lib::add_pointer_t<const T>
-get_if(const variant<Ts...> *v) noexcept
-{
+  template <typename T, typename... Ts>
+  inline constexpr lib::add_pointer_t<const T>
+  get_if(const variant<Ts...> *v) noexcept {
     return get_if<detail::find_index_checked<T, Ts...>::value>(v);
-}
+  }
 
-namespace detail {
-template<typename RelOp>
-struct convert_to_bool {
-    template<typename Lhs, typename Rhs>
-    inline constexpr bool operator()(Lhs &&lhs, Rhs &&rhs) const
-    {
+  namespace detail {
+    template <typename RelOp>
+    struct convert_to_bool {
+      template <typename Lhs, typename Rhs>
+      inline constexpr bool operator()(Lhs &&lhs, Rhs &&rhs) const {
         static_assert(std::is_convertible<lib::invoke_result_t<RelOp, Lhs, Rhs>,
                                           bool>::value,
                       "relational operators must return a type"
                       " implicitly convertible to bool");
-        return lib::invoke(RelOp{}, lib::forward<Lhs>(lhs),
-                           lib::forward<Rhs>(rhs));
-    }
-};
-}// namespace detail
+        return lib::invoke(
+            RelOp{}, lib::forward<Lhs>(lhs), lib::forward<Rhs>(rhs));
+      }
+    };
+  }  // namespace detail
 
-template<typename... Ts>
-inline constexpr bool
-operator==(const variant<Ts...> &lhs, const variant<Ts...> &rhs)
-{
+  template <typename... Ts>
+  inline constexpr bool operator==(const variant<Ts...> &lhs,
+                                   const variant<Ts...> &rhs) {
     using detail::visitation::variant;
     using equal_to = detail::convert_to_bool<lib::equal_to>;
 #ifdef MPARK_CPP14_CONSTEXPR
@@ -2720,16 +2528,15 @@ operator==(const variant<Ts...> &lhs, const variant<Ts...> &rhs)
     if (lhs.valueless_by_exception()) return true;
     return variant::visit_value_at(lhs.index(), equal_to{}, lhs, rhs);
 #else
-    return lhs.index() == rhs.index()
-        && (lhs.valueless_by_exception()
-            || variant::visit_value_at(lhs.index(), equal_to{}, lhs, rhs));
+    return lhs.index() == rhs.index() &&
+           (lhs.valueless_by_exception() ||
+            variant::visit_value_at(lhs.index(), equal_to{}, lhs, rhs));
 #endif
-}
+  }
 
-template<typename... Ts>
-inline constexpr bool
-operator!=(const variant<Ts...> &lhs, const variant<Ts...> &rhs)
-{
+  template <typename... Ts>
+  inline constexpr bool operator!=(const variant<Ts...> &lhs,
+                                   const variant<Ts...> &rhs) {
     using detail::visitation::variant;
     using not_equal_to = detail::convert_to_bool<lib::not_equal_to>;
 #ifdef MPARK_CPP14_CONSTEXPR
@@ -2737,16 +2544,15 @@ operator!=(const variant<Ts...> &lhs, const variant<Ts...> &rhs)
     if (lhs.valueless_by_exception()) return false;
     return variant::visit_value_at(lhs.index(), not_equal_to{}, lhs, rhs);
 #else
-    return lhs.index() != rhs.index()
-        || (!lhs.valueless_by_exception()
-            && variant::visit_value_at(lhs.index(), not_equal_to{}, lhs, rhs));
+    return lhs.index() != rhs.index() ||
+           (!lhs.valueless_by_exception() &&
+            variant::visit_value_at(lhs.index(), not_equal_to{}, lhs, rhs));
 #endif
-}
+  }
 
-template<typename... Ts>
-inline constexpr bool
-operator<(const variant<Ts...> &lhs, const variant<Ts...> &rhs)
-{
+  template <typename... Ts>
+  inline constexpr bool operator<(const variant<Ts...> &lhs,
+                                  const variant<Ts...> &rhs) {
     using detail::visitation::variant;
     using less = detail::convert_to_bool<lib::less>;
 #ifdef MPARK_CPP14_CONSTEXPR
@@ -2756,17 +2562,16 @@ operator<(const variant<Ts...> &lhs, const variant<Ts...> &rhs)
     if (lhs.index() > rhs.index()) return false;
     return variant::visit_value_at(lhs.index(), less{}, lhs, rhs);
 #else
-    return !rhs.valueless_by_exception()
-        && (lhs.valueless_by_exception() || lhs.index() < rhs.index()
-            || (lhs.index() == rhs.index()
-                && variant::visit_value_at(lhs.index(), less{}, lhs, rhs)));
+    return !rhs.valueless_by_exception() &&
+           (lhs.valueless_by_exception() || lhs.index() < rhs.index() ||
+            (lhs.index() == rhs.index() &&
+             variant::visit_value_at(lhs.index(), less{}, lhs, rhs)));
 #endif
-}
+  }
 
-template<typename... Ts>
-inline constexpr bool
-operator>(const variant<Ts...> &lhs, const variant<Ts...> &rhs)
-{
+  template <typename... Ts>
+  inline constexpr bool operator>(const variant<Ts...> &lhs,
+                                  const variant<Ts...> &rhs) {
     using detail::visitation::variant;
     using greater = detail::convert_to_bool<lib::greater>;
 #ifdef MPARK_CPP14_CONSTEXPR
@@ -2776,17 +2581,16 @@ operator>(const variant<Ts...> &lhs, const variant<Ts...> &rhs)
     if (lhs.index() < rhs.index()) return false;
     return variant::visit_value_at(lhs.index(), greater{}, lhs, rhs);
 #else
-    return !lhs.valueless_by_exception()
-        && (rhs.valueless_by_exception() || lhs.index() > rhs.index()
-            || (lhs.index() == rhs.index()
-                && variant::visit_value_at(lhs.index(), greater{}, lhs, rhs)));
+    return !lhs.valueless_by_exception() &&
+           (rhs.valueless_by_exception() || lhs.index() > rhs.index() ||
+            (lhs.index() == rhs.index() &&
+             variant::visit_value_at(lhs.index(), greater{}, lhs, rhs)));
 #endif
-}
+  }
 
-template<typename... Ts>
-inline constexpr bool
-operator<=(const variant<Ts...> &lhs, const variant<Ts...> &rhs)
-{
+  template <typename... Ts>
+  inline constexpr bool operator<=(const variant<Ts...> &lhs,
+                                   const variant<Ts...> &rhs) {
     using detail::visitation::variant;
     using less_equal = detail::convert_to_bool<lib::less_equal>;
 #ifdef MPARK_CPP14_CONSTEXPR
@@ -2796,19 +2600,17 @@ operator<=(const variant<Ts...> &lhs, const variant<Ts...> &rhs)
     if (lhs.index() > rhs.index()) return false;
     return variant::visit_value_at(lhs.index(), less_equal{}, lhs, rhs);
 #else
-    return lhs.valueless_by_exception()
-        || (!rhs.valueless_by_exception()
-            && (lhs.index() < rhs.index()
-                || (lhs.index() == rhs.index()
-                    && variant::visit_value_at(lhs.index(), less_equal{}, lhs,
-                                               rhs))));
+    return lhs.valueless_by_exception() ||
+           (!rhs.valueless_by_exception() &&
+            (lhs.index() < rhs.index() ||
+             (lhs.index() == rhs.index() &&
+              variant::visit_value_at(lhs.index(), less_equal{}, lhs, rhs))));
 #endif
-}
+  }
 
-template<typename... Ts>
-inline constexpr bool
-operator>=(const variant<Ts...> &lhs, const variant<Ts...> &rhs)
-{
+  template <typename... Ts>
+  inline constexpr bool operator>=(const variant<Ts...> &lhs,
+                                   const variant<Ts...> &rhs) {
     using detail::visitation::variant;
     using greater_equal = detail::convert_to_bool<lib::greater_equal>;
 #ifdef MPARK_CPP14_CONSTEXPR
@@ -2818,144 +2620,123 @@ operator>=(const variant<Ts...> &lhs, const variant<Ts...> &rhs)
     if (lhs.index() < rhs.index()) return false;
     return variant::visit_value_at(lhs.index(), greater_equal{}, lhs, rhs);
 #else
-    return rhs.valueless_by_exception()
-        || (!lhs.valueless_by_exception()
-            && (lhs.index() > rhs.index()
-                || (lhs.index() == rhs.index()
-                    && variant::visit_value_at(lhs.index(), greater_equal{},
-                                               lhs, rhs))));
+    return rhs.valueless_by_exception() ||
+           (!lhs.valueless_by_exception() &&
+            (lhs.index() > rhs.index() ||
+             (lhs.index() == rhs.index() &&
+              variant::visit_value_at(
+                  lhs.index(), greater_equal{}, lhs, rhs))));
 #endif
-}
+  }
 
-struct monostate {};
+  struct monostate {};
 
-inline constexpr bool
-operator<(monostate, monostate) noexcept
-{
+  inline constexpr bool operator<(monostate, monostate) noexcept {
     return false;
-}
+  }
 
-inline constexpr bool
-operator>(monostate, monostate) noexcept
-{
+  inline constexpr bool operator>(monostate, monostate) noexcept {
     return false;
-}
+  }
 
-inline constexpr bool
-operator<=(monostate, monostate) noexcept
-{
+  inline constexpr bool operator<=(monostate, monostate) noexcept {
     return true;
-}
+  }
 
-inline constexpr bool
-operator>=(monostate, monostate) noexcept
-{
+  inline constexpr bool operator>=(monostate, monostate) noexcept {
     return true;
-}
+  }
 
-inline constexpr bool
-operator==(monostate, monostate) noexcept
-{
+  inline constexpr bool operator==(monostate, monostate) noexcept {
     return true;
-}
+  }
 
-inline constexpr bool
-operator!=(monostate, monostate) noexcept
-{
+  inline constexpr bool operator!=(monostate, monostate) noexcept {
     return false;
-}
+  }
 
 #ifdef MPARK_CPP14_CONSTEXPR
-namespace detail {
+  namespace detail {
 
-inline constexpr bool
-all(std::initializer_list<bool> bs)
-{
-    for (bool b : bs) {
-        if (!b) { return false; }
+    inline constexpr bool all(std::initializer_list<bool> bs) {
+      for (bool b : bs) {
+        if (!b) {
+          return false;
+        }
+      }
+      return true;
     }
-    return true;
-}
 
-}// namespace detail
+  }  // namespace detail
 
-template<typename Visitor, typename... Vs>
-inline constexpr decltype(auto)
-visit(Visitor &&visitor, Vs &&...vs)
-{
+  template <typename Visitor, typename... Vs>
+  inline constexpr decltype(auto) visit(Visitor &&visitor, Vs &&... vs) {
     return (detail::all({!vs.valueless_by_exception()...})
-                ? (void) 0
+                ? (void)0
                 : throw_bad_variant_access()),
            detail::visitation::variant::visit_value(
                lib::forward<Visitor>(visitor), lib::forward<Vs>(vs)...);
-}
+  }
 #else
-namespace detail {
+  namespace detail {
 
-template<std::size_t N>
-inline constexpr bool
-all_impl(const lib::array<bool, N> &bs, std::size_t idx)
-{
-    return idx >= N || (bs[idx] && all_impl(bs, idx + 1));
-}
+    template <std::size_t N>
+    inline constexpr bool all_impl(const lib::array<bool, N> &bs,
+                                   std::size_t idx) {
+      return idx >= N || (bs[idx] && all_impl(bs, idx + 1));
+    }
 
-template<std::size_t N>
-inline constexpr bool
-all(const lib::array<bool, N> &bs)
-{
-    return all_impl(bs, 0);
-}
+    template <std::size_t N>
+    inline constexpr bool all(const lib::array<bool, N> &bs) {
+      return all_impl(bs, 0);
+    }
 
-}// namespace detail
+  }  // namespace detail
 
-template<typename Visitor, typename... Vs>
-inline constexpr DECLTYPE_AUTO
-visit(Visitor &&visitor, Vs &&...vs) DECLTYPE_AUTO_RETURN(
-    (detail::all(lib::array<bool, sizeof...(Vs)>{
-         {!vs.valueless_by_exception()...}})
-         ? (void) 0
-         : throw_bad_variant_access()),
-    detail::visitation::variant::visit_value(lib::forward<Visitor>(visitor),
-                                             lib::forward<Vs>(vs)...))
+  template <typename Visitor, typename... Vs>
+  inline constexpr DECLTYPE_AUTO visit(Visitor &&visitor, Vs &&... vs)
+    DECLTYPE_AUTO_RETURN(
+        (detail::all(
+             lib::array<bool, sizeof...(Vs)>{{!vs.valueless_by_exception()...}})
+             ? (void)0
+             : throw_bad_variant_access()),
+        detail::visitation::variant::visit_value(lib::forward<Visitor>(visitor),
+                                                 lib::forward<Vs>(vs)...))
 #endif
 
-template<typename... Ts>
-inline auto
-swap(variant<Ts...> &lhs, variant<Ts...> &rhs) noexcept(noexcept(lhs.swap(rhs)))
-    -> decltype(lhs.swap(rhs))
-{
+  template <typename... Ts>
+  inline auto swap(variant<Ts...> &lhs,
+                   variant<Ts...> &rhs) noexcept(noexcept(lhs.swap(rhs)))
+      -> decltype(lhs.swap(rhs)) {
     lhs.swap(rhs);
-}
+  }
 
-namespace detail {
+  namespace detail {
 
-template<typename T, typename...>
-using enabled_type = T;
+    template <typename T, typename...>
+    using enabled_type = T;
 
-namespace hash {
+    namespace hash {
 
-template<typename H, typename K>
-constexpr bool
-meets_requirements() noexcept
-{
-    return std::is_copy_constructible<H>::value
-        && std::is_move_constructible<H>::value
-        && lib::is_invocable_r<std::size_t, H, const K &>::value;
-}
+      template <typename H, typename K>
+      constexpr bool meets_requirements() noexcept {
+        return std::is_copy_constructible<H>::value &&
+               std::is_move_constructible<H>::value &&
+               lib::is_invocable_r<std::size_t, H, const K &>::value;
+      }
 
-template<typename K>
-constexpr bool
-is_enabled() noexcept
-{
-    using H = std::hash<K>;
-    return meets_requirements<H, K>() && std::is_default_constructible<H>::value
-        && std::is_copy_assignable<H>::value
-        && std::is_move_assignable<H>::value;
-}
+      template <typename K>
+      constexpr bool is_enabled() noexcept {
+        using H = std::hash<K>;
+        return meets_requirements<H, K>() &&
+               std::is_default_constructible<H>::value &&
+               std::is_copy_assignable<H>::value &&
+               std::is_move_assignable<H>::value;
+      }
 
-}// namespace hash
+    }  // namespace hash
 
-}// namespace detail
+  }  // namespace detail
 
 #undef AUTO
 #undef AUTO_RETURN
@@ -2966,77 +2747,67 @@ is_enabled() noexcept
 #undef DECLTYPE_AUTO
 #undef DECLTYPE_AUTO_RETURN
 
-}// namespace mpark
+}  // namespace mpark
 
 namespace std {
 
-template<typename... Ts>
-struct hash<mpark::detail::enabled_type<
-    mpark::variant<Ts...>,
-    mpark::lib::enable_if_t<mpark::lib::all<mpark::detail::hash::is_enabled<
-        mpark::lib::remove_const_t<Ts>>()...>::value>>> {
+  template <typename... Ts>
+  struct hash<mpark::detail::enabled_type<
+      mpark::variant<Ts...>,
+      mpark::lib::enable_if_t<mpark::lib::all<mpark::detail::hash::is_enabled<
+          mpark::lib::remove_const_t<Ts>>()...>::value>>> {
     using argument_type = mpark::variant<Ts...>;
     using result_type = std::size_t;
 
-    inline result_type operator()(const argument_type &v) const
-    {
-        using mpark::detail::visitation::variant;
-        std::size_t result = v.valueless_by_exception()
-            ? 299792458// Random value chosen by the universe upon creation
-            : variant::visit_alt(
+    inline result_type operator()(const argument_type &v) const {
+      using mpark::detail::visitation::variant;
+      std::size_t result =
+          v.valueless_by_exception()
+              ? 299792458  // Random value chosen by the universe upon creation
+              : variant::visit_alt(
 #ifdef MPARK_GENERIC_LAMBDAS
-                [](const auto &alt) {
-                    using alt_type = mpark::lib::decay_t<decltype(alt)>;
-                    using value_type = mpark::lib::remove_const_t<
-                        typename alt_type::value_type>;
-                    return hash<value_type>{}(alt.value);
-                }
+                    [](const auto &alt) {
+                      using alt_type = mpark::lib::decay_t<decltype(alt)>;
+                      using value_type = mpark::lib::remove_const_t<
+                          typename alt_type::value_type>;
+                      return hash<value_type>{}(alt.value);
+                    }
 #else
-                hasher{}
+                    hasher{}
 #endif
-                ,
-                v);
-        return hash_combine(result, hash<std::size_t>{}(v.index()));
+                    ,
+                    v);
+      return hash_combine(result, hash<std::size_t>{}(v.index()));
     }
 
-private:
+    private:
 #ifndef MPARK_GENERIC_LAMBDAS
     struct hasher {
-        template<typename Alt>
-        inline std::size_t operator()(const Alt &alt) const
-        {
-            using alt_type = mpark::lib::decay_t<Alt>;
-            using value_type =
-                mpark::lib::remove_const_t<typename alt_type::value_type>;
-            return hash<value_type>{}(alt.value);
-        }
+      template <typename Alt>
+      inline std::size_t operator()(const Alt &alt) const {
+        using alt_type = mpark::lib::decay_t<Alt>;
+        using value_type =
+            mpark::lib::remove_const_t<typename alt_type::value_type>;
+        return hash<value_type>{}(alt.value);
+      }
     };
 #endif
 
-    static std::size_t hash_combine(std::size_t lhs, std::size_t rhs)
-    {
-        return lhs ^= rhs + 0x9e3779b9 + (lhs << 6) + (lhs >> 2);
+    static std::size_t hash_combine(std::size_t lhs, std::size_t rhs) {
+      return lhs ^= rhs + 0x9e3779b9 + (lhs << 6) + (lhs >> 2);
     }
-};
+  };
 
-template<>
-struct hash<mpark::monostate> {
+  template <>
+  struct hash<mpark::monostate> {
     using argument_type = mpark::monostate;
     using result_type = std::size_t;
 
-    inline result_type operator()(const argument_type &) const noexcept
-    {
-        return 66740831;// return a fundamentally attractive random value.
+    inline result_type operator()(const argument_type &) const noexcept {
+      return 66740831;  // return a fundamentally attractive random value.
     }
-};
+  };
 
-}// namespace std
+}  // namespace std
 
-namespace sled {
-// template<typename... Ts>
-// using variant = mpark::variant<Ts...>;
-using namespace mpark;
-
-}// namespace sled
-
-#endif// SLED_MPARK_VARIANT_HPP
+#endif  // MPARK_VARIANT_HPP