Implemented C++17 <variant>.

[mpark]

• Removed unnecessary use of __size_constant.

[mpark]

TODO:

• Kill _LIBCPP_NOEXCEPT_SFINAE_RETURN
• Kill _LIBCPP_NOEXCEPT_INIT
• Specify the SFINAE / noexcept conditions at the variant level.
• Update unit tests.

[mpark]

This comment was removed by mpark.

[mpark]

• Killed _LIBCPP_NOEXCEPT_SFINAE_RETURN.
• Killed _LIBCPP_NOEXCEPT_INIT.
• Specified the SFINAE / noexcept conditions at the variant level.

[mpark]

This comment was removed by mpark.

[mpark]

include/variant

279

Added it back, since I removed it prematurely.

[mpark]

• Fixed <variant> comparison operators as per P0393.
• Updated variant synopsis.
• Removed allocator support from variant.
• Removed support for empty set of alternatives in a variant.
• Removed support for void as an alternative in a variant.
• Removed support for reference types in a variant.
• Removed __all_v.
• Moved bad_variant_access to unversioned namespace.
• Removed unnecessary uses of __identity.
• Removed unnecessary use of __size_constant.
• Addressed Eric's comments.
• Updated variant tests.
• Adopted to use the new in_place tags.
• variant_alt() should be = default.
• Fixed variant comparison operators test.
• Removed variant's uses_allocator test.

[mpark]

• Fixed <variant> comparison operators as per P0393.
• Updated variant synopsis.
• Removed allocator support from variant.
• Removed support for empty set of alternatives in a variant.
• Removed support for void as an alternative in a variant.
• Removed support for reference types in a variant.
• Removed __all_v.
• Moved bad_variant_access to unversioned namespace.
• Removed unnecessary uses of __identity.
• Removed unnecessary use of __size_constant.
• Addressed Eric's comments.
• Updated variant tests.
• Adopted to use the new in_place tags.
• variant_alt() should be = default.
• Fixed variant comparison operators test.
• Removed variant's uses_allocator test.
• Disallowed array types in variant.
• Added new tests.

[mpark]

• Removed __get_value function which is now unnecessary

[mpark]

test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp

55 ↗

