FM / util

/usr/local/lib64/python3.6/site-packages/torch/include/c10/util/

/usr/local/lib64/python3.6/site-packages/torch/include/c10/util

Name	Size	Mode	Actions
accumulate.h	4205	0644	edit dl rm
AlignOf.h	4835	0644	edit dl rm
Array.h	11354	0644	edit dl rm
ArrayRef.h	9058	0644	edit dl rm
Backtrace.h	364	0644	edit dl rm
BFloat16-inl.h	9222	0644	edit dl rm
BFloat16-math.h	5217	0644	edit dl rm
BFloat16.h	2372	0644	edit dl rm
Bitset.h	3414	0644	edit dl rm
C++17.h	13329	0644	edit dl rm
complex.h	17542	0644	edit dl rm
complex_math.h	10902	0644	edit dl rm
complex_utils.h	958	0644	edit dl rm
ConstexprCrc.h	6633	0644	edit dl rm
copysign.h	866	0644	edit dl rm
DeadlockDetection.h	1920	0644	edit dl rm
Deprecated.h	3579	0644	edit dl rm
either.h	6423	0644	edit dl rm
env.h	835	0644	edit dl rm
Exception.h	24723	0644	edit dl rm
ExclusivelyOwned.h	4759	0644	edit dl rm
Flags.h	10056	0644	edit dl rm
flat_hash_map.h	61655	0644	edit dl rm
FunctionRef.h	2301	0644	edit dl rm
Half-inl.h	8674	0644	edit dl rm
Half.h	18965	0644	edit dl rm
hash.h	5084	0644	edit dl rm
IdWrapper.h	2348	0644	edit dl rm
intrusive_ptr.h	35563	0644	edit dl rm
in_place.h	350	0644	edit dl rm
irange.h	2679	0644	edit dl rm
LeftRight.h	6016	0644	edit dl rm
llvmMathExtras.h	29168	0644	edit dl rm
Logging.h	11256	0644	edit dl rm
logging_is_google_glog.h	2031	0644	edit dl rm
logging_is_not_google_glog.h	8271	0644	edit dl rm
MathConstants.h	858	0644	edit dl rm
math_compat.h	7296	0644	edit dl rm
MaybeOwned.h	6689	0644	edit dl rm
Metaprogramming.h	15288	0644	edit dl rm
numa.h	696	0644	edit dl rm
Optional.h	35592	0644	edit dl rm
order_preserving_flat_hash_map.h	65482	0644	edit dl rm
overloaded.h	709	0644	edit dl rm
python_stub.h	56	0644	edit dl rm
qint8.h	472	0644	edit dl rm
qint32.h	319	0644	edit dl rm
quint4x2.h	366	0644	edit dl rm
quint8.h	320	0644	edit dl rm
Registry.h	12242	0644	edit dl rm
reverse_iterator.h	8796	0644	edit dl rm
ScopeExit.h	1345	0644	edit dl rm
signal_handler.h	3154	0644	edit dl rm
SmallBuffer.h	1243	0644	edit dl rm
SmallVector.h	34456	0644	edit dl rm
sparse_bitset.h	26511	0644	edit dl rm
StringUtil.h	4538	0644	edit dl rm
string_utils.h	3989	0644	edit dl rm
string_view.h	20189	0644	edit dl rm
tempfile.h	6029	0644	edit dl rm
ThreadLocal.h	3883	0644	edit dl rm
ThreadLocalDebugInfo.h	2603	0644	edit dl rm
thread_name.h	148	0644	edit dl rm
Type.h	607	0644	edit dl rm
TypeCast.h	6972	0644	edit dl rm
typeid.h	18793	0644	edit dl rm
TypeIndex.h	5251	0644	edit dl rm
TypeList.h	16901	0644	edit dl rm
TypeTraits.h	5368	0644	edit dl rm
Unicode.h	295	0644	edit dl rm
UniqueVoidPtr.h	4117	0644	edit dl rm
Unroll.h	667	0644	edit dl rm
variant.h	95182	0644	edit dl rm
win32-headers.h	858	0644	edit dl rm

Edit: /usr/local/lib64/python3.6/site-packages/torch/include/c10/util/variant.h (95182B)

#ifndef C10_UTIL_VARIANT_H_
#define C10_UTIL_VARIANT_H_

/*
   variant synopsis

namespace std {

// 20.7.2, class template variant
 template <class... Types>
 class variant {
 public:

// 20.7.2.1, constructors
    constexpr variant() noexcept(see below);
    variant(const variant&);
    variant(variant&&) noexcept(see below);

template <class T> constexpr variant(T&&) noexcept(see below);

template <class T, class... Args>
 constexpr explicit variant(in_place_type_t<T>, Args&&...);

template <class T, class U, class... Args>
 constexpr explicit variant(
 in_place_type_t<T>, initializer_list, Args&&...);

template <size_t I, class... Args>
 constexpr explicit variant(in_place_index_t, Args&&...);

template <size_t I, class U, class... Args>
 constexpr explicit variant(
 in_place_index_t, initializer_list, Args&&...);

// 20.7.2.2, destructor
    ~variant();

// 20.7.2.3, assignment
    variant& operator=(const variant&);
    variant& operator=(variant&&) noexcept(see below);

template <class T> variant& operator=(T&&) noexcept(see below);

// 20.7.2.4, modifiers
 template <class T, class... Args>
 T& emplace(Args&&...);

template <class T, class U, class... Args>
 T& emplace(initializer_list, Args&&...);

template <size_t I, class... Args>
 variant_alternative<I, variant>& emplace(Args&&...);

template <size_t I, class U, class... Args>
 variant_alternative<I, variant>& emplace(initializer_list, Args&&...);

// 20.7.2.5, value status
    constexpr bool valueless_by_exception() const noexcept;
    constexpr size_t index() const noexcept;

// 20.7.2.6, swap
    void swap(variant&) noexcept(see below);
  };

// 20.7.3, variant helper classes
 template <class T> struct variant_size; // undefined

template <class T>
 constexpr size_t variant_size_v = variant_size<T>::value;

template <class T> struct variant_size<const T>;
 template <class T> struct variant_size<volatile T>;
 template <class T> struct variant_size<const volatile T>;

template <class... Types>
 struct variant_size<variant<Types...>>;

template <size_t I, class T> struct variant_alternative; // undefined

template <size_t I, class T>
 using variant_alternative_t = typename variant_alternative<I, T>::type;

template <size_t I, class T> struct variant_alternative<I, const T>;
 template <size_t I, class T> struct variant_alternative<I, volatile T>;
 template <size_t I, class T> struct variant_alternative<I, const volatile T>;

template <size_t I, class... Types>
 struct variant_alternative<I, variant<Types...>>;

constexpr size_t variant_npos = -1;

// 20.7.4, value access
 template <class T, class... Types>
 constexpr bool holds_alternative(const variant<Types...>&) noexcept;

template <size_t I, class... Types>
 constexpr variant_alternative_t<I, variant<Types...>>&
 get(variant<Types...>&);

template <size_t I, class... Types>
 constexpr variant_alternative_t<I, variant<Types...>>&&
 get(variant<Types...>&&);

template <size_t I, class... Types>
 constexpr variant_alternative_t<I, variant<Types...>> const&
 get(const variant<Types...>&);

template <size_t I, class... Types>
 constexpr variant_alternative_t<I, variant<Types...>> const&&
 get(const variant<Types...>&&);

template <class T, class... Types>
 constexpr T& get(variant<Types...>&);

template <class T, class... Types>
 constexpr T&& get(variant<Types...>&&);

template <class T, class... Types>
 constexpr const T& get(const variant<Types...>&);

template <class T, class... Types>
 constexpr const T&& get(const variant<Types...>&&);

template <size_t I, class... Types>
 constexpr add_pointer_t<variant_alternative_t<I, variant<Types...>>>
 get_if(variant<Types...>*) noexcept;

template <size_t I, class... Types>
 constexpr add_pointer_t<const variant_alternative_t<I, variant<Types...>>>
 get_if(const variant<Types...>*) noexcept;

template <class T, class... Types>
 constexpr add_pointer_t<T>
 get_if(variant<Types...>*) noexcept;

template <class T, class... Types>
 constexpr add_pointer_t<const T>
 get_if(const variant<Types...>*) noexcept;

// 20.7.5, relational operators
 template <class... Types>
 constexpr bool operator==(const variant<Types...>&, const variant<Types...>&);

template <class... Types>
 constexpr bool operator!=(const variant<Types...>&, const variant<Types...>&);

template <class... Types>
 constexpr bool operator<(const variant<Types...>&, const variant<Types...>&);

template <class... Types>
 constexpr bool operator>(const variant<Types...>&, const variant<Types...>&);

template <class... Types>
 constexpr bool operator<=(const variant<Types...>&, const variant<Types...>&);

template <class... Types>
 constexpr bool operator>=(const variant<Types...>&, const variant<Types...>&);

// 20.7.6, visitation
 template <class Visitor, class... Variants>
 constexpr see below visit(Visitor&&, Variants&&...);

// 20.7.7, class monostate
  struct monostate;

// 20.7.8, monostate relational operators
 constexpr bool operator<(monostate, monostate) noexcept;
 constexpr bool operator>(monostate, monostate) noexcept;
 constexpr bool operator<=(monostate, monostate) noexcept;
 constexpr bool operator>=(monostate, monostate) noexcept;
 constexpr bool operator==(monostate, monostate) noexcept;
 constexpr bool operator!=(monostate, monostate) noexcept;

// 20.7.9, specialized algorithms
 template <class... Types>
 void swap(variant<Types...>&, variant<Types...>&) noexcept(see below);

// 20.7.10, class bad_variant_access
  class bad_variant_access;

// 20.7.11, hash support
 template <class T> struct hash;
 template <class... Types> struct hash<variant<Types...>>;
 template <> struct hash<monostate>;

} // namespace std

#include <cstddef>
#include <exception>
#include <functional>
#include <initializer_list>
#include <new>
#include <type_traits>
#include <utility>

#ifndef MPARK_CONFIG_HPP
#define MPARK_CONFIG_HPP

// MSVC 2015 Update 3.
#if __cplusplus < 201103L && (!defined(_MSC_VER) || _MSC_FULL_VER < 190024210)
#error "MPark.Variant requires C++11 support."
#endif

#ifndef __has_attribute
#define __has_attribute(x) 0
#endif

#ifndef __has_builtin
#define __has_builtin(x) 0
#endif

#ifndef __has_include
#define __has_include(x) 0
#endif

#ifndef __has_feature
#define __has_feature(x) 0
#endif

#if __has_attribute(always_inline) || defined(__GNUC__)
#define MPARK_ALWAYS_INLINE __attribute__((__always_inline__)) inline
#elif defined(_MSC_VER)
#define MPARK_ALWAYS_INLINE __forceinline
#else
#define MPARK_ALWAYS_INLINE inline
#endif

#if __has_builtin(__builtin_addressof) || \
    (defined(__GNUC__) && __GNUC__ >= 7) || defined(_MSC_VER)
#define MPARK_BUILTIN_ADDRESSOF
#endif

#if __has_builtin(__builtin_unreachable) || defined(__GNUC__)
#define MPARK_BUILTIN_UNREACHABLE __builtin_unreachable()
#elif defined(_MSC_VER)
#define MPARK_BUILTIN_UNREACHABLE __assume(false)
#else
#define MPARK_BUILTIN_UNREACHABLE
#endif

#if __has_builtin(__type_pack_element)
#define MPARK_TYPE_PACK_ELEMENT
#endif

#if defined(__cpp_constexpr) && __cpp_constexpr >= 200704 && \
    !(defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 9)
#define MPARK_CPP11_CONSTEXPR
#endif

#if defined(__cpp_constexpr) && __cpp_constexpr >= 201304
#define MPARK_CPP14_CONSTEXPR
#endif

#if __has_feature(cxx_exceptions) || defined(__cpp_exceptions) || \
    (defined(_MSC_VER) && defined(_CPPUNWIND))
#define MPARK_EXCEPTIONS
#endif

#if defined(__cpp_generic_lambdas) || defined(_MSC_VER)
#define MPARK_GENERIC_LAMBDAS
#endif

#if defined(__cpp_lib_integer_sequence)
#define MPARK_INTEGER_SEQUENCE
#endif

#if defined(__cpp_return_type_deduction) || defined(_MSC_VER)
#define MPARK_RETURN_TYPE_DEDUCTION
#endif

#if defined(__cpp_lib_transparent_operators) || defined(_MSC_VER)
#define MPARK_TRANSPARENT_OPERATORS
#endif

#if defined(__cpp_variable_templates) || defined(_MSC_VER)
#define MPARK_VARIABLE_TEMPLATES
#endif

#if !defined(__GLIBCXX__) || __has_include(<codecvt>) // >= libstdc++-5
#define MPARK_TRIVIALITY_TYPE_TRAITS
#define MPARK_INCOMPLETE_TYPE_TRAITS
#endif

#endif // MPARK_CONFIG_HPP

#ifndef MPARK_IN_PLACE_HPP
#define MPARK_IN_PLACE_HPP

#include <c10/util/in_place.h>

#include <cstddef>

namespace c10 {

#ifdef MPARK_VARIABLE_TEMPLATES
template <std::size_t I>
constexpr in_place_index_t in_place_index{};

template <typename T>
constexpr in_place_type_t<T> in_place_type{};
#endif

} // namespace c10

#endif // MPARK_IN_PLACE_HPP

#ifndef MPARK_LIB_HPP
#define MPARK_LIB_HPP

#include <functional>
#include <memory>
#include <type_traits>
#include <utility>

#define MPARK_RETURN(...)                                  \
  noexcept(noexcept(__VA_ARGS__))->decltype(__VA_ARGS__) { \
    return __VA_ARGS__;                                    \
  }

namespace c10 {
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];
 }

T data[N == 0 ? 1 : N];
};

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 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 <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>
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 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;
#else
template <typename T, T... Is>
struct integer_sequence {
 using value_type = T;
 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 <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 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>
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<1> : identity<index_sequence<0>> {};

template <typename... Ts>
using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
#endif

// <functional>
#ifdef MPARK_TRANSPARENT_OPERATORS
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))
};
#endif

#ifdef MPARK_TRANSPARENT_OPERATORS
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))
};
#endif

#ifdef MPARK_TRANSPARENT_OPERATORS
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))
};
#endif

#ifdef MPARK_TRANSPARENT_OPERATORS
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))
};
#endif

#ifdef MPARK_TRANSPARENT_OPERATORS
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))
};
#endif

#ifdef MPARK_TRANSPARENT_OPERATORS
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))
};
#endif
} // namespace cpp14

inline namespace cpp17 {

// <type_traits>
template <bool B>
using bool_constant = std::integral_constant<bool, B>;

template <typename...>
struct voider : identity<void> {};

template <typename... Ts>
using void_t = typename voider<Ts...>::type;

namespace detail_ {
namespace swappable {

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 U>
 inline static std::false_type test(...);

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 <typename T>
struct is_nothrow_swappable<false, T> : std::false_type {};

} // namespace swappable
} // namespace detail_

using detail_::swappable::is_swappable;

template <typename T>
using is_nothrow_swappable =
 detail_::swappable::is_nothrow_swappable<is_swappable<T>::value, T>;

// <functional>
namespace detail_ {

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 <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 */, 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<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 */, 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)...))

#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)...))
#ifdef _MSC_VER
#pragma warning(pop)
#endif
} // 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)...))

namespace detail_ {
 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>()...))> {};

} // namespace detail_

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;

namespace detail_ {

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 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> {};

} // namespace detail_

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...>;

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 <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>()...);
 }

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 {};

} // namespace detail_

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...>;

// <memory>
#ifdef MPARK_BUILTIN_ADDRESSOF
template <typename T>
inline constexpr T* addressof(T& arg) noexcept {
 return __builtin_addressof(arg);
}
#else
namespace detail_ {

namespace has_addressof_impl {

struct fail;

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;
}

} // namespace has_addressof_impl

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::false_type) noexcept {
 return &arg;
}

} // namespace detail_

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;

} // namespace cpp17

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>
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 I, typename T>
struct indexed_type : size_constant {
 using type = T;
};

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...>;
#else
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 <typename T>
 inline static std::enable_if<true, T> impl(indexed_type<I, T>);

inline static std::enable_if<false> impl(...);

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_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;
#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_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_move_assignable : bool_constant<__is_trivial(T)> {};
#endif

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>
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>;
};

} // namespace lib
} // namespace c10

#undef MPARK_RETURN

#endif // MPARK_LIB_HPP

namespace c10 {

#ifdef MPARK_RETURN_TYPE_DEDUCTION

#define AUTO auto
#define AUTO_RETURN(...) \
  { return __VA_ARGS__; }

#define AUTO_REFREF auto&&
#define AUTO_REFREF_RETURN(...) \
  { return __VA_ARGS__; }

#define DECLTYPE_AUTO decltype(auto)
#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_REFREF auto
#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__;           \
  }

#endif

class bad_variant_access : public std::exception {
 public:
  const char* what() const noexcept override {
    return "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 T>
struct variant_size;

#ifdef MPARK_VARIABLE_TEMPLATES
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<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 <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>
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, const volatile T>
 : std::add_cv<variant_alternative_t<I, T>> {};

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);

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);

#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) {
 if (matches[i]) {
 if (result != not_found) {
 return ambiguous;
 }
 result = i;
 }
 }
 return result;
}
#else
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 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>;

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 {
 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...>()>;

struct valueless_t {};

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;
}

#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) {
 Trait t = traits[i];
 if (static_cast<int>(t) > static_cast<int>(result)) {
 result = t;
 }
 }
 return result;
}
#else
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(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>()...);

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 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>()...);
};

namespace access {

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, std::size_t I>
 inline static constexpr auto&& get_alt(V&& v, in_place_index_t) {
 return get_alt(lib::forward<V>(v).tail_, in_place_index_t{});
 }
#else
 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{}(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
 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)
 AUTO_REFREF_RETURN(get_alt_impl{}(lib::forward<V>(v)))
#endif
};

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{}))
#else
 AUTO_REFREF_RETURN(recursive_union::get_alt(
 data(lib::forward<V>(v)),
 in_place_index_t{}))
#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(lib::forward<V>(v).impl_))
};

} // namespace access

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>())...));

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 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 <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&&...) {
 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&&...) {
 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) {
 using Expected = R;
 using Actual = decltype(lib::invoke(
 lib::forward<F>(f),
 access::base::get_alt<ITs::value>(
 lib::forward<typename ITs::type>(visited_vs))...));
 return visit_return_type_check<Expected, Actual>::invoke(
 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)...)

#define MPARK_DEFAULT(I) \
 dispatcher<(I < lib::decay_t<V>::size()), R, ITs...>::template dispatch( \
 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);
      }

#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) {
 using Expected = R;
 using Actual = decltype(lib::invoke(
 lib::forward<F>(f),
 access::base::get_alt(lib::forward<Vs>(vs))...));
 return visit_return_type_check<Expected, Actual>::invoke(
 lib::forward<F>(f),
 access::base::get_alt(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,
 "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( \
 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( \
 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);
      }

#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, 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... Vs>
 struct make_fmatrix_impl {
 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),
 access::base::get_alt<Is>(lib::forward<Vs>(vs))...));
 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...>) {
 return &dispatch<Is...>;
 }

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 <std::size_t... Is>
 struct impl<lib::index_sequence<Is...>> {
 inline constexpr AUTO operator()() const 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...>{}()...))
 };
#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()>{}...);
 }
#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()>...>{}())
#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) {
 using Expected = dispatch_result_t<F, Vs...>;
 using Actual = decltype(lib::invoke(
 lib::forward<F>(f),
 access::base::get_alt(lib::forward<Vs>(vs))...));
 return visit_return_type_check<Expected, Actual>::invoke(
 lib::forward<F>(f),
 access::base::get_alt(lib::forward<Vs>(vs))...);
 }

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 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... 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)})

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_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)...))
};

} // namespace visitation

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)...) {}
#ifdef _MSC_VER
#pragma warning(pop)
#endif

T value;
};

template <Trait DestructibleTrait, std::size_t Index, typename... Ts>
union recursive_union;

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, \
 Args&&... args) \
 : tail_(in_place_index_t{}, 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;);

#undef MPARK_VARIANT_RECURSIVE_UNION

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 <std::size_t I, typename... Args>
 inline explicit constexpr base(in_place_index_t, Args&&... args)
 : data_(in_place_index_t{}, lib::forward<Args>(args)...), index_(I) {}

inline constexpr bool valueless_by_exception() const noexcept {
 return index_ == static_cast<index_t>(-1);
 }

inline constexpr std::size_t index() const noexcept {
    return valueless_by_exception() ? variant_npos : index_;
  }

protected:
 using data_t = recursive_union<DestructibleTrait, 0, Ts...>;

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 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_;
  }

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 {
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4100)
#endif
 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)...) {}
#endif

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 \
 }

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()) {
 visitation::alt::visit_alt(dtor{}, *this);
 }
 this->index_ = static_cast<index_t>(-1);
 });

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>;

public:
  MPARK_INHERITING_CTOR(constructor, super)
  using super::operator=;

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);
 }
 };
#endif

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) {
 lhs.destroy();
 if (!rhs.valueless_by_exception()) {
 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);
 }