(On Diff #78689)

This test is currently fails. However, TestTypes::NoCtors inherits from ::ArchetypeBases::TestBase<NoCtors> which defines the following constructors:

template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
explicit TestBase(std::initializer_list<int>& il, int = 0) noexcept
  : value(il.size()) {
    ++alive; ++constructed; ++value_constructed;
}
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
explicit TestBase(std::initializer_list<int>& il, int = 0) noexcept : value(il.size()) {
    ++alive; ++constructed; ++value_constructed;
}

These constructors are not = deleted in NoCtors. So the behavior we observe here is correct.

But I'm not sure which direction we should be solving this, since I don't fully understand the intended semantics of these test classes.

test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp

459–461 ↗

(On Diff #78689)

I don't think the non-member swap is SFINAE'd out based on the current wording.

537–539 ↗

(On Diff #78689)

I don't think the non-member swap is SFINAE'd out based on the current wording.

[mpark]

Removed Eric's tests.

[EricWF]

include/variant

274

Please lift this inside the template body, and add a static assert that the index is in range.

334

__variant_best_match_t if it gives you the type back directly please.

335

In order to avoid forming a function which takes an abstract class by value please change this to.

typename result_of_t<__variant_overload<_Types...>(_Tp&&)>::type;

551

Please use _UpperCamelCase for template parameters.

765

Names like __is_nothrow_move_constructible may be the compiler builtin used to implement is_nothrow_move_constructible. Try to avoid them.

802

__assign_alt needs to be public in order to use it in the lambda according to GCC.

852

Seems like an awkward way to make the type dependent. Maybe something like this?

bool _Dummy = true,
class = enable_if_t<
  is_default_constructible_v<
    typename __dependent_type<variant_alternative_t<0, variant>, _Dummy>::type
>>

864

The && is almost always unnecessary. Libc++ usually omits it and you should too.

867

_Arg&& __arg (ie add a space)

1015

Clang and GCC disagree on the type of this expression. Clang produces the reference qualified type but GCC does not. I think a better formulation is:

return ((void)__holds_alternative<_Ip>(__v) ? (void)0 : throw bad_variant_access{}), __variant_access::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v)).__value;

[mpark]

Addressed a few of the comments.

include/variant

274

Which of the following would you prefer?
I think you're looking for the latter?

template <size_t _Ip, class... _Types>
struct _LIBCPP_TYPE_VIS_ONLY variant_alternative<_Ip, variant<_Types...>>
    : __identity<__type_pack_element<_Ip, _Types...>> {
  static_assert(_Ip < sizeof...(_Types));
};

template <size_t _Ip, class... _Types>
struct _LIBCPP_TYPE_VIS_ONLY variant_alternative<_Ip, variant<_Types...>> {
  static_assert(_Ip < sizeof...(_Types));
  using type = __type_pack_element<_Ip, _Types...>;
};

[mpark]

Removed test/std/utilities/lit.local.cfg.

[mpark]

Removed the use of &&.

[EricWF]

I think the only thing left to mention are visibility macros.

_LIBCPP_INLINE_VISIBILITY should be applied to most publicly visible functions, especially if they are only a line or two.

Also inline should be added to any non-inline function template. (Note: inline definitions and constexpr functions are both implicitly inline).

include/variant

544

This should be constrained to not pick up __variant_alt

779

Why not forward?

[EricWF]

include/variant

615

I think we get a better layout putting __index second when one of the types in the variant requires more alignment than size_t. In the current layout that will cause 8 bytes of padding between __index and __data. What do you think?

[mpark]

include/variant

779

haha, had done this myself just in time.

[mpark]

Address a few more of Eric's comments.

[mpark]

Use an if statement rather than ternary operator.

[mpark]

Help out GCC.

[mpark]

include/variant

802

Updated to this->__assign_alt(...);

[mpark]

Fix variant swap.

[mpark]

Use member swap to define non-member swap.

[mpark]

Made __variant_alt safer for construction.

[mpark]

include/variant

544

Good catch! I've added an in_place_t tag parameter to avoid this rather than adding a bunch of SFINAE conditions.

[mpark]

include/variant

274

Used the latter.

[mpark]

Pulled out __first_type.

[mpark]

TODO:

• Think about layout
• Implement constexpr copy/move ctors for variant that holds all trivially_copyable types.
• Don't forget about https://reviews.llvm.org/D23263#603887
• Investigate https://reviews.llvm.org/D26899#602539

[ruoka]

This test fails to compile. Shouldn’t the visit work similarly to invoke?

#include <variant>
#include <functional>
#include <string>

using std::variant;
using std::visit;

struct visitor
{

bool operator () (bool, bool)
{
  return true;
}
bool operator () (const std::string&, const std::string&)
{
  return true;
}

};

int main()
{

visitor vis;
variant<bool,std::string> var1, var2;
bool b1, b2;
std::string str1, str2;

b1 = b2 = true;
std::invoke(vis, b1, b2);

var1 = var2 = true;
visit(vis, var1, var2);

str1 = str2 = "test";
std::invoke(vis, str1, str2);

var1 = var2 = "test";
visit(vis, var1, var2);

}

[mpark]

In D23263#604565, @ruoka wrote:

This test fails to compile. Shouldn’t the visit work similarly to invoke?

#include <variant>
#include <functional>
#include <string>

using std::variant;
using std::visit;

struct visitor
{
  bool operator () (bool, bool)
  {
    return true;
  }
  bool operator () (const std::string&, const std::string&)
  {
    return true;
  }
};

int main()
{
  visitor vis;
  variant<bool,std::string> var1, var2;
  bool b1, b2;
  std::string str1, str2;

  b1 = b2 = true;
  std::invoke(vis, b1, b2);

  var1 = var2 = true;
  visit(vis, var1, var2);

  str1 = str2 = "test";
  std::invoke(vis, str1, str2);

  var1 = var2 = "test";
  visit(vis, var1, var2);
}

No, I don't believe so. IIUC, visit requires exhaustive matching from a visitor.
In your example, visitor does not have handlers for (bool, const std::string&) and (const std::string&, bool).

[ruoka]

In D23263#606107, @mpark wrote:

In D23263#604565, @ruoka wrote:

This test fails to compile. Shouldn’t the visit work similarly to invoke?

#include <variant>
#include <functional>
#include <string>

using std::variant;
using std::visit;

struct visitor
{
  bool operator () (bool, bool)
  {
    return true;
  }
  bool operator () (const std::string&, const std::string&)
  {
    return true;
  }
};

int main()
{
  visitor vis;
  variant<bool,std::string> var1, var2;
  bool b1, b2;
  std::string str1, str2;

  b1 = b2 = true;
  std::invoke(vis, b1, b2);

  var1 = var2 = true;
  visit(vis, var1, var2);

  str1 = str2 = "test";
  std::invoke(vis, str1, str2);

  var1 = var2 = "test";
  visit(vis, var1, var2);
}

No, I don't believe so. IIUC, visit requires exhaustive matching from a visitor.
In your example, visitor does not have handlers for (bool, const std::string&) and (const std::string&, bool).

Boost had a similar example. There visit seemed to work similarly to the std::invoke. But maybe that is not required from the std::visit in the standard.

http://www.boost.org/doc/libs/1_61_0/doc/html/variant/reference.html#variant.concepts.static-visitor.examples

[mpark]

• Added visibility macro _LIBCPP_INLINE_VISIBILITY + inline.
• Preserved triviality of special member functions.
• Added libcxx tests for the trivial special member functions feature.
• Reorganized the structure of the file.
• Consistently used const T rather than T const in tests.

[mpark]

In D23263#607998, @ruoka wrote:

In D23263#606107, @mpark wrote:

In D23263#604565, @ruoka wrote:

This test fails to compile. Shouldn’t the visit work similarly to invoke?

#include <variant>
#include <functional>
#include <string>

using std::variant;
using std::visit;

struct visitor
{
  bool operator () (bool, bool)
  {
    return true;
  }
  bool operator () (const std::string&, const std::string&)
  {
    return true;
  }
};

int main()
{
  visitor vis;
  variant<bool,std::string> var1, var2;
  bool b1, b2;
  std::string str1, str2;

  b1 = b2 = true;
  std::invoke(vis, b1, b2);

  var1 = var2 = true;
  visit(vis, var1, var2);

  str1 = str2 = "test";
  std::invoke(vis, str1, str2);

  var1 = var2 = "test";
  visit(vis, var1, var2);
}

No, I don't believe so. IIUC, visit requires exhaustive matching from a visitor.
In your example, visitor does not have handlers for (bool, const std::string&) and (const std::string&, bool).

Boost had a similar example. There visit seemed to work similarly to the std::invoke. But maybe that is not required from the std::visit in the standard.

http://www.boost.org/doc/libs/1_61_0/doc/html/variant/reference.html#variant.concepts.static-visitor.examples

All of the examples on that page perform visitation with a single variant, which satisfies the exhaustive match requirement.
For your multi-visitation example to be exhaustive, you need to handle the bool, const std::string&, and const std::string&, bool
cases. You can achieve that either by adding operator()(bool, const std::string&) and operator()(const std::string&, bool), or
by adding a "default handler", i.e. template <typename T, typename U> operator()(const T&, const U&);.

[mpark]

Rebased

[ruoka]

In D23263#609001, @mpark wrote:

In D23263#607998, @ruoka wrote:

In D23263#606107, @mpark wrote:

In D23263#604565, @ruoka wrote:

This test fails to compile. Shouldn’t the visit work similarly to invoke?

#include <variant>
#include <functional>
#include <string>

using std::variant;
using std::visit;

struct visitor
{
  bool operator () (bool, bool)
  {
    return true;
  }
  bool operator () (const std::string&, const std::string&)
  {
    return true;
  }
};

int main()
{
  visitor vis;
  variant<bool,std::string> var1, var2;
  bool b1, b2;
  std::string str1, str2;

  b1 = b2 = true;
  std::invoke(vis, b1, b2);

  var1 = var2 = true;
  visit(vis, var1, var2);

  str1 = str2 = "test";
  std::invoke(vis, str1, str2);

  var1 = var2 = "test";
  visit(vis, var1, var2);
}

No, I don't believe so. IIUC, visit requires exhaustive matching from a visitor.
In your example, visitor does not have handlers for (bool, const std::string&) and (const std::string&, bool).

Boost had a similar example. There visit seemed to work similarly to the std::invoke. But maybe that is not required from the std::visit in the standard.

http://www.boost.org/doc/libs/1_61_0/doc/html/variant/reference.html#variant.concepts.static-visitor.examples

All of the examples on that page perform visitation with a single variant, which satisfies the exhaustive match requirement.
For your multi-visitation example to be exhaustive, you need to handle the bool, const std::string&, and const std::string&, bool
cases. You can achieve that either by adding operator()(bool, const std::string&) and operator()(const std::string&, bool), or
by adding a "default handler", i.e. template <typename T, typename U> operator()(const T&, const U&);.

I see your point now. I guess this is what the "for all combinations of alternative types of all variants" means. I didn't realise it before. Thanks!

[mpark]

Fixed formatting.

[mpark]

• Used unsigned int rather than size_t for index
• Placed index second so that we have trailing padding rather than in the middle.
• Used __sfinae_ctor_base and` __sfinae_assign_base` for special member SFINAE.

[EricWF]

LGTM.

I've attached a couple of inline comments that I generated a couple of days ago.

include/variant

285

This is beautiful metaprogramming. C++14 constexpr FTW.

814

I really dislike passing uninitialized memory as __variant_alt<_Ip, _Tp>&. I'm pretty sure it's UB. Optimally we should pass this in as a void* but IDK how to easily change this.

You don't need to change this. Just leaving a note.

816

Needs (void*) cast to avoid ADL.

1216

I think we should choose a less common value to hash valueless variants to.

1232

I think we want to return a more interesting hash value than that. 0 seems likely to cause hash collisions. Maybe some large prime?

[EricWF]

Woot! Thanks for all your hard work! I'm sure there will be more <variant> changes and cleanup to come, but this is ready to land in-tree.

[EricWF]

r288547.

include/variant

+// -*- C++ -*-
+//===------------------------------ variant -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_VARIANT
+#define _LIBCPP_VARIANT
+
+/*
+   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<U>, Args&&...);
+
+    template <size_t I, class... Args>
+    constexpr explicit variant(in_place_index_t<I>, Args&&...);
+
+    template <size_t I, class U, class... Args>
+    constexpr explicit variant(
+        in_place_index_t<I>, initializer_list<U>, 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>
+    void emplace(Args&&...);
+
+    template <class T, class U, class... Args>
+    void emplace(initializer_list<U>, Args&&...);
+
+    template <size_t I, class... Args>
+    void emplace(Args&&...);
+
+    template <size_t I, class U, class...  Args>
+    void emplace(initializer_list<U>, 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 <__config>
+#include <__tuple>
+#include <array>
+#include <exception>
+#include <functional>
+#include <initializer_list>
+#include <new>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+namespace std {  // explicitly not using versioning namespace
+
+class _LIBCPP_EXCEPTION_ABI bad_variant_access : public exception {
+public:
+  virtual const char* what() const noexcept;
+};
+
+}  // namespace std
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 14
+
+template <class... _Types>
+class _LIBCPP_TYPE_VIS variant;
+
+template <class _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY variant_size;
+
+template <class _Tp>
+constexpr size_t variant_size_v = variant_size<_Tp>::value;
+
+template <class _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY variant_size<const _Tp>
+    : variant_size<_Tp> {};
+
+template <class _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY variant_size<volatile _Tp>
+    : variant_size<_Tp> {};
+
+template <class _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY variant_size<const volatile _Tp>
+    : variant_size<_Tp> {};
+
+template <class... _Types>
+struct _LIBCPP_TYPE_VIS_ONLY variant_size<variant<_Types...>>
+    : integral_constant<size_t, sizeof...(_Types)> {};
+
+template <size_t _Ip, class _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY variant_alternative;
+
+template <size_t _Ip, class _Tp>
+using variant_alternative_t = typename variant_alternative<_Ip, _Tp>::type;
+
+template <size_t _Ip, class _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY variant_alternative<_Ip, const _Tp>
+    : add_const<variant_alternative_t<_Ip, _Tp>> {};
+
+template <size_t _Ip, class _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY variant_alternative<_Ip, volatile _Tp>
+    : add_volatile<variant_alternative_t<_Ip, _Tp>> {};
+
+template <size_t _Ip, class _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY variant_alternative<_Ip, const volatile _Tp>
+    : add_cv<variant_alternative_t<_Ip, _Tp>> {};
+
+template <size_t _Ip, class... _Types>
+struct _LIBCPP_TYPE_VIS_ONLY variant_alternative<_Ip, variant<_Types...>> {
+  static_assert(_Ip < sizeof...(_Types));
+  using type = __type_pack_element<_Ip, _Types...>;
+};
+
+constexpr size_t variant_npos = static_cast<size_t>(-1);
+
+struct __variant_valueless_t {};
+
+namespace __find_detail {
+
+  template <class _Tp, class... _Types>
+  constexpr size_t __find_index() {
+    constexpr bool __matches[] = {is_same_v<_Tp, _Types>...};
+    size_t __result = __not_found;
+    for (size_t __i = 0; __i < sizeof...(_Types); ++__i) {
+      if (__matches[__i]) {
+        if (__result != __not_found) {
+          return __ambiguous;
+        }
+        __result = __i;
+      }
+    }
+    return __result;
+  }
+
+  template <size_t _Index>
+  struct __find_unambiguous_index_sfinae_impl
+      : integral_constant<size_t, _Index> {};
+
+  template <>
+  struct __find_unambiguous_index_sfinae_impl<__not_found> {};
+
+  template <>
+  struct __find_unambiguous_index_sfinae_impl<__ambiguous> {};
+
+  template <class _Tp, class... _Types>
+  struct __find_unambiguous_index_sfinae
+      : __find_unambiguous_index_sfinae_impl<__find_index<_Tp, _Types...>()> {};
+
+}  // namespace __find_detail
+
+using __find_detail::__find_unambiguous_index_sfinae;
+
+template <class... _Types>
+class __variant_overload;
+
+template <>
+class __variant_overload<> {
+public:
+  void operator()() const;
+};
+
+template <class _Tp, class... _Types>
+class __variant_overload<_Tp, _Types...>
+    : public __variant_overload<_Types...> {
+public:
+  using __variant_overload<_Types...>::operator();
+  __identity<_Tp> operator()(_Tp) const;
+};
+
+template <class _Tp, class... _Types>
+using __variant_best_match_t =
+    typename result_of_t<__variant_overload<_Types...>(_Tp&&)>::type;
+
+struct __variant_union_access {
+  template <class _Vp>
+  static constexpr auto&& __get_alt(_Vp&& __v, in_place_index_t<0>) {
+    return _VSTD::forward<_Vp>(__v).__head;
+  }
+
+  template <class _Vp, size_t _Ip>
+  static constexpr auto&& __get_alt(_Vp&& __v, in_place_index_t<_Ip>) {
+    return __get_alt(_VSTD::forward<_Vp>(__v).__tail, in_place_index<_Ip - 1>);
+  }
+};
+
+struct __variant_impl_access {
+  template <size_t _Ip, class _Vp>
+  static constexpr auto&& __get_alt(_Vp&& __v) {
+    return __variant_union_access::__get_alt(_VSTD::forward<_Vp>(__v).__data,
+                                             in_place_index<_Ip>);
+  }
+};
+
+struct __variant_access {
+  template <size_t _Ip, class _Vp>
+  static constexpr auto&& __get_alt(_Vp&& __v) {
+    return __variant_impl_access::__get_alt<_Ip>(
+        _VSTD::forward<_Vp>(__v).__impl);
+  }
+};
+
+namespace __variant_impl_visitation_detail {
+
+  template <class _Tp>
+  constexpr const _Tp& __at_impl(const _Tp& __elem, const size_t*) {
+    return __elem;
+  }
+
+  template <class _Tp, size_t _Np>
+  constexpr auto&& __at_impl(const array<_Tp, _Np>& __elems,
+                             const size_t* __index) {
+    return __at_impl(__elems[*__index], __index + 1);
+  }
+
+  template <class _Tp, size_t _Np, size_t _Ip>
+  constexpr auto&& __at(const array<_Tp, _Np>& __elems,
+                        const size_t (&__indices)[_Ip]) {
+    return __at_impl(__elems, begin(__indices));
+  }
+
+  template <class _Tp, class... _Types>
+  struct __all_same : __all<is_same_v<_Tp, _Types>...> {};
+
+  template <class... _Types>
+  constexpr void __variant_visit_has_same_return_types(true_type) {}
+
+  template <class... _Types>
+  constexpr void __variant_visit_has_same_return_types(false_type) = delete;
+
+  template <class... _Args>
+  constexpr array<common_type_t<decay_t<_Args>...>, sizeof...(_Args)>
+  __make_array(_Args&&... __args) {
+    using __all_same = __all_same<decay_t<_Args>...>;
+    __variant_visit_has_same_return_types<decay_t<_Args>...>(__all_same{});
+    return {{_VSTD::forward<_Args>(__args)...}};
+  }
+
+  template <class _Fp, class... _Vs, size_t... _Is>
+  constexpr auto __make_dispatch(index_sequence<_Is...>) {
+    struct __dispatcher {
+      static constexpr decltype(auto) __dispatch(_Fp __f, _Vs... __vs) {
+        return __invoke_constexpr(
+            static_cast<_Fp>(__f),
+            __variant_impl_access::__get_alt<_Is>(static_cast<_Vs>(__vs))...);
+      }
+    };
+    return _VSTD::addressof(__dispatcher::__dispatch);
+  }
+
+  template <size_t _Ip, class _Fp, class... _Vs>
+  constexpr auto __make_fdiagonal_impl() {
+    return __make_dispatch<_Fp, _Vs...>(
+        index_sequence<(__identity<_Vs>{}, _Ip)...>{});
+  }
+
+  template <class _Fp, class... _Vs, size_t... _Is>
+  constexpr auto __make_fdiagonal_impl(index_sequence<_Is...>) {
+    return __make_array(__make_fdiagonal_impl<_Is, _Fp, _Vs...>()...);
+  }
+
+  template <class _Fp, class _Vp, class... _Vs>
+  constexpr auto __make_fdiagonal() {
+    constexpr size_t _Np = decay_t<_Vp>::__size();
+    static_assert(__all<(_Np == decay_t<_Vs>::__size())...>::value);
+    return __make_fdiagonal_impl<_Fp, _Vp, _Vs...>(make_index_sequence<_Np>{});
+  }
+
+  template <class _Fp, class... _Vs, size_t... _Is>
+  constexpr auto __make_fmatrix_impl(index_sequence<_Is...> __is) {
+    return __make_dispatch<_Fp, _Vs...>(__is);
+  }
+
+  template <class _Fp, class... _Vs, size_t... _Is, size_t... _Js, class... _Ls>
+  constexpr auto __make_fmatrix_impl(index_sequence<_Is...>,
+                                     index_sequence<_Js...>,
+                                     _Ls... __ls) {
+    return __make_array(__make_fmatrix_impl<_Fp, _Vs...>(
+        index_sequence<_Is..., _Js>{}, __ls...)...);
+  }
+
+  template <class _Fp, class... _Vs>
+  constexpr auto __make_fmatrix() {
+    return __make_fmatrix_impl<_Fp, _Vs...>(
+        index_sequence<>{}, make_index_sequence<decay_t<_Vs>::__size()>{}...);
+  }
+
+}  // namespace __variant_impl_visitation_detail
+
+struct __variant_impl_visitation {
+  template <class _Visitor, class... _Vs>
+  static constexpr decltype(auto) __visit_alt_at(size_t __index,
+                                                 _Visitor&& __visitor,
+                                                 _Vs&&... __vs) {
+    using namespace __variant_impl_visitation_detail;
+    constexpr auto __fdiagonal = __make_fdiagonal<
+        _Visitor&&,
+        decltype(_VSTD::forward<_Vs>(__vs).__as_variant_base())...>();
+    return __fdiagonal[__index](
+        _VSTD::forward<_Visitor>(__visitor),
+        _VSTD::forward<_Vs>(__vs).__as_variant_base()...);
+  }
+
+  template <class _Visitor, class... _Vs>
+  static constexpr decltype(auto) __visit_alt(_Visitor&& __visitor,
+                                              _Vs&&... __vs) {
+    using namespace __variant_impl_visitation_detail;
+    constexpr auto __fmatrix = __make_fmatrix<
+        _Visitor&&,
+        decltype(_VSTD::forward<_Vs>(__vs).__as_variant_base())...>();
+    const size_t __indices[] = {__vs.index()...};
+    return __at(__fmatrix, __indices)(
+        _VSTD::forward<_Visitor>(__visitor),
+        _VSTD::forward<_Vs>(__vs).__as_variant_base()...);
+  }
+};
+
+struct __variant_visitation {
+  template <class _Visitor, class... _Vs>
+  static constexpr decltype(auto) __visit_alt_at(size_t __index,
+                                                 _Visitor&& __visitor,
+                                                 _Vs&&... __vs) {
+    return __variant_impl_visitation::__visit_alt_at(
+        __index,
+        _VSTD::forward<_Visitor>(__visitor),
+        _VSTD::forward<_Vs>(__vs).__impl...);
+  }
+
+  template <class _Visitor, class... _Vs>
+  static constexpr decltype(auto) __visit_alt(_Visitor&& __visitor,
+                                              _Vs&&... __vs) {
+    return __variant_impl_visitation::__visit_alt(
+        _VSTD::forward<_Visitor>(__visitor),
+        _VSTD::forward<_Vs>(__vs).__impl...);
+  }
+
+  template <class _Visitor>
+  struct __value_visitor {
+    template <class... _Alts>
+    constexpr decltype(auto) operator()(_Alts&&... __alts) const {
+      return __invoke_constexpr(_VSTD::forward<_Visitor>(__visitor),
+                                _VSTD::forward<_Alts>(__alts).__value...);
+    }
+
+    _Visitor&& __visitor;
+  };
+
+  template <class _Visitor>
+  static constexpr auto __make_value_visitor(_Visitor&& __visitor) {
+    return __value_visitor<_Visitor>{_VSTD::forward<_Visitor>(__visitor)};
+  }
+
+  template <class _Visitor, class... _Vs>
+  static constexpr decltype(auto) __visit_value_at(size_t __index,
+                                                   _Visitor&& __visitor,
+                                                   _Vs&&... __vs) {
+    return __visit_alt_at(
+        __index,
+        __make_value_visitor(_VSTD::forward<_Visitor>(__visitor)),
+        _VSTD::forward<_Vs>(__vs)...);
+  }
+
+  template <class _Visitor, class... _Vs>
+  static constexpr decltype(auto) __visit_value(_Visitor&& __visitor,
+                                                _Vs&&... __vs) {
+    return __visit_alt(
+        __make_value_visitor(_VSTD::forward<_Visitor>(__visitor)),
+        _VSTD::forward<_Vs>(__vs)...);
+  }
+};
+
+template <size_t _Index, class _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY __variant_alt {
+  using __value_type = _Tp;
+
+  __variant_alt() = default;
+  __variant_alt(const __variant_alt&) = delete;
+  __variant_alt(__variant_alt&&) = delete;
+  __variant_alt& operator=(const __variant_alt&) = delete;
+  __variant_alt& operator=(__variant_alt&&) = delete;
+
+  template <class... _Args>
+  explicit constexpr __variant_alt(_Args&&... __args)
+      : __value(_VSTD::forward<_Args>(__args)...) {}
+
+  __value_type __value;
+};
+
+template <bool _TriviallyDestructible, size_t _Index, class... _Types>
+union __variant_union;
+
+template <bool _TriviallyDestructible, size_t _Index>
+union __variant_union<_TriviallyDestructible, _Index> {};
+
+#define _LIBCPP_VARIANT_UNION(__trivially_destructible, dtor)                  \
+  template <size_t _Index, class _Tp, class... _Types>                         \
+  union __variant_union<__trivially_destructible, _Index, _Tp, _Types...> {    \
+  public:                                                                      \
+    explicit constexpr __variant_union(__variant_valueless_t) noexcept         \
+        : __dummy{} {}                                                         \
+                                                                               \
+    template <class... _Args>                                                  \
+    explicit constexpr __variant_union(in_place_index_t<0>,                    \
+                                       _Args&&... __args)                      \
+        : __head(_VSTD::forward<_Args>(__args)...) {}                          \
+                                                                               \
+    template <size_t _Ip, class... _Args>                                      \
+    explicit constexpr __variant_union(in_place_index_t<_Ip>,                  \
+                                       _Args&&... __args)                      \
+        : __tail(in_place_index<_Ip - 1>, _VSTD::forward<_Args>(__args)...) {} \
+                                                                               \
+    dtor                                                                       \
+                                                                               \
+  private:                                                                     \
+    char __dummy;                                                              \
+    __variant_alt<_Index, _Tp> __head;                                         \
+    __variant_union<__trivially_destructible, _Index + 1, _Types...> __tail;   \
+                                                                               \
+    friend struct __variant_union_access;                                      \
+  }
+
+_LIBCPP_VARIANT_UNION(true , ~__variant_union() = default;);
+_LIBCPP_VARIANT_UNION(false, ~__variant_union() {});
+
+#undef _LIBCPP_VARIANT_UNION
+
+template <bool _TriviallyDestructible, class... _Types>
+class __variant_base {
+public:
+  static constexpr size_t __size() { return sizeof...(_Types); }
+
+  explicit constexpr __variant_base(__variant_valueless_t tag) noexcept
+      : __index(variant_npos), __data(tag) {}
+
+  template <size_t _Ip, class... _Args>
+  explicit constexpr __variant_base(in_place_index_t<_Ip>, _Args&&... __args)
+      : __index(_Ip),
+        __data(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...) {}
+
+  constexpr bool valueless_by_exception() const noexcept {
+    return index() == variant_npos;
+  }
+
+  constexpr size_t index() const noexcept { return __index; }
+
+protected:
+  constexpr auto&& __as_variant_base() & { return *this; }
+  constexpr auto&& __as_variant_base() && { return _VSTD::move(*this); }
+  constexpr auto&& __as_variant_base() const & { return *this; }
+  constexpr auto&& __as_variant_base() const && { return _VSTD::move(*this); }
+
+  size_t __index;
+  __variant_union<_TriviallyDestructible, 0, _Types...> __data;
+
+  friend struct __variant_impl_access;
+  friend struct __variant_impl_visitation;
+};
+
+template <bool _TriviallyDestructible, class... _Types>
+class __variant_dtor;
+
+template <class... _Types>
+class __variant_dtor</* __trivially_destructible */ true, _Types...>
+    : public __variant_base<true, _Types...> {
+  using __base_type = __variant_base<true, _Types...>;
+
+public:
+  using __base_type::__base_type;
+  ~__variant_dtor() = default;
+
+protected:
+  void __destroy() noexcept { this->__index = variant_npos; }
+};
+
+template <class... _Types>
+class __variant_dtor</* __trivially_destructible */ false, _Types...>
+    : public __variant_base<false, _Types...> {
+  using __base_type = __variant_base<false, _Types...>;
+
+public:
+  using __base_type::__base_type;
+  ~__variant_dtor() { __destroy(); }
+
+protected:
+  void __destroy() noexcept {
+    if (!this->valueless_by_exception()) {
+      __variant_impl_visitation::__visit_alt(
+          [](auto& __alt) noexcept {
+            using __alt_type = decay_t<decltype(__alt)>;
+            __alt.~__alt_type();
+          },
+          *this);
+    }
+    this->__index = variant_npos;
+  }
+};
+
+template <class... _Types>
+struct __variant_impl
+    : public __variant_dtor<
+          __all<is_trivially_destructible_v<_Types>...>::value, _Types...> {
+  using __base_type =
+      __variant_dtor<__all<is_trivially_destructible_v<_Types>...>::value,
+                     _Types...>;
+
+public:
+  using __base_type::__base_type;
+
+  __variant_impl(
+      const conditional_t<__all<is_copy_constructible_v<_Types>...>::value,
+                          __variant_impl,
+                          __nat>& __that)
+      : __variant_impl(__variant_valueless_t{}) {
+    static_assert(!is_same_v<decay_t<decltype(__that)>, __nat>);
+    __generic_construct(*this, __that);
+  }
+
+  __variant_impl(
+      conditional_t<__all<is_move_constructible_v<_Types>...>::value,
+                    __variant_impl,
+                    __nat>&&
+          __that)
+    noexcept(__all<is_nothrow_move_constructible_v<_Types>...>::value)
+      : __variant_impl(__variant_valueless_t{}) {
+    static_assert(!is_same_v<decay_t<decltype(__that)>, __nat>);
+    __generic_construct(*this, _VSTD::move(__that));
+  }
+
+  __variant_impl& operator=(
+      const conditional_t<__all<(is_copy_constructible_v<_Types> &&
+                                 is_move_constructible_v<_Types> &&
+                                 is_copy_assignable_v<_Types>)...>::value,
+                          __variant_impl,
+                          __nat>& __that) {
+    static_assert(!is_same_v<decay_t<decltype(__that)>, __nat>);
+    return __generic_assign(__that);
+  }
+
+  __variant_impl& operator=(
+      conditional_t<__all<(is_move_constructible_v<_Types> &&
+                           is_move_assignable_v<_Types>)...>::value,
+                    __variant_impl,
+                    __nat>&&
+          __that) noexcept(__all<(is_nothrow_move_constructible_v<_Types> &&
+                                  is_nothrow_move_assignable_v<_Types>)...>::value) {
+    static_assert(!is_same_v<decay_t<decltype(__that)>, __nat>);
+    return __generic_assign(_VSTD::move(__that));
+  }
+
+  template <size_t _Ip, class _Arg>
+  void __assign(_Arg&& __arg) {
+    __assign_alt(__variant_impl_access::__get_alt<_Ip>(*this),
+                 _VSTD::forward<_Arg>(__arg),
+                 false_type{});
+  }
+
+  template <size_t _Ip, class... _Args>
+  void __emplace(_Args&&... __args) {
+    this->__destroy();
+    __construct_alt(__variant_impl_access::__get_alt<_Ip>(*this),
+                    _VSTD::forward<_Args>(__args)...);
+    this->__index = _Ip;
+  }
+
+  void __swap(__variant_impl& __that)  {
+    if (this->valueless_by_exception() && __that.valueless_by_exception()) {
+      // do nothing.
+    } else if (this->index() == __that.index()) {
+      __variant_impl_visitation::__visit_alt_at(
+          this->index(),
+          [](auto& __this_alt, auto& __that_alt) {
+            using _VSTD::swap;
+            swap(__this_alt.__value, __that_alt.__value);
+          },
+          *this, __that);
+    } else {
+      __variant_impl* __lhs = this;
+      __variant_impl* __rhs = _VSTD::addressof(__that);
+      if (__lhs->__move_nothrow() && !__rhs->__move_nothrow()) {
+        _VSTD::swap(__lhs, __rhs);
+      }
+      __variant_impl __tmp(_VSTD::move(*__rhs));
+#ifndef _LIBCPP_NO_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 guarentee.
+      try {
+        __generic_construct(*__rhs, _VSTD::move(*__lhs));
+      } catch (...) {
+        if (__tmp.__move_nothrow()) {
+          __generic_construct(*__rhs, _VSTD::move(__tmp));
+        }
+        throw;
+      }
+#else
+      __generic_construct(*__rhs, _VSTD::move(*__lhs));
+#endif
+      __generic_construct(*__lhs, _VSTD::move(__tmp));
+    }
+  }
+
+private:
+  bool __move_nothrow() const {
+    constexpr bool __results[] = {is_nothrow_move_constructible_v<_Types>...};
+    return this->valueless_by_exception() || __results[this->index()];
+  }
+
+  template <bool _CopyAssign, size_t _Ip, class _Tp, class _Arg>
+  void __assign_alt(__variant_alt<_Ip, _Tp>& __alt,
+                    _Arg&& __arg,
+                    bool_constant<_CopyAssign> __tag) {
+    if (this->index() == _Ip) {
+      __alt.__value = _VSTD::forward<_Arg>(__arg);
+    } else {
+      struct {
+        void operator()(true_type) const {
+          __this->__emplace<_Ip>(_Tp(_VSTD::forward<_Arg>(__arg)));
+        }
+        void operator()(false_type) const {
+          __this->__emplace<_Ip>(_VSTD::forward<_Arg>(__arg));
+        }
+        __variant_impl* __this;
+        _Arg&& __arg;
+      } __impl{this, _VSTD::forward<_Arg>(__arg)};
+      __impl(__tag);
+    }
+  }
+
+  template <class _That>
+  __variant_impl& __generic_assign(_That&& __that) {
+    static_assert(is_same_v<decay_t<_That>, __variant_impl>);
+    if (this->valueless_by_exception() && __that.valueless_by_exception()) {
+      // do nothing.
+    } else if (__that.valueless_by_exception()) {
+      this->__destroy();
+    } else {
+      __variant_impl_visitation::__visit_alt_at(
+          __that.index(),
+          [this](auto& __this_alt, auto&& __that_alt) {
+            this->__assign_alt(
+                __this_alt,
+                _VSTD::forward<decltype(__that_alt)>(__that_alt).__value,
+                is_lvalue_reference<_That>{});
+          },
+          *this, _VSTD::forward<_That>(__that));
+    }
+    return *this;
+  }
+
+  template <size_t _Ip, class _Tp, class... _Args>
+  static void __construct_alt(__variant_alt<_Ip, _Tp>& __alt,
+                              _Args&&... __args) {
+    ::new (_VSTD::addressof(__alt))
+        __variant_alt<_Ip, _Tp>(_VSTD::forward<_Args>(__args)...);
+  }
+
+  template <class _Rhs>
+  static void __generic_construct(__variant_impl& __lhs, _Rhs&& __rhs) {
+    static_assert(is_same_v<decay_t<_Rhs>, __variant_impl>);
+    __lhs.__destroy();
+    if (!__rhs.valueless_by_exception()) {
+      __variant_impl_visitation::__visit_alt_at(
+          __rhs.index(),
+          [](auto& __lhs_alt, auto&& __rhs_alt) {
+            __construct_alt(
+                __lhs_alt,
+                _VSTD::forward<decltype(__rhs_alt)>(__rhs_alt).__value);
+          },
+          __lhs, _VSTD::forward<_Rhs>(__rhs));
+      __lhs.__index = __rhs.index();
+    }
+  }
+};
+
+template <class... _Types>
+class variant {
+  static_assert(0 < sizeof...(_Types),
+                "variant must consist of at least one alternative.");
+
+  static_assert(__all<!is_array_v<_Types>...>::value,
+                "variant can not have an array type as an alternative.");
+
+  static_assert(__all<!is_reference_v<_Types>...>::value,
+                "variant can not have a reference type as an alternative.");
+
+  static_assert(__all<!is_void_v<_Types>...>::value,
+                "variant can not have a void type as an alternative.");
+
+public:
+  template <bool _Dummy = true,
+            enable_if_t<__dependent_type<is_default_constructible<
+                                             variant_alternative_t<0, variant>>,
+                                         _Dummy>::value,
+                        int> = 0>
+  constexpr variant() noexcept(
+      is_nothrow_default_constructible_v<variant_alternative_t<0, variant>>)
+      : __impl(in_place_index<0>) {}
+
+  variant(const variant&) = default;
+  variant(variant&&) = default;
+
+  template <class _Arg,
+            enable_if_t<!is_same_v<decay_t<_Arg>, variant>, int> = 0,
+            class _Tp = __variant_best_match_t<_Arg, _Types...>,
+            size_t _Ip = __find_unambiguous_index_sfinae<_Tp, _Types...>::value,
+            enable_if_t<is_constructible_v<_Tp, _Arg>, int> = 0>
+  constexpr variant(_Arg&& __arg) noexcept(
+      is_nothrow_constructible_v<_Tp, _Arg>)
+      : __impl(in_place_index<_Ip>, _VSTD::forward<_Arg>(__arg)) {}
+
+  template <size_t _Ip, class... _Args,
+            enable_if_t<(_Ip < sizeof...(_Types)), int> = 0,
+            class _Tp = variant_alternative_t<_Ip, variant<_Types...>>,
+            enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
+  explicit constexpr variant(
+      in_place_index_t<_Ip>,
+      _Args&&... __args) noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
+      : __impl(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...) {}
+
+  template <
+      size_t _Ip,
+      class _Up,
+      class... _Args,
+      enable_if_t<(_Ip < sizeof...(_Types)), int> = 0,
+      class _Tp = variant_alternative_t<_Ip, variant<_Types...>>,
+      enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
+                  int> = 0>
+  explicit constexpr variant(
+      in_place_index_t<_Ip>,
+      initializer_list<_Up> __il,
+      _Args&&... __args) noexcept(
+      is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>)
+      : __impl(in_place_index<_Ip>, __il, _VSTD::forward<_Args>(__args)...) {}
+
+  template <class _Tp,
+            class... _Args,
+            size_t _Ip = __find_unambiguous_index_sfinae<_Tp, _Types...>::value,
+            enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
+  explicit constexpr variant(in_place_type_t<_Tp>, _Args&&... __args) noexcept(
+      is_nothrow_constructible_v<_Tp, _Args...>)
+      : __impl(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...) {}
+
+  template <
+      class _Tp,
+      class _Up,
+      class... _Args,
+      size_t _Ip = __find_unambiguous_index_sfinae<_Tp, _Types...>::value,
+      enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
+                  int> = 0>
+  explicit constexpr variant(
+      in_place_type_t<_Tp>,
+      initializer_list<_Up> __il,
+      _Args&&... __args) noexcept(
+      is_nothrow_constructible_v<_Tp, initializer_list< _Up>&, _Args...>)
+      : __impl(in_place_index<_Ip>, __il, _VSTD::forward<_Args>(__args)...) {}
+
+  ~variant() = default;
+
+  variant& operator=(const variant&) = default;
+  variant& operator=(variant&&) = default;
+
+  template <class _Arg,
+            enable_if_t<!is_same_v<decay_t<_Arg>, variant>, int> = 0,
+            class _Tp = __variant_best_match_t<_Arg, _Types...>,
+            size_t _Ip = __find_unambiguous_index_sfinae<_Tp, _Types...>::value,
+            enable_if_t<(is_assignable_v<_Tp&, _Arg> &&
+                         is_constructible_v<_Tp, _Arg>), int> = 0>
+  variant& operator=(_Arg&& __arg) noexcept(
+    (is_nothrow_assignable_v<_Tp&, _Arg> &&
+     is_nothrow_constructible_v<_Tp, _Arg>)) {
+    __impl.template __assign<_Ip>(_VSTD::forward<_Arg>(__arg));
+    return *this;
+  }
+
+  template <
+      size_t _Ip,
+      class... _Args,
+      enable_if_t<(_Ip < sizeof...(_Types)), int> = 0,
+      class _Tp = variant_alternative_t<_Ip, variant<_Types...>>,
+      enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
+  void emplace(_Args&&... __args) {
+    __impl.template __emplace<_Ip>(_VSTD::forward<_Args>(__args)...);
+  }
+
+  template <
+      size_t _Ip,
+      class _Up,
+      class... _Args,
+      enable_if_t<(_Ip < sizeof...(_Types)), int> = 0,
+      class _Tp = variant_alternative_t<_Ip, variant<_Types...>>,
+      enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
+                  int> = 0>
+  void emplace(initializer_list<_Up> __il, _Args&&... __args) {
+    __impl.template __emplace<_Ip>(__il, _VSTD::forward<_Args>(__args)...);
+  }
+
+  template <
+      class _Tp,
+      class... _Args,
+      size_t _Ip = __find_unambiguous_index_sfinae<_Tp, _Types...>::value,
+      enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
+  void emplace(_Args&&... __args) {
+    __impl.template __emplace<_Ip>(_VSTD::forward<_Args>(__args)...);
+  }
+
+  template <
+      class _Tp,
+      class _Up,
+      class... _Args,
+      size_t _Ip = __find_unambiguous_index_sfinae<_Tp, _Types...>::value,
+      enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
+                  int> = 0>
+  void emplace(initializer_list<_Up> __il, _Args&&... __args) {
+    __impl.template __emplace<_Ip>(__il, _VSTD::forward<_Args>(__args)...);
+  }
+
+  constexpr bool valueless_by_exception() const noexcept {
+    return __impl.valueless_by_exception();
+  }
+
+  constexpr size_t index() const noexcept { return __impl.index(); }
+
+  template <
+      bool _Dummy = true,
+      enable_if_t<
+          __all<(
+              __dependent_type<is_move_constructible<_Types>, _Dummy>::value &&
+              __dependent_type<is_swappable<_Types>, _Dummy>::value)...>::value,
+          int> = 0>
+  void swap(variant& __that) noexcept(
+      __all<(is_nothrow_move_constructible_v<_Types> &&
+             is_nothrow_swappable_v<_Types>)...>::value) {
+    __impl.__swap(__that.__impl);
+  }
+
+private:
+  __variant_impl<_Types...> __impl;
+
+  friend struct __variant_access;
+  friend struct __variant_visitation;
+};
+
+template <size_t _Ip, class... _Types>
+constexpr bool __holds_alternative(const variant<_Types...>& __v) noexcept {
+  return __v.index() == _Ip;
+}
+
+template <class _Tp, class... _Types>
+constexpr bool holds_alternative(const variant<_Types...>& __v) noexcept {
+  return __holds_alternative<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
+}
+
+template <size_t _Ip, class _Vp>
+static constexpr auto&& __generic_get(_Vp&& __v) {
+  if (!__holds_alternative<_Ip>(__v)) {
+    throw bad_variant_access{};
+  }
+  return __variant_access::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v)).__value;
+}
+
+template <size_t _Ip, class... _Types>
+constexpr variant_alternative_t<_Ip, variant<_Types...>>& get(
+    variant<_Types...>& __v) {
+  static_assert(_Ip < sizeof...(_Types));
+  static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
+  return __generic_get<_Ip>(__v);
+}
+
+template <size_t _Ip, class... _Types>
+constexpr variant_alternative_t<_Ip, variant<_Types...>>&& get(
+    variant<_Types...>&& __v) {
+  static_assert(_Ip < sizeof...(_Types));
+  static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
+  return __generic_get<_Ip>(_VSTD::move(__v));
+}
+
+template <size_t _Ip, class... _Types>
+constexpr const variant_alternative_t<_Ip, variant<_Types...>>& get(
+    const variant<_Types...>& __v) {
+  static_assert(_Ip < sizeof...(_Types));
+  static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
+  return __generic_get<_Ip>(__v);
+}
+
+template <size_t _Ip, class... _Types>
+constexpr const variant_alternative_t<_Ip, variant<_Types...>>&& get(
+    const variant<_Types...>&& __v) {
+  static_assert(_Ip < sizeof...(_Types));
+  static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
+  return __generic_get<_Ip>(_VSTD::move(__v));
+}
+
+template <class _Tp, class... _Types>
+constexpr _Tp& get(variant<_Types...>& __v) {
+  static_assert(!is_void_v<_Tp>);
+  return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
+}
+
+template <class _Tp, class... _Types>
+constexpr _Tp&& get(variant<_Types...>&& __v) {
+  static_assert(!is_void_v<_Tp>);
+  return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(
+      _VSTD::move(__v));
+}
+
+template <class _Tp, class... _Types>
+constexpr const _Tp& get(const variant<_Types...>& __v) {
+  static_assert(!is_void_v<_Tp>);
+  return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
+}
+
+template <class _Tp, class... _Types>
+constexpr const _Tp&& get(const variant<_Types...>&& __v) {
+  static_assert(!is_void_v<_Tp>);
+  return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(
+      _VSTD::move(__v));
+}
+
+template <size_t _Ip, class _Vp>
+constexpr auto* __generic_get_if(_Vp* __v) noexcept {
+  return __v && __holds_alternative<_Ip>(*__v)
+             ? _VSTD::addressof(__variant_access::__get_alt<_Ip>(*__v).__value)
+             : nullptr;
+}
+
+template <size_t _Ip, class... _Types>
+constexpr add_pointer_t<variant_alternative_t<_Ip, variant<_Types...>>>
+get_if(variant<_Types...>* __v) noexcept {
+  static_assert(_Ip < sizeof...(_Types));
+  static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
+  return __generic_get_if<_Ip>(__v);
+}
+
+template <size_t _Ip, class... _Types>
+constexpr add_pointer_t<const variant_alternative_t<_Ip, variant<_Types...>>>
+get_if(const variant<_Types...>* __v) noexcept {
+  static_assert(_Ip < sizeof...(_Types));
+  static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
+  return __generic_get_if<_Ip>(__v);
+}
+
+template <class _Tp, class... _Types>
+constexpr add_pointer_t<_Tp>
+get_if(variant<_Types...>* __v) noexcept {
+  static_assert(!is_void_v<_Tp>);
+  return _VSTD::get_if<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
+}
+
+template <class _Tp, class... _Types>
+constexpr add_pointer_t<const _Tp>
+get_if(const variant<_Types...>* __v) noexcept {
+  static_assert(!is_void_v<_Tp>);
+  return _VSTD::get_if<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
+}
+
+template <class... _Types>
+constexpr bool operator==(const variant<_Types...>& __lhs,
+                          const variant<_Types...>& __rhs) {
+  if (__lhs.index() != __rhs.index()) return false;
+  if (__lhs.valueless_by_exception()) return true;
+  return __variant_visitation::__visit_value_at(
+      __lhs.index(), equal_to<>{}, __lhs, __rhs);
+}
+
+template <class... _Types>
+constexpr bool operator!=(const variant<_Types...>& __lhs,
+                          const variant<_Types...>& __rhs) {
+  if (__lhs.index() != __rhs.index()) return true;
+  if (__lhs.valueless_by_exception()) return false;
+  return __variant_visitation::__visit_value_at(
+      __lhs.index(), not_equal_to<>{}, __lhs, __rhs);
+}
+
+template <class... _Types>
+constexpr bool operator<(const variant<_Types...>& __lhs,
+                         const variant<_Types...>& __rhs) {
+  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_visitation::__visit_value_at(
+      __lhs.index(), less<>{}, __lhs, __rhs);
+}
+
+template <class... _Types>
+constexpr bool operator>(const variant<_Types...>& __lhs,
+                         const variant<_Types...>& __rhs) {
+  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_visitation::__visit_value_at(
+      __lhs.index(), greater<>{}, __lhs, __rhs);
+}
+
+template <class... _Types>
+constexpr bool operator<=(const variant<_Types...>& __lhs,
+                          const variant<_Types...>& __rhs) {
+  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_visitation::__visit_value_at(
+      __lhs.index(), less_equal<>{}, __lhs, __rhs);
+}
+
+template <class... _Types>
+constexpr bool operator>=(const variant<_Types...>& __lhs,
+                          const variant<_Types...>& __rhs) {
+  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_visitation::__visit_value_at(
+      __lhs.index(), greater_equal<>{}, __lhs, __rhs);
+}
+
+template <class _Visitor, class... _Vs>
+constexpr decltype(auto) visit(_Visitor&& __visitor, _Vs&&... __vs) {
+  bool __results[] = {__vs.valueless_by_exception()...};
+  for (bool __result : __results) {
+    if (__result) {
+      throw bad_variant_access{};
+    }
+  }
+  return __variant_visitation::__visit_value(
+      _VSTD::forward<_Visitor>(__visitor), _VSTD::forward<_Vs>(__vs)...);
+}
+
+struct _LIBCPP_TYPE_VIS_ONLY monostate {};
+
+constexpr bool operator<(monostate, monostate) noexcept { return false; }
+constexpr bool operator>(monostate, monostate) noexcept { return false; }
+constexpr bool operator<=(monostate, monostate) noexcept { return true; }
+constexpr bool operator>=(monostate, monostate) noexcept { return true; }
+constexpr bool operator==(monostate, monostate) noexcept { return true; }
+constexpr bool operator!=(monostate, monostate) noexcept { return false; }
+
+template <class... _Types>
+auto swap(variant<_Types...>& __lhs,
+          variant<_Types...>& __rhs) noexcept(noexcept(__lhs.swap(__rhs)))
+    -> decltype(__lhs.swap(__rhs), void()) {
+  __lhs.swap(__rhs);
+}
+
+template <class... _Types>
+struct _LIBCPP_TYPE_VIS_ONLY hash<variant<_Types...>> {
+  using argument_type = variant<_Types...>;
+  using result_type = size_t;
+
+  result_type operator()(const argument_type& __v) const {
+    return __v.valueless_by_exception()
+               ? variant_npos
+               : __variant_visitation::__visit_alt(
+                     [](const auto& __alt) {
+                       using __alt_type = decay_t<decltype(__alt)>;
+                       using __value_type = typename __alt_type::__value_type;
+                       return hash<__value_type>{}(__alt.__value);
+                     },
+                     __v);
+  }
+};
+
+template <>
+struct _LIBCPP_TYPE_VIS_ONLY hash<monostate> {
+  using argument_type = monostate;
+  using result_type = size_t;
+
+  result_type operator()(const argument_type&) const { return 0; }
+};
+
+#endif  // _LIBCPP_STD_VER > 14
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif  // _LIBCPP_VARIANT

src/variant.cpp

+//===------------------------ variant.cpp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "variant"
+
+namespace std {
+
+const char* bad_variant_access::what() const noexcept {
+  return "bad_variant_access";
+}
+
+}  // namespace std