#else
 ctor {}
#endif
 ,
 lhs,
 lib::forward<Rhs>(rhs));
 lhs.index_ = rhs.index_;
 }
 }
};

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; \
 }

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::Unavailable,
                               move_constructor(move_constructor&&) = delete;);

#undef MPARK_VARIANT_MOVE_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; \
 }

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::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>;

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(*this),
 lib::forward<Args>(args)...)) {
 this->destroy();
 auto& result = this->construct_alt(
 access::base::get_alt(*this), lib::forward<Args>(args)...);
 this->index_ = I;
 return result;
 }

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);
 }
 assignment* self;
 };
#endif

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);
#ifdef _MSC_VER
#pragma warning(pop)
#endif
 } else {
 struct {
 void operator()(std::true_type) const {
 this_->emplace(lib::forward<Arg>(arg_));
 }
 void operator()(std::false_type) const {
 this_->emplace(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) {
 if (this->valueless_by_exception() && that.valueless_by_exception()) {
 // do nothing.
 } else if (that.valueless_by_exception()) {
 this->destroy();
 } else {
 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);
 }
#else
 assigner<That> { this }
#endif
 ,
 *this,
 lib::forward<That>(that));
 }
 }
};

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 \
 }

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::Unavailable,
    move_assignment& operator=(move_assignment&&) = delete;);

#undef MPARK_VARIANT_MOVE_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; \
 }

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::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...>>;

public:
  MPARK_INHERITING_CTOR(impl, super)
  impl& operator=(const impl& other) = default;

template <std::size_t I, typename Arg>
 inline void assign(Arg&& arg) {
 this->assign_alt(access::base::get_alt(*this), lib::forward<Arg>(arg));
 }

inline void swap(impl& that) {
    if (this->valueless_by_exception() && that.valueless_by_exception()) {
      // do nothing.
    } else if (this->index() == that.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);
          }
#else
          swapper {}
#endif
          ,
          *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));
#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
      this->generic_construct(*rhs, lib::move(*lhs));
#endif
      this->generic_construct(*lhs, lib::move(tmp));
    }
  }

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);
 }
 };
#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()];
 }
};

#undef MPARK_INHERITING_CTOR

template <std::size_t I, typename T>
struct overload_leaf {
 using F = lib::size_constant (*)(T);
 operator F() const {
 return nullptr;
 }
};

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>... {};

public:
 using type = impl<lib::index_sequence_for<Ts...>>;
};

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>
struct is_in_place_index : std::false_type {};

template <std::size_t I>
struct is_in_place_index<in_place_index_t> : std::true_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 {};

} // namespace detail_

template <typename... Ts>
class variant {
 static_assert(
 0 < sizeof...(Ts),
 "variant must consist of at least one alternative.");

static_assert(
 lib::all<!std::is_array<Ts>::value...>::value,
 "variant can not have an array type as an alternative.");

static_assert(
 lib::all<!std::is_reference<Ts>::value...>::value,
 "variant can not have a reference type as an alternative.");

static_assert(
 lib::all<!std::is_void<Ts>::value...>::value,
 "variant can not have a void type as an alternative.");

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>{}) {}

variant(const variant&) = default;
  variant(variant&&) = default;

// NOTE [gcc 7.3.1 bug workaround]
 //
 // The original line `typename T = lib::type_pack_element_t<I, Ts...>`
 // throws the following compiler error on gcc 7.3.1:
 // ```
 // ../c10/util/variant.h:2250:9: internal compiler error:
 // unexpected expression ‘I’ of kind template_parm_index
 // typename T = lib::type_pack_element_t<I, Ts...>,
 // ^~~~~~~~
 // ```
 // As a workaround, `I` is changed to `detail_::best_match<Arg,
 // Ts...>::value`, which is the default value for `I` in this template. Note
 // that this workaround effectively disallows setting `I` to any other
 // non-default value, and we add a `static_assert` in the function body to
 // check for this.
 //
 // See the following issues for more context:
 // - https://github.com/mpark/variant/issues/43
 // - https://github.com/eggs-cpp/variant/issues/31
 template <
 typename Arg,
 typename Decayed = lib::decay_t<Arg>,
 lib::enable_if_t<!std::is_same<Decayed, variant>::value, int> = 0,
 lib::enable_if_t<!detail_::is_in_place_index<Decayed>::value, int> = 0,
 lib::enable_if_t<!detail_::is_in_place_type<Decayed>::value, int> = 0,
 std::size_t I = detail_::best_match<Arg, Ts...>::value,
 typename T = lib::
 type_pack_element_t<detail_::best_match<Arg, Ts...>::value, Ts...>,
 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{}, lib::forward<Arg>(arg)) {
 static_assert(
 I == detail_::best_match<Arg, Ts...>::value,
 "Setting template parameter `I` to a custom non-default value is not supported. "
 "Please file a feature request if you see this.");
 }

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,
 Args&&... args) noexcept(std::is_nothrow_constructible<T, Args...>::value)
 : impl_(in_place_index_t{}, 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 explicit constexpr variant(
 in_place_index_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{}, il, lib::forward<Args>(args)...) {}

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{}, 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 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{}, il, lib::forward<Args>(args)...) {}

~variant() = default;

variant& operator=(const variant&) = default;
  variant& operator=(variant&&) = default;

// NOTE: See NOTE [gcc 7.3.1 bug workaround] for the changes made to this
 // function.
 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<detail_::best_match<Arg, Ts...>::value, 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)) {
 static_assert(
 I == detail_::best_match<Arg, Ts...>::value,
 "Setting template parameter `I` to a custom non-default value is not supported. "
 "Please file a feature request if you see this.");
 impl_.template assign(lib::forward<Arg>(arg));
 return *this;
 }

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(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(il, lib::forward<Args>(args)...);
 }

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(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(il, lib::forward<Args>(args)...);
 }

inline constexpr bool valueless_by_exception() const noexcept {
    return impl_.valueless_by_exception();
  }

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>
 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_);
 }

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 {
 return v.index() == I;
}

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 {}

constexpr AUTO_REFREF operator()(V&& v) const
 AUTO_REFREF_RETURN(access::variant::get_alt(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(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) {
 return detail_::generic_get(v);
}

template <std::size_t I, typename... Ts>
inline constexpr variant_alternative_t<I, variant<Ts...>>&& get(
 variant<Ts...>&& v) {
 return detail_::generic_get(lib::move(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(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(lib::move(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) {
 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) {
 return get<detail_::find_index_checked<T, Ts...>::value>(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_ {

template <std::size_t I, typename V>
inline constexpr /* auto * */ AUTO generic_get_if(V* v) noexcept AUTO_RETURN(
 v&& holds_alternative(*v)
 ? lib::addressof(access::variant::get_alt(*v).value)
 : nullptr)

} // 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 {
 return detail_::generic_get_if(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 {
 return detail_::generic_get_if(v);
}

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 {
 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 {
 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_

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
 if (lhs.index() != rhs.index())
 return false;
 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));
#endif
}

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
 if (lhs.index() != rhs.index())
 return true;
 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));
#endif
}

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
 if (rhs.valueless_by_exception())
 return false;
 if (lhs.valueless_by_exception())
 return true;
 if (lhs.index() < rhs.index())
 return true;
 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)));
#endif
}

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
 if (lhs.valueless_by_exception())
 return false;
 if (rhs.valueless_by_exception())
 return true;
 if (lhs.index() > rhs.index())
 return true;
 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)));
#endif
}

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
 if (lhs.valueless_by_exception())
 return true;
 if (rhs.valueless_by_exception())
 return false;
 if (lhs.index() < rhs.index())
 return true;
 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))));
#endif
}

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
 if (rhs.valueless_by_exception())
 return true;
 if (lhs.valueless_by_exception())
 return false;
 if (lhs.index() > rhs.index())
 return true;
 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))));
#endif
}

struct monostate {};

inline constexpr bool operator<(monostate, monostate) noexcept {
 return false;
}

inline constexpr bool operator>(monostate, monostate) noexcept {
  return false;
}

inline constexpr bool operator<=(monostate, monostate) noexcept {
 return true;
}

inline constexpr bool operator>=(monostate, monostate) noexcept {
  return true;
}

inline constexpr bool operator==(monostate, monostate) noexcept {
  return true;
}

inline constexpr bool operator!=(monostate, monostate) noexcept {
  return false;
}

#ifdef MPARK_CPP14_CONSTEXPR
namespace detail_ {

inline constexpr bool any(std::initializer_list<bool> bs) {
 for (bool b : bs) {
 if (b) {
 return true;
 }
 }
 return false;
}

} // namespace detail_

template <typename Visitor, typename... Vs>
inline constexpr decltype(auto) visit(Visitor&& visitor, Vs&&... vs) {
 return (!detail_::any({vs.valueless_by_exception()...})
 ? (void)0
 : throw_bad_variant_access()),
 detail_::visitation::variant::visit_value(
 lib::forward<Visitor>(visitor), lib::forward<Vs>(vs)...);
}
#else
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(const lib::array<bool, N>& bs) {
 return all_impl(bs, 0);
}

} // 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)...))
#endif

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_ {

template <typename T, typename...>
using enabled_type = T;

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 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 detail_

#undef AUTO
#undef AUTO_RETURN

#undef AUTO_REFREF
#undef AUTO_REFREF_RETURN

#undef DECLTYPE_AUTO
#undef DECLTYPE_AUTO_RETURN

} // namespace c10

namespace std {

template <typename... Ts>
struct hash<c10::detail_::enabled_type<
 c10::variant<Ts...>,
 c10::lib::enable_if_t<c10::lib::all<c10::detail_::hash::is_enabled<
 c10::lib::remove_const_t<Ts>>()...>::value>>> {
 using argument_type = c10::variant<Ts...>;
 using result_type = std::size_t;

inline result_type operator()(const argument_type& v) const {
 using c10::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 = c10::lib::decay_t<decltype(alt)>;
 using value_type =
 c10::lib::remove_const_t<typename alt_type::value_type>;
 return hash<value_type>{}(alt.value);
 }
#else
 hasher {}
#endif
 ,
 v);
 return hash_combine(result, hash<std::size_t>{}(v.index()));
 }

private:
#ifndef MPARK_GENERIC_LAMBDAS
 struct hasher {
 template <typename Alt>
 inline std::size_t operator()(const Alt& alt) const {
 using alt_type = c10::lib::decay_t<Alt>;
 using value_type =
 c10::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);
 }
};

template <>
struct hash<c10::monostate> {
 using argument_type = c10::monostate;
 using result_type = std::size_t;

inline result_type operator()(const argument_type&) const noexcept {
    return 66740831; // return a fundamentally attractive random value.
  }
};

} // namespace std

#endif // C10_UTIL_VARIANT_H_

// MPark.Variant // // Copyright Michael Park, 2015-2017 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE.md or copy at // http://boost.org/LICENSE_1_0.txt) // // From https://github.com/mpark/variant // // C10 // - Move to `c10` namespace. // - Rename namespace `detail` to `detail_`, to not conflict with existing // c10 implementations in `detail` namespace. // - In two functions, the template name reference `I` is changed to // `detail_::best_match::value` to work around gcc 7.3.1 bug. // However, this workaround also limits the use cases of `c10::variant`. // Please see NOTE [gcc 7.3.1 bug workaround] for details. // - The following code is moved to `c10/util/in_place.h`: // ``` // struct in_place_t { explicit in_place_t() = default; }; // // template // struct in_place_index_t { explicit in_place_index_t() = default; }; // // template // struct in_place_type_t { explicit in_place_type_t() = default; }; // // constexpr in_place_t in_place{}; // ``` // so that they can also be used in `c10/util/Optional.h`. #ifndef C10_UTIL_VARIANT_H_ #define C10_UTIL_VARIANT_H_ /* variant synopsis namespace std { // 20.7.2, class template variant template class variant { public: // 20.7.2.1, constructors constexpr variant() noexcept(see below); variant(const variant&); variant(variant&&) noexcept(see below); template constexpr variant(T&&) noexcept(see below); template constexpr explicit variant(in_place_type_t, Args&&...); template constexpr explicit variant( in_place_type_t, initializer_list, Args&&...); template constexpr explicit variant(in_place_index_t, Args&&...); template constexpr explicit variant( in_place_index_t, initializer_list, Args&&...); // 20.7.2.2, destructor ~variant(); // 20.7.2.3, assignment variant& operator=(const variant&); variant& operator=(variant&&) noexcept(see below); template variant& operator=(T&&) noexcept(see below); // 20.7.2.4, modifiers template T& emplace(Args&&...); template T& emplace(initializer_list, Args&&...); template variant_alternative& emplace(Args&&...); template variant_alternative& emplace(initializer_list, Args&&...); // 20.7.2.5, value status constexpr bool valueless_by_exception() const noexcept; constexpr size_t index() const noexcept; // 20.7.2.6, swap void swap(variant&) noexcept(see below); }; // 20.7.3, variant helper classes template struct variant_size; // undefined template constexpr size_t variant_size_v = variant_size::value; template struct variant_size; template struct variant_size; template struct variant_size; template struct variant_size>; template struct variant_alternative; // undefined template using variant_alternative_t = typename variant_alternative::type; template struct variant_alternative; template struct variant_alternative; template struct variant_alternative; template struct variant_alternative>; constexpr size_t variant_npos = -1; // 20.7.4, value access template constexpr bool holds_alternative(const variant&) noexcept; template constexpr variant_alternative_t>& get(variant&); template constexpr variant_alternative_t>&& get(variant&&); template constexpr variant_alternative_t> const& get(const variant&); template constexpr variant_alternative_t> const&& get(const variant&&); template constexpr T& get(variant&); template constexpr T&& get(variant&&); template constexpr const T& get(const variant&); template constexpr const T&& get(const variant&&); template constexpr add_pointer_t>> get_if(variant*) noexcept; template constexpr add_pointer_t>> get_if(const variant*) noexcept; template constexpr add_pointer_t get_if(variant*) noexcept; template constexpr add_pointer_t get_if(const variant*) noexcept; // 20.7.5, relational operators template constexpr bool operator==(const variant&, const variant&); template constexpr bool operator!=(const variant&, const variant&); template constexpr bool operator<(const variant&, const variant&); template constexpr bool operator>(const variant&, const variant&); template constexpr bool operator<=(const variant&, const variant&); template constexpr bool operator>=(const variant&, const variant&); // 20.7.6, visitation template constexpr see below visit(Visitor&&, Variants&&...); // 20.7.7, class monostate struct monostate; // 20.7.8, monostate relational operators constexpr bool operator<(monostate, monostate) noexcept; constexpr bool operator>(monostate, monostate) noexcept; constexpr bool operator<=(monostate, monostate) noexcept; constexpr bool operator>=(monostate, monostate) noexcept; constexpr bool operator==(monostate, monostate) noexcept; constexpr bool operator!=(monostate, monostate) noexcept; // 20.7.9, specialized algorithms template void swap(variant&, variant&) noexcept(see below); // 20.7.10, class bad_variant_access class bad_variant_access; // 20.7.11, hash support template struct hash; template struct hash>; template <> struct hash; } // namespace std */ #include #include #include #include #include #include #include // MPark.Variant // // Copyright Michael Park, 2015-2017 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE.md or copy at // http://boost.org/LICENSE_1_0.txt) #ifndef MPARK_CONFIG_HPP #define MPARK_CONFIG_HPP // MSVC 2015 Update 3. #if __cplusplus < 201103L && (!defined(_MSC_VER) || _MSC_FULL_VER < 190024210) #error "MPark.Variant requires C++11 support." #endif #ifndef __has_attribute #define __has_attribute(x) 0 #endif #ifndef __has_builtin #define __has_builtin(x) 0 #endif #ifndef __has_include #define __has_include(x) 0 #endif #ifndef __has_feature #define __has_feature(x) 0 #endif #if __has_attribute(always_inline) || defined(__GNUC__) #define MPARK_ALWAYS_INLINE __attribute__((__always_inline__)) inline #elif defined(_MSC_VER) #define MPARK_ALWAYS_INLINE __forceinline #else #define MPARK_ALWAYS_INLINE inline #endif #if __has_builtin(__builtin_addressof) || \ (defined(__GNUC__) && __GNUC__ >= 7) || defined(_MSC_VER) #define MPARK_BUILTIN_ADDRESSOF #endif #if __has_builtin(__builtin_unreachable) || defined(__GNUC__) #define MPARK_BUILTIN_UNREACHABLE __builtin_unreachable() #elif defined(_MSC_VER) #define MPARK_BUILTIN_UNREACHABLE __assume(false) #else #define MPARK_BUILTIN_UNREACHABLE #endif #if __has_builtin(__type_pack_element) #define MPARK_TYPE_PACK_ELEMENT #endif #if defined(__cpp_constexpr) && __cpp_constexpr >= 200704 && \ !(defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 9) #define MPARK_CPP11_CONSTEXPR #endif #if defined(__cpp_constexpr) && __cpp_constexpr >= 201304 #define MPARK_CPP14_CONSTEXPR #endif #if __has_feature(cxx_exceptions) || defined(__cpp_exceptions) || \ (defined(_MSC_VER) && defined(_CPPUNWIND)) #define MPARK_EXCEPTIONS #endif #if defined(__cpp_generic_lambdas) || defined(_MSC_VER) #define MPARK_GENERIC_LAMBDAS #endif #if defined(__cpp_lib_integer_sequence) #define MPARK_INTEGER_SEQUENCE #endif #if defined(__cpp_return_type_deduction) || defined(_MSC_VER) #define MPARK_RETURN_TYPE_DEDUCTION #endif #if defined(__cpp_lib_transparent_operators) || defined(_MSC_VER) #define MPARK_TRANSPARENT_OPERATORS #endif #if defined(__cpp_variable_templates) || defined(_MSC_VER) #define MPARK_VARIABLE_TEMPLATES #endif #if !defined(__GLIBCXX__) || __has_include() // >= libstdc++-5 #define MPARK_TRIVIALITY_TYPE_TRAITS #define MPARK_INCOMPLETE_TYPE_TRAITS #endif #endif // MPARK_CONFIG_HPP // MPark.Variant // // Copyright Michael Park, 2015-2017 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE.md or copy at // http://boost.org/LICENSE_1_0.txt) #ifndef MPARK_IN_PLACE_HPP #define MPARK_IN_PLACE_HPP #include #include namespace c10 { #ifdef MPARK_VARIABLE_TEMPLATES template constexpr in_place_index_t in_place_index{}; template constexpr in_place_type_t in_place_type{}; #endif } // namespace c10 #endif // MPARK_IN_PLACE_HPP // MPark.Variant // // Copyright Michael Park, 2015-2017 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE.md or copy at // http://boost.org/LICENSE_1_0.txt) #ifndef MPARK_LIB_HPP #define MPARK_LIB_HPP #include #include #include #include #define MPARK_RETURN(...) \ noexcept(noexcept(__VA_ARGS__))->decltype(__VA_ARGS__) { \ return __VA_ARGS__; \ } namespace c10 { namespace lib { template struct identity { using type = T; }; inline namespace cpp14 { template struct array { constexpr const T& operator[](std::size_t index) const { return data[index]; } T data[N == 0 ? 1 : N]; }; template using add_pointer_t = typename std::add_pointer::type; template using common_type_t = typename std::common_type::type; template using decay_t = typename std::decay::type; template using enable_if_t = typename std::enable_if::type; template using remove_const_t = typename std::remove_const::type; template using remove_reference_t = typename std::remove_reference::type; template inline constexpr T&& forward(remove_reference_t& t) noexcept { return static_cast(t); } template inline constexpr T&& forward(remove_reference_t&& t) noexcept { static_assert( !std::is_lvalue_reference::value, "can not forward an rvalue as an lvalue"); return static_cast(t); } template inline constexpr remove_reference_t&& move(T&& t) noexcept { return static_cast&&>(t); } #ifdef MPARK_INTEGER_SEQUENCE using std::index_sequence; using std::index_sequence_for; using std::integer_sequence; using std::make_index_sequence; #else template struct integer_sequence { using value_type = T; static constexpr std::size_t size() noexcept { return sizeof...(Is); } }; template using index_sequence = integer_sequence; template struct make_index_sequence_concat; template struct make_index_sequence_concat< index_sequence, index_sequence> : identity> {}; template struct make_index_sequence_impl; template using make_index_sequence = typename make_index_sequence_impl::type; template struct make_index_sequence_impl : make_index_sequence_concat< make_index_sequence, make_index_sequence> {}; template <> struct make_index_sequence_impl<0> : identity> {}; template <> struct make_index_sequence_impl<1> : identity> {}; template using index_sequence_for = make_index_sequence; #endif // #ifdef MPARK_TRANSPARENT_OPERATORS using equal_to = std::equal_to<>; #else struct equal_to { template inline constexpr auto operator()(Lhs&& lhs, Rhs&& rhs) const MPARK_RETURN(lib::forward(lhs) == lib::forward(rhs)) }; #endif #ifdef MPARK_TRANSPARENT_OPERATORS using not_equal_to = std::not_equal_to<>; #else struct not_equal_to { template inline constexpr auto operator()(Lhs&& lhs, Rhs&& rhs) const MPARK_RETURN(lib::forward(lhs) != lib::forward(rhs)) }; #endif #ifdef MPARK_TRANSPARENT_OPERATORS using less = std::less<>; #else struct less { template inline constexpr auto operator()(Lhs&& lhs, Rhs&& rhs) const MPARK_RETURN(lib::forward(lhs) < lib::forward(rhs)) }; #endif #ifdef MPARK_TRANSPARENT_OPERATORS using greater = std::greater<>; #else struct greater { template inline constexpr auto operator()(Lhs&& lhs, Rhs&& rhs) const MPARK_RETURN(lib::forward(lhs) > lib::forward(rhs)) }; #endif #ifdef MPARK_TRANSPARENT_OPERATORS using less_equal = std::less_equal<>; #else struct less_equal { template inline constexpr auto operator()(Lhs&& lhs, Rhs&& rhs) const MPARK_RETURN(lib::forward(lhs) <= lib::forward(rhs)) }; #endif #ifdef MPARK_TRANSPARENT_OPERATORS using greater_equal = std::greater_equal<>; #else struct greater_equal { template inline constexpr auto operator()(Lhs&& lhs, Rhs&& rhs) const MPARK_RETURN(lib::forward(lhs) >= lib::forward(rhs)) }; #endif } // namespace cpp14 inline namespace cpp17 { // template using bool_constant = std::integral_constant; template struct voider : identity {}; template using void_t = typename voider::type; namespace detail_ { namespace swappable { using std::swap; template struct is_swappable { private: template < typename U, typename = decltype(swap(std::declval(), std::declval()))> inline static std::true_type test(int); template inline static std::false_type test(...); public: static constexpr bool value = decltype(test(0))::value; }; template struct is_nothrow_swappable { static constexpr bool value = noexcept(swap(std::declval(), std::declval())); }; template struct is_nothrow_swappable : std::false_type {}; } // namespace swappable } // namespace detail_ using detail_::swappable::is_swappable; template using is_nothrow_swappable = detail_::swappable::is_nothrow_swappable::value, T>; // namespace detail_ { template struct is_reference_wrapper : std::false_type {}; template struct is_reference_wrapper> : std::true_type {}; template struct Invoke; template <> struct Invoke { template inline static constexpr auto invoke(R T::*pmf, Arg&& arg, Args&&... args) MPARK_RETURN((lib::forward(arg).*pmf)(lib::forward(args)...)) }; template <> struct Invoke { template inline static constexpr auto invoke(R T::*pmf, Arg&& arg, Args&&... args) MPARK_RETURN( (lib::forward(arg).get().*pmf)(lib::forward(args)...)) }; template <> struct Invoke { template inline static constexpr auto invoke(R T::*pmf, Arg&& arg, Args&&... args) MPARK_RETURN( ((*lib::forward(arg)).*pmf)(lib::forward(args)...)) }; template <> struct Invoke { template inline static constexpr auto invoke(R T::*pmo, Arg&& arg) MPARK_RETURN(lib::forward(arg).*pmo) }; template <> struct Invoke { template inline static constexpr auto invoke(R T::*pmo, Arg&& arg) MPARK_RETURN(lib::forward(arg).get().*pmo) }; template <> struct Invoke { template inline static constexpr auto invoke(R T::*pmo, Arg&& arg) MPARK_RETURN((*lib::forward(arg)).*pmo) }; template inline constexpr auto invoke(R T::*f, Arg&& arg, Args&&... args) MPARK_RETURN( Invoke< std::is_function::value, (std::is_base_of>::value ? 0 : is_reference_wrapper>::value ? 1 : 2)>:: invoke(f, lib::forward(arg), lib::forward(args)...)) #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable : 4100) #endif template inline constexpr auto invoke(F&& f, Args&&... args) MPARK_RETURN(lib::forward(f)(lib::forward(args)...)) #ifdef _MSC_VER #pragma warning(pop) #endif } // namespace detail_ template inline constexpr auto invoke(F&& f, Args&&... args) MPARK_RETURN( detail_::invoke(lib::forward(f), lib::forward(args)...)) namespace detail_ { template struct invoke_result {}; template struct invoke_result< void_t(), std::declval()...))>, F, Args...> : identity(), std::declval()...))> {}; } // namespace detail_ template using invoke_result = detail_::invoke_result; template using invoke_result_t = typename invoke_result::type; namespace detail_ { template struct is_invocable : std::false_type {}; template struct is_invocable>, F, Args...> : std::true_type {}; template struct is_invocable_r : std::false_type {}; template struct is_invocable_r>, R, F, Args...> : std::is_convertible, R> {}; } // namespace detail_ template using is_invocable = detail_::is_invocable; template using is_invocable_r = detail_::is_invocable_r; namespace detail_ { template struct is_nothrow_invocable { static constexpr bool value = noexcept(lib::invoke(std::declval(), std::declval()...)); }; template struct is_nothrow_invocable : std::false_type {}; template struct is_nothrow_invocable_r { private: inline static R impl() { return lib::invoke(std::declval(), std::declval()...); } public: static constexpr bool value = noexcept(impl()); }; template struct is_nothrow_invocable_r : std::false_type {}; } // namespace detail_ template using is_nothrow_invocable = detail_::is_nothrow_invocable::value, F, Args...>; template using is_nothrow_invocable_r = detail_:: is_nothrow_invocable_r::value, R, F, Args...>; // #ifdef MPARK_BUILTIN_ADDRESSOF template inline constexpr T* addressof(T& arg) noexcept { return __builtin_addressof(arg); } #else namespace detail_ { namespace has_addressof_impl { struct fail; template inline fail operator&(T&&); template inline static constexpr bool impl() { return (std::is_class::value || std::is_union::value) && !std::is_same()), fail>::value; } } // namespace has_addressof_impl template using has_addressof = bool_constant()>; template inline constexpr T* addressof(T& arg, std::true_type) noexcept { return std::addressof(arg); } template inline constexpr T* addressof(T& arg, std::false_type) noexcept { return &arg; } } // namespace detail_ template inline constexpr T* addressof(T& arg) noexcept { return detail_::addressof(arg, detail_::has_addressof{}); } #endif template inline constexpr T* addressof(const T&&) = delete; } // namespace cpp17 template struct remove_all_extents : identity {}; template struct remove_all_extents> : remove_all_extents {}; template using remove_all_extents_t = typename remove_all_extents::type; template using size_constant = std::integral_constant; template struct indexed_type : size_constant { using type = T; }; template using all = std::is_same< integer_sequence, integer_sequence>; #ifdef MPARK_TYPE_PACK_ELEMENT template using type_pack_element_t = __type_pack_element; #else template struct type_pack_element_impl { private: template struct set; template struct set> : indexed_type... {}; template inline static std::enable_if impl(indexed_type); inline static std::enable_if impl(...); public: using type = decltype(impl(set>{})); }; template using type_pack_element = typename type_pack_element_impl::type; template using type_pack_element_t = typename type_pack_element::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; #else template struct is_trivially_copy_constructible : bool_constant::value&& __has_trivial_copy( T)> {}; template struct is_trivially_move_constructible : bool_constant<__is_trivial(T)> {}; template struct is_trivially_copy_assignable : bool_constant::value&& __has_trivial_assign( T)> {}; template struct is_trivially_move_assignable : bool_constant<__is_trivial(T)> {}; #endif template struct dependent_type : T {}; template struct push_back; template using push_back_t = typename push_back::type; template struct push_back, J> { using type = index_sequence; }; } // namespace lib } // namespace c10 #undef MPARK_RETURN #endif // MPARK_LIB_HPP namespace c10 { #ifdef MPARK_RETURN_TYPE_DEDUCTION #define AUTO auto #define AUTO_RETURN(...) \ { return __VA_ARGS__; } #define AUTO_REFREF auto&& #define AUTO_REFREF_RETURN(...) \ { return __VA_ARGS__; } #define DECLTYPE_AUTO decltype(auto) #define DECLTYPE_AUTO_RETURN(...) \ { return __VA_ARGS__; } #else #define AUTO auto #define AUTO_RETURN(...) \ ->lib::decay_t { \ return __VA_ARGS__; \ } #define AUTO_REFREF auto #define AUTO_REFREF_RETURN(...) \ ->decltype((__VA_ARGS__)) { \ static_assert(std::is_reference::value, ""); \ return __VA_ARGS__; \ } #define DECLTYPE_AUTO auto #define DECLTYPE_AUTO_RETURN(...) \ ->decltype(__VA_ARGS__) { \ return __VA_ARGS__; \ } #endif class bad_variant_access : public std::exception { public: const char* what() const noexcept override { return "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 class variant; template struct variant_size; #ifdef MPARK_VARIABLE_TEMPLATES template constexpr std::size_t variant_size_v = variant_size::value; #endif template struct variant_size : variant_size {}; template struct variant_size : variant_size {}; template struct variant_size : variant_size {}; template struct variant_size> : lib::size_constant {}; template struct variant_alternative; template using variant_alternative_t = typename variant_alternative::type; template struct variant_alternative : std::add_const> {}; template struct variant_alternative : std::add_volatile> {}; template struct variant_alternative : std::add_cv> {}; template struct variant_alternative> { static_assert( I < sizeof...(Ts), "index out of bounds in `std::variant_alternative<>`"); using type = lib::type_pack_element_t; }; constexpr std::size_t variant_npos = static_cast(-1); namespace detail_ { constexpr std::size_t not_found = static_cast(-1); constexpr std::size_t ambiguous = static_cast(-2); #ifdef MPARK_CPP14_CONSTEXPR template inline constexpr std::size_t find_index() { constexpr lib::array matches = { {std::is_same::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; } } return result; } #else inline constexpr std::size_t find_index_impl(std::size_t result, std::size_t) { return result; } template 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 inline constexpr std::size_t find_index() { return find_index_impl(not_found, 0, std::is_same::value...); } #endif template using find_index_sfinae_impl = lib::enable_if_t>; template using find_index_sfinae = find_index_sfinae_impl()>; template struct find_index_checked_impl : lib::size_constant { static_assert(I != not_found, "the specified type is not found."); static_assert(I != ambiguous, "the specified type is ambiguous."); }; template using find_index_checked = find_index_checked_impl()>; struct valueless_t {}; enum class Trait { TriviallyAvailable, Available, Unavailable }; template < typename T, template class IsTriviallyAvailable, template class IsAvailable> inline constexpr Trait trait() { return IsTriviallyAvailable::value ? Trait::TriviallyAvailable : IsAvailable::value ? Trait::Available : Trait::Unavailable; } #ifdef MPARK_CPP14_CONSTEXPR template inline constexpr Trait common_trait(Traits... traits_) { Trait result = Trait::TriviallyAvailable; lib::array traits = {{traits_...}}; for (std::size_t i = 0; i < sizeof...(Traits); ++i) { Trait t = traits[i]; if (static_cast(t) > static_cast(result)) { result = t; } } return result; } #else inline constexpr Trait common_trait_impl(Trait result) { return result; } template inline constexpr Trait common_trait_impl(Trait result, Trait t, Traits... ts) { return static_cast(t) > static_cast(result) ? common_trait_impl(t, ts...) : common_trait_impl(result, ts...); } template inline constexpr Trait common_trait(Traits... ts) { return common_trait_impl(Trait::TriviallyAvailable, ts...); } #endif template 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 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 destructible_trait = common_trait( trait()...); }; namespace access { struct recursive_union { #ifdef MPARK_RETURN_TYPE_DEDUCTION template inline static constexpr auto&& get_alt(V&& v, in_place_index_t<0>) { return lib::forward(v).head_; } template inline static constexpr auto&& get_alt(V&& v, in_place_index_t) { return get_alt(lib::forward(v).tail_, in_place_index_t{}); } #else template struct get_alt_impl { template inline constexpr AUTO_REFREF operator()(V&& v) const AUTO_REFREF_RETURN(get_alt_impl{}(lib::forward(v).tail_)) }; template struct get_alt_impl<0, Dummy> { template inline constexpr AUTO_REFREF operator()(V&& v) const AUTO_REFREF_RETURN(lib::forward(v).head_) }; template inline static constexpr AUTO_REFREF get_alt(V&& v, in_place_index_t) AUTO_REFREF_RETURN(get_alt_impl{}(lib::forward(v))) #endif }; struct base { template inline static constexpr AUTO_REFREF get_alt(V&& v) #ifdef _MSC_VER AUTO_REFREF_RETURN(recursive_union::get_alt( lib::forward(v).data_, in_place_index_t{})) #else AUTO_REFREF_RETURN(recursive_union::get_alt( data(lib::forward(v)), in_place_index_t{})) #endif }; struct variant { template inline static constexpr AUTO_REFREF get_alt(V&& v) AUTO_REFREF_RETURN(base::get_alt(lib::forward(v).impl_)) }; } // namespace access namespace visitation { #if defined(MPARK_CPP14_CONSTEXPR) && !defined(_MSC_VER) #define MPARK_VARIANT_SWITCH_VISIT #endif struct base { template using dispatch_result_t = decltype(lib::invoke( std::declval(), access::base::get_alt<0>(std::declval())...)); template struct expected { template inline static constexpr bool but_got() { return std::is_same::value; } }; template struct visit_return_type_check { static_assert( expected::template but_got(), "`visit` requires the visitor to have a single return type"); template inline static constexpr DECLTYPE_AUTO invoke( Visitor&& visitor, Alts&&... alts) DECLTYPE_AUTO_RETURN(lib::invoke( lib::forward(visitor), lib::forward(alts)...)) }; #ifdef MPARK_VARIANT_SWITCH_VISIT template struct dispatcher; template struct dispatcher { template MPARK_ALWAYS_INLINE static constexpr R dispatch( F&&, typename ITs::type&&..., Vs&&...) { MPARK_BUILTIN_UNREACHABLE; } template MPARK_ALWAYS_INLINE static constexpr R dispatch_case(F&&, Vs&&...) { MPARK_BUILTIN_UNREACHABLE; } template MPARK_ALWAYS_INLINE static constexpr R dispatch_at( std::size_t, F&&, Vs&&...) { MPARK_BUILTIN_UNREACHABLE; } }; template struct dispatcher { template 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), access::base::get_alt( lib::forward(visited_vs))...)); return visit_return_type_check::invoke( lib::forward(f), access::base::get_alt( lib::forward(visited_vs))...); } template 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::size()), \ R, \ ITs..., \ lib::indexed_type>:: \ template dispatch<0>( \ lib::forward(f), \ lib::forward(visited_vs)..., \ lib::forward(v), \ lib::forward(vs)...) #define MPARK_DEFAULT(I) \ dispatcher<(I < lib::decay_t::size()), R, ITs...>::template dispatch( \ lib::forward(f), \ lib::forward(visited_vs)..., \ lib::forward(v), \ lib::forward(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); } #undef MPARK_DEFAULT #undef MPARK_DISPATCH } template MPARK_ALWAYS_INLINE static constexpr R dispatch_case(F&& f, Vs&&... vs) { using Expected = R; using Actual = decltype(lib::invoke( lib::forward(f), access::base::get_alt(lib::forward(vs))...)); return visit_return_type_check::invoke( lib::forward(f), access::base::get_alt(lib::forward(vs))...); } template 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::size() == lib::decay_t::size())...>::value, "all of the variants must be the same size."); #define MPARK_DISPATCH_AT(I) \ dispatcher<(I < lib::decay_t::size()), R>::template dispatch_case( \ lib::forward(f), lib::forward(v), lib::forward(vs)...) #define MPARK_DEFAULT(I) \ dispatcher<(I < lib::decay_t::size()), R>::template dispatch_at( \ index, lib::forward(f), lib::forward(v), lib::forward(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); } #undef MPARK_DEFAULT #undef MPARK_DISPATCH_AT } }; #else template inline static constexpr const T& at(const T& elem) noexcept { return elem; } template inline static constexpr const lib::remove_all_extents_t& at( const lib::array& elems, std::size_t i, Is... is) noexcept { return at(elems[i], is...); } template inline static constexpr lib::array, sizeof...(Fs) + 1> make_farray(F&& f, Fs&&... fs) { return {{lib::forward(f), lib::forward(fs)...}}; } template struct make_fmatrix_impl { template inline static constexpr dispatch_result_t dispatch( F&& f, Vs&&... vs) { using Expected = dispatch_result_t; using Actual = decltype(lib::invoke( lib::forward(f), access::base::get_alt(lib::forward(vs))...)); return visit_return_type_check::invoke( lib::forward(f), access::base::get_alt(lib::forward(vs))...); } #ifdef MPARK_RETURN_TYPE_DEDUCTION template inline static constexpr auto impl(lib::index_sequence) { return &dispatch; } template inline static constexpr auto impl( Is, lib::index_sequence, Ls... ls) { return make_farray(impl(lib::push_back_t{}, ls...)...); } #else template struct impl; template struct impl> { inline constexpr AUTO operator()() const AUTO_RETURN(&dispatch) }; template struct impl, Ls...> { inline constexpr AUTO operator()() const AUTO_RETURN(make_farray(impl, Ls...>{}()...)) }; #endif }; #ifdef MPARK_RETURN_TYPE_DEDUCTION template inline static constexpr auto make_fmatrix() { return make_fmatrix_impl::impl( lib::index_sequence<>{}, lib::make_index_sequence::size()>{}...); } #else template inline static constexpr AUTO make_fmatrix() AUTO_RETURN(typename make_fmatrix_impl::template impl< lib::index_sequence<>, lib::make_index_sequence::size()>...>{}()) #endif template struct make_fdiagonal_impl { template inline static constexpr dispatch_result_t dispatch( F&& f, Vs&&... vs) { using Expected = dispatch_result_t; using Actual = decltype(lib::invoke( lib::forward(f), access::base::get_alt(lib::forward(vs))...)); return visit_return_type_check::invoke( lib::forward(f), access::base::get_alt(lib::forward(vs))...); } template inline static constexpr AUTO impl(lib::index_sequence) AUTO_RETURN(make_farray(&dispatch...)) }; template inline static constexpr auto make_fdiagonal() -> decltype(make_fdiagonal_impl::impl( lib::make_index_sequence::size()>{})) { static_assert( lib::all<( lib::decay_t::size() == lib::decay_t::size())...>::value, "all of the variants must be the same size."); return make_fdiagonal_impl::impl( lib::make_index_sequence::size()>{}); } #endif }; #if !defined(MPARK_VARIANT_SWITCH_VISIT) && \ (!defined(_MSC_VER) || _MSC_VER >= 1910) template using fmatrix_t = decltype(base::make_fmatrix()); template struct fmatrix { static constexpr fmatrix_t value = base::make_fmatrix(); }; template constexpr fmatrix_t fmatrix::value; template using fdiagonal_t = decltype(base::make_fdiagonal()); template struct fdiagonal { static constexpr fdiagonal_t value = base::make_fdiagonal(); }; template constexpr fdiagonal_t fdiagonal::value; #endif struct alt { template 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)))...>>:: template dispatch<0>( lib::forward(visitor), as_base(lib::forward(vs))...)) #elif !defined(_MSC_VER) || _MSC_VER >= 1910 DECLTYPE_AUTO_RETURN(base::at( fmatrix(vs)))...>::value, vs.index()...)( lib::forward(visitor), as_base(lib::forward(vs))...)) #else DECLTYPE_AUTO_RETURN(base::at( base::make_fmatrix< Visitor&&, decltype(as_base(lib::forward(vs)))...>(), vs.index()...)( lib::forward(visitor), as_base(lib::forward(vs))...)) #endif template 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)))...>>:: template dispatch_at<0>( index, lib::forward(visitor), as_base(lib::forward(vs))...)) #elif !defined(_MSC_VER) || _MSC_VER >= 1910 DECLTYPE_AUTO_RETURN(base::at( fdiagonal(vs)))...>:: value, index)( lib::forward(visitor), as_base(lib::forward(vs))...)) #else DECLTYPE_AUTO_RETURN(base::at( base::make_fdiagonal< Visitor&&, decltype(as_base(lib::forward(vs)))...>(), index)( lib::forward(visitor), as_base(lib::forward(vs))...)) #endif }; struct variant { private: template struct visitor { template inline static constexpr bool does_not_handle() { return lib::is_invocable::value; } }; template struct visit_exhaustiveness_check { static_assert( visitor::template does_not_handle(), "`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), lib::forward(values)...)) }; template struct value_visitor { Visitor&& visitor_; template inline constexpr DECLTYPE_AUTO operator()(Alts&&... alts) const DECLTYPE_AUTO_RETURN(visit_exhaustiveness_check< Visitor, decltype((lib::forward(alts).value))...>:: invoke( lib::forward(visitor_), lib::forward(alts).value...)) }; template inline static constexpr AUTO make_value_visitor(Visitor&& visitor) AUTO_RETURN(value_visitor{lib::forward(visitor)}) public : template inline static constexpr DECLTYPE_AUTO visit_alt(Visitor&& visitor, Vs&&... vs) DECLTYPE_AUTO_RETURN(alt::visit_alt( lib::forward(visitor), lib::forward(vs).impl_...)) template 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), lib::forward(vs).impl_...)) template inline static constexpr DECLTYPE_AUTO visit_value(Visitor&& visitor, Vs&&... vs) DECLTYPE_AUTO_RETURN(visit_alt( make_value_visitor(lib::forward(visitor)), lib::forward(vs)...)) template 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)), lib::forward(vs)...)) }; } // namespace visitation template struct alt { using value_type = T; #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable : 4244) #endif template inline explicit constexpr alt(in_place_t, Args&&... args) : value(lib::forward(args)...) {} #ifdef _MSC_VER #pragma warning(pop) #endif T value; }; template union recursive_union; template union recursive_union {}; #define MPARK_VARIANT_RECURSIVE_UNION(destructible_trait, destructor) \ template \ union recursive_union { \ public: \ inline explicit constexpr recursive_union(valueless_t) noexcept \ : dummy_{} {} \ \ template \ inline explicit constexpr recursive_union( \ in_place_index_t<0>, \ Args&&... args) \ : head_(in_place_t{}, lib::forward(args)...) {} \ \ template \ inline explicit constexpr recursive_union( \ in_place_index_t, \ Args&&... args) \ : tail_(in_place_index_t{}, lib::forward(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 head_; \ recursive_union 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;); #undef MPARK_VARIANT_RECURSIVE_UNION using index_t = unsigned int; template class base { public: inline explicit constexpr base(valueless_t tag) noexcept : data_(tag), index_(static_cast(-1)) {} template inline explicit constexpr base(in_place_index_t, Args&&... args) : data_(in_place_index_t{}, lib::forward(args)...), index_(I) {} inline constexpr bool valueless_by_exception() const noexcept { return index_ == static_cast(-1); } inline constexpr std::size_t index() const noexcept { return valueless_by_exception() ? variant_npos : index_; } protected: using data_t = recursive_union; 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 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_; } 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 { #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable : 4100) #endif template 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 \ inline explicit constexpr type(Args&&... args) \ : base(lib::forward(args)...) {} #endif template class destructor; #define MPARK_VARIANT_DESTRUCTOR(destructible_trait, definition, destroy) \ template \ class destructor, destructible_trait> \ : public base { \ using super = base; \ \ 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(-1); }); 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(-1); }); MPARK_VARIANT_DESTRUCTOR(Trait::Unavailable, ~destructor() = delete; , inline void destroy() noexcept = delete;); #undef MPARK_VARIANT_DESTRUCTOR template class constructor : public destructor { using super = destructor; public: MPARK_INHERITING_CTOR(constructor, super) using super::operator=; protected: #ifndef MPARK_GENERIC_LAMBDAS struct ctor { template inline void operator()(LhsAlt& lhs_alt, RhsAlt&& rhs_alt) const { constructor::construct_alt(lhs_alt, lib::forward(rhs_alt).value); } }; #endif template inline static T& construct_alt(alt& a, Args&&... args) { auto* result = ::new (static_cast(lib::addressof(a))) alt(in_place_t{}, lib::forward(args)...); return result->value; } template inline static void generic_construct(constructor& lhs, Rhs&& rhs) { lhs.destroy(); if (!rhs.valueless_by_exception()) { visitation::alt::visit_alt_at( rhs.index(), #ifdef MPARK_GENERIC_LAMBDAS [](auto& lhs_alt, auto&& rhs_alt) { constructor::construct_alt( lhs_alt, lib::forward(rhs_alt).value); } #else ctor {} #endif , lhs, lib::forward(rhs)); lhs.index_ = rhs.index_; } } }; template class move_constructor; #define MPARK_VARIANT_MOVE_CONSTRUCTOR(move_constructible_trait, definition) \ template \ class move_constructor, move_constructible_trait> \ : public constructor> { \ using super = constructor>; \ \ 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::Available, move_constructor(move_constructor&& that) noexcept( lib::all::value...>::value) : move_constructor(valueless_t{}) { this->generic_construct(*this, lib::move(that)); }); MPARK_VARIANT_MOVE_CONSTRUCTOR(Trait::Unavailable, move_constructor(move_constructor&&) = delete;); #undef MPARK_VARIANT_MOVE_CONSTRUCTOR template class copy_constructor; #define MPARK_VARIANT_COPY_CONSTRUCTOR(copy_constructible_trait, definition) \ template \ class copy_constructor, copy_constructible_trait> \ : public move_constructor> { \ using super = move_constructor>; \ \ 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::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;); #undef MPARK_VARIANT_COPY_CONSTRUCTOR template class assignment : public copy_constructor { using super = copy_constructor; public: MPARK_INHERITING_CTOR(assignment, super) using super::operator=; template inline /* auto & */ auto emplace(Args&&... args) -> decltype(this->construct_alt( access::base::get_alt(*this), lib::forward(args)...)) { this->destroy(); auto& result = this->construct_alt( access::base::get_alt(*this), lib::forward(args)...); this->index_ = I; return result; } protected: #ifndef MPARK_GENERIC_LAMBDAS template struct assigner { template inline void operator()(ThisAlt& this_alt, ThatAlt&& that_alt) const { self->assign_alt(this_alt, lib::forward(that_alt).value); } assignment* self; }; #endif template inline void assign_alt(alt& a, Arg&& arg) { if (this->index() == I) { #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable : 4244) #endif a.value = lib::forward(arg); #ifdef _MSC_VER #pragma warning(pop) #endif } else { struct { void operator()(std::true_type) const { this_->emplace(lib::forward(arg_)); } void operator()(std::false_type) const { this_->emplace(T(lib::forward(arg_))); } assignment* this_; Arg&& arg_; } impl{this, lib::forward(arg)}; impl( lib::bool_constant < std::is_nothrow_constructible::value || !std::is_nothrow_move_constructible::value > {}); } } template inline void generic_assign(That&& that) { if (this->valueless_by_exception() && that.valueless_by_exception()) { // do nothing. } else if (that.valueless_by_exception()) { this->destroy(); } else { 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(that_alt).value); } #else assigner { this } #endif , *this, lib::forward(that)); } } }; template class move_assignment; #define MPARK_VARIANT_MOVE_ASSIGNMENT(move_assignable_trait, definition) \ template \ class move_assignment, move_assignable_trait> \ : public assignment> { \ using super = assignment>; \ \ 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::Available, move_assignment& operator=(move_assignment&& that) noexcept( lib::all< (std::is_nothrow_move_constructible::value && std::is_nothrow_move_assignable::value)...>::value) { this->generic_assign(lib::move(that)); return *this; }); MPARK_VARIANT_MOVE_ASSIGNMENT( Trait::Unavailable, move_assignment& operator=(move_assignment&&) = delete;); #undef MPARK_VARIANT_MOVE_ASSIGNMENT template class copy_assignment; #define MPARK_VARIANT_COPY_ASSIGNMENT(copy_assignable_trait, definition) \ template \ class copy_assignment, copy_assignable_trait> \ : public move_assignment> { \ using super = move_assignment>; \ \ 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::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;); #undef MPARK_VARIANT_COPY_ASSIGNMENT template class impl : public copy_assignment> { using super = copy_assignment>; public: MPARK_INHERITING_CTOR(impl, super) impl& operator=(const impl& other) = default; template inline void assign(Arg&& arg) { this->assign_alt(access::base::get_alt(*this), lib::forward(arg)); } inline void swap(impl& that) { if (this->valueless_by_exception() && that.valueless_by_exception()) { // do nothing. } else if (this->index() == that.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); } #else swapper {} #endif , *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)); #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 this->generic_construct(*rhs, lib::move(*lhs)); #endif this->generic_construct(*lhs, lib::move(tmp)); } } private: #ifndef MPARK_GENERIC_LAMBDAS struct swapper { template 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{ {std::is_nothrow_move_constructible::value...}}[this->index()]; } }; #undef MPARK_INHERITING_CTOR template struct overload_leaf { using F = lib::size_constant (*)(T); operator F() const { return nullptr; } }; template struct overload_impl { private: template struct impl; template struct impl> : overload_leaf... {}; public: using type = impl>; }; template using overload = typename overload_impl::type; template using best_match = lib::invoke_result_t, T&&>; template struct is_in_place_index : std::false_type {}; template struct is_in_place_index> : std::true_type {}; template struct is_in_place_type : std::false_type {}; template struct is_in_place_type> : std::true_type {}; } // namespace detail_ template class variant { static_assert( 0 < sizeof...(Ts), "variant must consist of at least one alternative."); static_assert( lib::all::value...>::value, "variant can not have an array type as an alternative."); static_assert( lib::all::value...>::value, "variant can not have a reference type as an alternative."); static_assert( lib::all::value...>::value, "variant can not have a void type as an alternative."); public: template < typename Front = lib::type_pack_element_t<0, Ts...>, lib::enable_if_t::value, int> = 0> inline constexpr variant() noexcept( std::is_nothrow_default_constructible::value) : impl_(in_place_index_t<0>{}) {} variant(const variant&) = default; variant(variant&&) = default; // NOTE [gcc 7.3.1 bug workaround] // // The original line `typename T = lib::type_pack_element_t` // throws the following compiler error on gcc 7.3.1: // ``` // ../c10/util/variant.h:2250:9: internal compiler error: // unexpected expression ‘I’ of kind template_parm_index // typename T = lib::type_pack_element_t, // ^~~~~~~~ // ``` // As a workaround, `I` is changed to `detail_::best_match::value`, which is the default value for `I` in this template. Note // that this workaround effectively disallows setting `I` to any other // non-default value, and we add a `static_assert` in the function body to // check for this. // // See the following issues for more context: // - https://github.com/mpark/variant/issues/43 // - https://github.com/eggs-cpp/variant/issues/31 template < typename Arg, typename Decayed = lib::decay_t, lib::enable_if_t::value, int> = 0, lib::enable_if_t::value, int> = 0, lib::enable_if_t::value, int> = 0, std::size_t I = detail_::best_match::value, typename T = lib:: type_pack_element_t::value, Ts...>, lib::enable_if_t::value, int> = 0> inline constexpr variant(Arg&& arg) noexcept( std::is_nothrow_constructible::value) : impl_(in_place_index_t{}, lib::forward(arg)) { static_assert( I == detail_::best_match::value, "Setting template parameter `I` to a custom non-default value is not supported. " "Please file a feature request if you see this."); } template < std::size_t I, typename... Args, typename T = lib::type_pack_element_t, lib::enable_if_t::value, int> = 0> inline explicit constexpr variant( in_place_index_t, Args&&... args) noexcept(std::is_nothrow_constructible::value) : impl_(in_place_index_t{}, lib::forward(args)...) {} template < std::size_t I, typename Up, typename... Args, typename T = lib::type_pack_element_t, lib::enable_if_t< std::is_constructible&, Args...>::value, int> = 0> inline explicit constexpr variant( in_place_index_t, std::initializer_list il, Args&&... args) noexcept(std:: is_nothrow_constructible< T, std::initializer_list&, Args...>::value) : impl_(in_place_index_t{}, il, lib::forward(args)...) {} template < typename T, typename... Args, std::size_t I = detail_::find_index_sfinae::value, lib::enable_if_t::value, int> = 0> inline explicit constexpr variant( in_place_type_t, Args&&... args) noexcept(std::is_nothrow_constructible::value) : impl_(in_place_index_t{}, lib::forward(args)...) {} template < typename T, typename Up, typename... Args, std::size_t I = detail_::find_index_sfinae::value, lib::enable_if_t< std::is_constructible&, Args...>::value, int> = 0> inline explicit constexpr variant( in_place_type_t, std::initializer_list il, Args&&... args) noexcept(std:: is_nothrow_constructible< T, std::initializer_list&, Args...>::value) : impl_(in_place_index_t{}, il, lib::forward(args)...) {} ~variant() = default; variant& operator=(const variant&) = default; variant& operator=(variant&&) = default; // NOTE: See NOTE [gcc 7.3.1 bug workaround] for the changes made to this // function. template < typename Arg, lib::enable_if_t, variant>::value, int> = 0, std::size_t I = detail_::best_match::value, typename T = lib:: type_pack_element_t::value, Ts...>, lib::enable_if_t< (std::is_assignable::value && std::is_constructible::value), int> = 0> inline variant& operator=(Arg&& arg) noexcept( (std::is_nothrow_assignable::value && std::is_nothrow_constructible::value)) { static_assert( I == detail_::best_match::value, "Setting template parameter `I` to a custom non-default value is not supported. " "Please file a feature request if you see this."); impl_.template assign(lib::forward(arg)); return *this; } template < std::size_t I, typename... Args, typename T = lib::type_pack_element_t, lib::enable_if_t::value, int> = 0> inline T& emplace(Args&&... args) { return impl_.template emplace(lib::forward(args)...); } template < std::size_t I, typename Up, typename... Args, typename T = lib::type_pack_element_t, lib::enable_if_t< std::is_constructible&, Args...>::value, int> = 0> inline T& emplace(std::initializer_list il, Args&&... args) { return impl_.template emplace(il, lib::forward(args)...); } template < typename T, typename... Args, std::size_t I = detail_::find_index_sfinae::value, lib::enable_if_t::value, int> = 0> inline T& emplace(Args&&... args) { return impl_.template emplace(lib::forward(args)...); } template < typename T, typename Up, typename... Args, std::size_t I = detail_::find_index_sfinae::value, lib::enable_if_t< std::is_constructible&, Args...>::value, int> = 0> inline T& emplace(std::initializer_list il, Args&&... args) { return impl_.template emplace(il, lib::forward(args)...); } inline constexpr bool valueless_by_exception() const noexcept { return impl_.valueless_by_exception(); } 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, Dummy>:: value && lib::dependent_type, Dummy>::value)...>:: value, int> = 0> inline void swap(variant& that) noexcept( lib::all< (std::is_nothrow_move_constructible::value && lib::is_nothrow_swappable::value)...>::value) { impl_.swap(that.impl_); } private: detail_::impl impl_; friend struct detail_::access::variant; friend struct detail_::visitation::variant; }; template inline constexpr bool holds_alternative(const variant& v) noexcept { return v.index() == I; } template inline constexpr bool holds_alternative(const variant& v) noexcept { return holds_alternative::value>(v); } namespace detail_ { template struct generic_get_impl { constexpr generic_get_impl(int) noexcept {} constexpr AUTO_REFREF operator()(V&& v) const AUTO_REFREF_RETURN(access::variant::get_alt(lib::forward(v)).value) }; template inline constexpr AUTO_REFREF generic_get(V&& v) AUTO_REFREF_RETURN(generic_get_impl( holds_alternative(v) ? 0 : (throw_bad_variant_access(), 0))(lib::forward(v))) } // namespace detail_ template inline constexpr variant_alternative_t>& get( variant& v) { return detail_::generic_get(v); } template inline constexpr variant_alternative_t>&& get( variant&& v) { return detail_::generic_get(lib::move(v)); } template inline constexpr const variant_alternative_t>& get( const variant& v) { return detail_::generic_get(v); } template inline constexpr const variant_alternative_t>&& get( const variant&& v) { return detail_::generic_get(lib::move(v)); } template inline constexpr T& get(variant& v) { return get::value>(v); } template inline constexpr T&& get(variant&& v) { return get::value>(lib::move(v)); } template inline constexpr const T& get(const variant& v) { return get::value>(v); } template inline constexpr const T&& get(const variant&& v) { return get::value>(lib::move(v)); } namespace detail_ { template inline constexpr /* auto * */ AUTO generic_get_if(V* v) noexcept AUTO_RETURN( v&& holds_alternative(*v) ? lib::addressof(access::variant::get_alt(*v).value) : nullptr) } // namespace detail_ template inline constexpr lib::add_pointer_t>> get_if(variant* v) noexcept { return detail_::generic_get_if(v); } template inline constexpr lib::add_pointer_t< const variant_alternative_t>> get_if(const variant* v) noexcept { return detail_::generic_get_if(v); } template inline constexpr lib::add_pointer_t get_if(variant* v) noexcept { return get_if::value>(v); } template inline constexpr lib::add_pointer_t get_if( const variant* v) noexcept { return get_if::value>(v); } namespace detail_ { template struct convert_to_bool { template inline constexpr bool operator()(Lhs&& lhs, Rhs&& rhs) const { static_assert( std::is_convertible, bool>::value, "relational operators must return a type" " implicitly convertible to bool"); return lib::invoke(RelOp{}, lib::forward(lhs), lib::forward(rhs)); } }; } // namespace detail_ template inline constexpr bool operator==( const variant& lhs, const variant& rhs) { using detail_::visitation::variant; using equal_to = detail_::convert_to_bool; #ifdef MPARK_CPP14_CONSTEXPR if (lhs.index() != rhs.index()) return false; 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)); #endif } template inline constexpr bool operator!=( const variant& lhs, const variant& rhs) { using detail_::visitation::variant; using not_equal_to = detail_::convert_to_bool; #ifdef MPARK_CPP14_CONSTEXPR if (lhs.index() != rhs.index()) return true; 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)); #endif } template inline constexpr bool operator<( const variant& lhs, const variant& rhs) { using detail_::visitation::variant; using less = detail_::convert_to_bool; #ifdef MPARK_CPP14_CONSTEXPR if (rhs.valueless_by_exception()) return false; if (lhs.valueless_by_exception()) return true; if (lhs.index() < rhs.index()) return true; 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))); #endif } template inline constexpr bool operator>( const variant& lhs, const variant& rhs) { using detail_::visitation::variant; using greater = detail_::convert_to_bool; #ifdef MPARK_CPP14_CONSTEXPR if (lhs.valueless_by_exception()) return false; if (rhs.valueless_by_exception()) return true; if (lhs.index() > rhs.index()) return true; 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))); #endif } template inline constexpr bool operator<=( const variant& lhs, const variant& rhs) { using detail_::visitation::variant; using less_equal = detail_::convert_to_bool; #ifdef MPARK_CPP14_CONSTEXPR if (lhs.valueless_by_exception()) return true; if (rhs.valueless_by_exception()) return false; if (lhs.index() < rhs.index()) return true; 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)))); #endif } template inline constexpr bool operator>=( const variant& lhs, const variant& rhs) { using detail_::visitation::variant; using greater_equal = detail_::convert_to_bool; #ifdef MPARK_CPP14_CONSTEXPR if (rhs.valueless_by_exception()) return true; if (lhs.valueless_by_exception()) return false; if (lhs.index() > rhs.index()) return true; 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)))); #endif } struct monostate {}; inline constexpr bool operator<(monostate, monostate) noexcept { return false; } inline constexpr bool operator>(monostate, monostate) noexcept { return false; } inline constexpr bool operator<=(monostate, monostate) noexcept { return true; } inline constexpr bool operator>=(monostate, monostate) noexcept { return true; } inline constexpr bool operator==(monostate, monostate) noexcept { return true; } inline constexpr bool operator!=(monostate, monostate) noexcept { return false; } #ifdef MPARK_CPP14_CONSTEXPR namespace detail_ { inline constexpr bool any(std::initializer_list bs) { for (bool b : bs) { if (b) { return true; } } return false; } } // namespace detail_ template inline constexpr decltype(auto) visit(Visitor&& visitor, Vs&&... vs) { return (!detail_::any({vs.valueless_by_exception()...}) ? (void)0 : throw_bad_variant_access()), detail_::visitation::variant::visit_value( lib::forward(visitor), lib::forward(vs)...); } #else namespace detail_ { template inline constexpr bool all_impl(const lib::array& bs, std::size_t idx) { return idx >= N || (bs[idx] && all_impl(bs, idx + 1)); } template inline constexpr bool all(const lib::array& bs) { return all_impl(bs, 0); } } // namespace detail_ template inline constexpr DECLTYPE_AUTO visit(Visitor&& visitor, Vs&&... vs) DECLTYPE_AUTO_RETURN( (detail_::all(lib::array{ {!vs.valueless_by_exception()...}}) ? (void)0 : throw_bad_variant_access()), detail_::visitation::variant::visit_value( lib::forward(visitor), lib::forward(vs)...)) #endif template inline auto swap(variant& lhs, variant& rhs) noexcept( noexcept(lhs.swap(rhs))) -> decltype(lhs.swap(rhs)) { lhs.swap(rhs); } namespace detail_ { template using enabled_type = T; namespace hash { template constexpr bool meets_requirements() noexcept { return std::is_copy_constructible::value && std::is_move_constructible::value && lib::is_invocable_r::value; } template constexpr bool is_enabled() noexcept { using H = std::hash; return meets_requirements() && std::is_default_constructible::value && std::is_copy_assignable::value && std::is_move_assignable::value; } } // namespace hash } // namespace detail_ #undef AUTO #undef AUTO_RETURN #undef AUTO_REFREF #undef AUTO_REFREF_RETURN #undef DECLTYPE_AUTO #undef DECLTYPE_AUTO_RETURN } // namespace c10 namespace std { template struct hash, c10::lib::enable_if_t>()...>::value>>> { using argument_type = c10::variant; using result_type = std::size_t; inline result_type operator()(const argument_type& v) const { using c10::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 = c10::lib::decay_t; using value_type = c10::lib::remove_const_t; return hash{}(alt.value); } #else hasher {} #endif , v); return hash_combine(result, hash{}(v.index())); } private: #ifndef MPARK_GENERIC_LAMBDAS struct hasher { template inline std::size_t operator()(const Alt& alt) const { using alt_type = c10::lib::decay_t; using value_type = c10::lib::remove_const_t; return hash{}(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); } }; template <> struct hash { using argument_type = c10::monostate; using result_type = std::size_t; inline result_type operator()(const argument_type&) const noexcept { return 66740831; // return a fundamentally attractive random value. } }; } // namespace std #endif // C10_UTIL_VARIANT_H_