[tuple.tuple] - C++17 → C++20

Files changed (1) hide show

tmp/tmplaiqyf5w/{from.md → to.md} +172 -539

tmp/tmplaiqyf5w/{from.md → to.md} RENAMED Viewed

@@ -4,64 +4,71 @@
 namespace std {
   template<class... Types>
   class tuple {
   public:
     // [tuple.cnstr], tuple construction
-      \EXPLICIT constexpr tuple();
-      \EXPLICIT constexpr tuple(const Types&...);         // only if sizeof...(Types) >= 1
     template<class... UTypes>
-        \EXPLICIT constexpr tuple(UTypes&&...);           // only if sizeof...(Types) >= 1
     tuple(const tuple&) = default;
     tuple(tuple&&) = default;
     template<class... UTypes>
-        \EXPLICIT constexpr tuple(const tuple<UTypes...>&);
     template<class... UTypes>
-        \EXPLICIT constexpr tuple(tuple<UTypes...>&&);
     template<class U1, class U2>
-        \EXPLICIT constexpr tuple(const pair<U1, U2>&);   // only if sizeof...(Types) == 2
     template<class U1, class U2>
-        \EXPLICIT constexpr tuple(pair<U1, U2>&&);        // only if sizeof...(Types) == 2
     // allocator-extended constructors
     template<class Alloc>
         tuple(allocator_arg_t, const Alloc& a);
     template<class Alloc>
-        \EXPLICIT tuple(allocator_arg_t, const Alloc& a, const Types&...);
     template<class Alloc, class... UTypes>
-        \EXPLICIT tuple(allocator_arg_t, const Alloc& a, UTypes&&...);
     template<class Alloc>
- tuple(allocator_arg_t, const Alloc& a, const tuple&);
     template<class Alloc>
- tuple(allocator_arg_t, const Alloc& a, tuple&&);
     template<class Alloc, class... UTypes>
-        \EXPLICIT tuple(allocator_arg_t, const Alloc& a, const tuple<UTypes...>&);
     template<class Alloc, class... UTypes>
-        \EXPLICIT tuple(allocator_arg_t, const Alloc& a, tuple<UTypes...>&&);
     template<class Alloc, class U1, class U2>
-        \EXPLICIT tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&);
     template<class Alloc, class U1, class U2>
-        \EXPLICIT tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);
     // [tuple.assign], tuple assignment
- tuple& operator=(const tuple&);
- tuple& operator=(tuple&&) noexcept(see below);
     template<class... UTypes>
- tuple& operator=(const tuple<UTypes...>&);
     template<class... UTypes>
- tuple& operator=(tuple<UTypes...>&&);
     template<class U1, class U2>
- tuple& operator=(const pair<U1, U2>&); // only if sizeof...(Types) == 2
     template<class U1, class U2>
- tuple& operator=(pair<U1, U2>&&); // only if sizeof...(Types) == 2
     // [tuple.swap], tuple swap
- void swap(tuple&) noexcept(see below);
   };
   template<class... UTypes>
     tuple(UTypes...) -> tuple<UTypes...>;
   template<class T1, class T2>
@@ -75,186 +82,211 @@ namespace std {
 }
 ```
 #### Construction <a id="tuple.cnstr">[[tuple.cnstr]]</a>
 For each `tuple` constructor, an exception is thrown only if the
 construction of one of the types in `Types` throws an exception.
-The defaulted move and copy constructor, respectively, of `tuple` shall
-be a constexpr function if and only if all required element-wise
-initializations for copy and move, respectively, would satisfy the
 requirements for a constexpr function. The defaulted move and copy
-constructor of `tuple<>` shall be constexpr functions.
-The destructor of tuple shall be a trivial destructor if
-`(is_trivially_destructible_v<Types> && ...)` is `true`.
-In the constructor descriptions that follow, let i be in the range
-\[`0`, `sizeof...(Types)`) in order, `Tᵢ` be the iᵗʰ type in `Types`,
-and `Uᵢ` be the iᵗʰ type in a template parameter pack named `UTypes`,
-where indexing is zero-based.
 ``` cpp
-\EXPLICIT constexpr tuple();
 ```
 *Effects:* Value-initializes each element.
-*Remarks:* This constructor shall not participate in overload resolution
-unless `is_default_constructible_v<``Tᵢ``>` is `true` for all i.
-[*Note 1*: This behavior can be implemented by a constructor template
-with default template arguments. — *end note*]
-The constructor is explicit if and only if `Tᵢ` is not implicitly
-default-constructible for at least one i.
-[*Note 2*: This behavior can be implemented with a trait that checks
 whether a `const ``Tᵢ``&` can be initialized with `{}`. — *end note*]
 ``` cpp
-\EXPLICIT constexpr tuple(const Types&...);
 ```
 *Effects:* Initializes each element with the value of the corresponding
 parameter.
-*Remarks:* This constructor shall not participate in overload resolution
-unless `sizeof...(Types) >= 1` and `is_copy_constructible_v<``Tᵢ``>` is
-`true` for all i. The constructor is explicit if and only if
-`is_convertible_v<const ``Tᵢ``&, ``Tᵢ``>` is `false` for at least one i.
 ``` cpp
-template <class... UTypes> \EXPLICIT constexpr tuple(UTypes&&... u);
 ```
 *Effects:* Initializes the elements in the tuple with the corresponding
 value in `std::forward<UTypes>(u)`.
-*Remarks:* This constructor shall not participate in overload resolution
-unless `sizeof...(Types)` `==` `sizeof...(UTypes)` and
-`sizeof...(Types) >= 1` and `is_constructible_v<``Tᵢ``, ``Uᵢ``&&>` is
-`true` for all i. The constructor is explicit if and only if
-`is_convertible_v<``Uᵢ``&&, ``Tᵢ``>` is `false` for at least one i.
 ``` cpp
 tuple(const tuple& u) = default;
 ```
-*Requires:* `is_copy_constructible_v<``Tᵢ``>` is `true` for all i.
 *Effects:* Initializes each element of `*this` with the corresponding
 element of `u`.
 ``` cpp
 tuple(tuple&& u) = default;
 ```
-*Requires:* `is_move_constructible_v<``Tᵢ``>` is `true` for all i.
 *Effects:* For all i, initializes the iᵗʰ element of `*this` with
 `std::forward<``Tᵢ``>(get<`i`>(u))`.
 ``` cpp
-template <class... UTypes> \EXPLICIT constexpr tuple(const tuple<UTypes...>& u);
 ```
-*Effects:* Initializes each element of `*this` with the corresponding
-element of `u`.
-*Remarks:* This constructor shall not participate in overload resolution
-unless
-- `sizeof...(Types)` `==` `sizeof...(UTypes)` and
 - `is_constructible_v<``Tᵢ``, const ``Uᵢ``&>` is `true` for all i, and
-- `sizeof...(Types) != 1`, or (when `Types...` expands to `T` and
-  `UTypes...` expands to `U`)
-  `!is_convertible_v<const tuple<U>&, T> && !is_constructible_v<T, const tuple<U>&>&& !is_same_v<T, U>`
- is `true`.
-The constructor is explicit if and only if
-`is_convertible_v<const ``Uᵢ``&, ``Tᵢ``>` is `false` for at least one i.
 ``` cpp
-template <class... UTypes> \EXPLICIT constexpr tuple(tuple<UTypes...>&& u);
 ```
 *Effects:* For all i, initializes the iᵗʰ element of `*this` with
 `std::forward<``Uᵢ``>(get<`i`>(u))`.
-*Remarks:* This constructor shall not participate in overload resolution
-unless
-- `sizeof...(Types)` `==` `sizeof...(UTypes)`, and
-- `is_constructible_v<``Tᵢ``, ``Uᵢ``&&>` is `true` for all i, and
-- `sizeof...(Types) != 1`, or (when `Types...` expands to `T` and
-  `UTypes...` expands to `U`)
-  `!is_convertible_v<tuple<U>, T> && !is_constructible_v<T, tuple<U>> &&!is_same_v<T, U>`
-  is `true`.
-The constructor is explicit if and only if
-`is_convertible_v<``Uᵢ``&&, ``Tᵢ``>` is `false` for at least one i.
 ``` cpp
-template <class U1, class U2> \EXPLICIT constexpr tuple(const pair<U1, U2>& u);
 ```
 *Effects:* Initializes the first element with `u.first` and the second
 element with `u.second`.
-*Remarks:* This constructor shall not participate in overload resolution
-unless `sizeof...(Types) == 2`, `is_constructible_v<``T₀``, const U1&>`
-is `true` and `is_constructible_v<``T₁``, const U2&>` is `true`.
-The constructor is explicit if and only if
-`is_convertible_v<const U1&, ``T₀``>` is `false` or
-`is_convertible_v<const U2&, ``T₁``>` is `false`.
 ``` cpp
-template <class U1, class U2> \EXPLICIT constexpr tuple(pair<U1, U2>&& u);
 ```
 *Effects:* Initializes the first element with
 `std::forward<U1>(u.first)` and the second element with
 `std::forward<U2>(u.second)`.
-*Remarks:* This constructor shall not participate in overload resolution
-unless `sizeof...(Types) == 2`, `is_constructible_v<``T₀``, U1&&>` is
-`true` and `is_constructible_v<``T₁``, U2&&>` is `true`.
-The constructor is explicit if and only if
-`is_convertible_v<U1&&, ``T₀``>` is `false` or
-`is_convertible_v<U2&&, ``T₁``>` is `false`.
 ``` cpp
 template<class Alloc>
     tuple(allocator_arg_t, const Alloc& a);
 template<class Alloc>
- \EXPLICIT tuple(allocator_arg_t, const Alloc& a, const Types&...);
 template<class Alloc, class... UTypes>
- \EXPLICIT tuple(allocator_arg_t, const Alloc& a, UTypes&&...);
 template<class Alloc>
-  tuple(allocator_arg_t, const Alloc& a, const tuple&);
 template<class Alloc>
-  tuple(allocator_arg_t, const Alloc& a, tuple&&);
 template<class Alloc, class... UTypes>
- \EXPLICIT tuple(allocator_arg_t, const Alloc& a, const tuple<UTypes...>&);
 template<class Alloc, class... UTypes>
- \EXPLICIT tuple(allocator_arg_t, const Alloc& a, tuple<UTypes...>&&);
 template<class Alloc, class U1, class U2>
- \EXPLICIT tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&);
 template<class Alloc, class U1, class U2>
- \EXPLICIT tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);
 ```
-*Requires:* `Alloc` shall meet the requirements for an
-`Allocator` ([[allocator.requirements]]).
 *Effects:* Equivalent to the preceding constructors except that each
 element is constructed with uses-allocator
-construction ([[allocator.uses.construction]]).
 #### Assignment <a id="tuple.assign">[[tuple.assign]]</a>
 For each `tuple` assignment operator, an exception is thrown only if the
 assignment of one of the types in `Types` throws an exception. In the
@@ -262,31 +294,30 @@ function descriptions that follow, let i be in the range \[`0`,
 `sizeof...(Types)`) in order, `Tᵢ` be the iᵗʰ type in `Types`, and `Uᵢ`
 be the iᵗʰ type in a template parameter pack named `UTypes`, where
 indexing is zero-based.
 ``` cpp
-tuple& operator=(const tuple& u);
 ```
 *Effects:* Assigns each element of `u` to the corresponding element of
 `*this`.
-*Remarks:* This operator shall be defined as deleted unless
 `is_copy_assignable_v<``Tᵢ``>` is `true` for all i.
 *Returns:* `*this`.
 ``` cpp
-tuple& operator=(tuple&& u) noexcept(see below);
 ```
 *Effects:* For all i, assigns `std::forward<``Tᵢ``>(get<`i`>(u))` to
 `get<`i`>(*this)`.
-*Remarks:* This operator shall be defined as deleted unless
-`is_move_assignable_v<``Tᵢ``>` is `true` for all i.
 *Remarks:* The expression inside `noexcept` is equivalent to the logical
 <span class="smallcaps">and</span> of the following expressions:
 ``` cpp
 is_nothrow_move_assignable_v<Tᵢ>
@@ -295,74 +326,76 @@ is_nothrow_move_assignable_v<Tᵢ>
 where Tᵢ is the iᵗʰ type in `Types`.
 *Returns:* `*this`.
 ``` cpp
-template <class... UTypes> tuple& operator=(const tuple<UTypes...>& u);
 ```
 *Effects:* Assigns each element of `u` to the corresponding element of
 `*this`.
-*Remarks:* This operator shall not participate in overload resolution
-unless `sizeof...(Types) == sizeof...(UTypes)` and
-`is_assignable_v<``Tᵢ``&, const ``Uᵢ``&>` is `true` for all i.
 *Returns:* `*this`.
 ``` cpp
-template <class... UTypes> tuple& operator=(tuple<UTypes...>&& u);
 ```
 *Effects:* For all i, assigns `std::forward<``Uᵢ``>(get<`i`>(u))` to
 `get<`i`>(*this)`.
-*Remarks:* This operator shall not participate in overload resolution
-unless `is_assignable_v<``Tᵢ``&, ``Uᵢ``&&> == true` for all i and
-`sizeof...(Types) == sizeof...(UTypes)`.
 *Returns:* `*this`.
 ``` cpp
-template <class U1, class U2> tuple& operator=(const pair<U1, U2>& u);
 ```
 *Effects:* Assigns `u.first` to the first element of `*this` and
 `u.second` to the second element of `*this`.
-*Remarks:* This operator shall not participate in overload resolution
-unless `sizeof...(Types) == 2` and `is_assignable_v<``T₀``&, const U1&>`
-is `true` for the first type `T₀` in `Types` and
-`is_assignable_v<``T₁``&, const U2&>` is `true` for the second type `T₁`
-in `Types`.
 *Returns:* `*this`.
 ``` cpp
-template <class U1, class U2> tuple& operator=(pair<U1, U2>&& u);
 ```
 *Effects:* Assigns `std::forward<U1>(u.first)` to the first element of
 `*this` and
 `std::forward<U2>(u.second)` to the second element of `*this`.
-*Remarks:* This operator shall not participate in overload resolution
-unless `sizeof...(Types) == 2` and `is_assignable_v<``T₀``&, U1&&>` is
-`true` for the first type `T₀` in `Types` and
-`is_assignable_v<``T₁``&, U2&&>` is `true` for the second type `T₁` in
-`Types`.
 *Returns:* `*this`.
 #### `swap` <a id="tuple.swap">[[tuple.swap]]</a>
 ``` cpp
-void swap(tuple& rhs) noexcept(see below);
 ```
-*Requires:* Each element in `*this` shall be swappable
-with ([[swappable.requirements]]) the corresponding element in `rhs`.
 *Effects:* Calls `swap` for each element in `*this` and its
 corresponding element in `rhs`.
 *Remarks:* The expression inside `noexcept` is equivalent to the logical
@@ -375,405 +408,5 @@ is_nothrow_swappable_v<Tᵢ>
 where Tᵢ is the iᵗʰ type in `Types`.
 *Throws:* Nothing unless one of the element-wise `swap` calls throws an
 exception.
-#### Tuple creation functions <a id="tuple.creation">[[tuple.creation]]</a>
-In the function descriptions that follow, the members of a parameter
-pack `XTypes` are denoted by `X`ᵢ for i in \[`0`,
-`sizeof...(`*X*`Types)`) in order, where indexing is zero-based.
-``` cpp
-template<class... TTypes>
-  constexpr tuple<VTypes...> make_tuple(TTypes&&... t);
-```
-The pack `VTypes` is defined as follows. Let `U`ᵢ be `decay_t<T`ᵢ`>` for
-each `T`ᵢ in `TTypes`. If `U`ᵢ is a specialization of
-`reference_wrapper`, then `V`ᵢ in `VTypes` is `U`ᵢ`::type&`, otherwise
-`V`ᵢ is `U`ᵢ.
-*Returns:* `tuple<VTypes...>(std::forward<TTypes>(t)...)`.
-[*Example 1*:
-``` cpp
-int i; float j;
-make_tuple(1, ref(i), cref(j))
-```
-creates a tuple of type `tuple<int, int&, const float&>`.
-— *end example*]
-``` cpp
-template<class... TTypes>
-  constexpr tuple<TTypes&&...> forward_as_tuple(TTypes&&... t) noexcept;
-```
-*Effects:* Constructs a tuple of references to the arguments in `t`
-suitable for forwarding as arguments to a function. Because the result
-may contain references to temporary variables, a program shall ensure
-that the return value of this function does not outlive any of its
-arguments (e.g., the program should typically not store the result in a
-named variable).
-*Returns:* `tuple<TTypes&&...>(std::forward<TTypes>(t)...)`.
-``` cpp
-template<class... TTypes>
-  constexpr tuple<TTypes&...> tie(TTypes&... t) noexcept;
-```
-*Returns:* `tuple<TTypes&...>(t...)`. When an argument in `t` is
-`ignore`, assigning any value to the corresponding tuple element has no
-effect.
-[*Example 2*:
-`tie` functions allow one to create tuples that unpack tuples into
-variables. `ignore` can be used for elements that are not needed:
-``` cpp
-int i; std::string s;
-tie(i, ignore, s) = make_tuple(42, 3.14, "C++");
-// i == 42, s == "C++"
-```
-— *end example*]
-``` cpp
-template <class... Tuples>
-  constexpr tuple<CTypes...> tuple_cat(Tuples&&... tpls);
-```
-In the following paragraphs, let `Tᵢ` be the iᵗʰ type in `Tuples`, `Uᵢ`
-be `remove_reference_t<T`ᵢ`>`, and `tpᵢ` be the iᵗʰ parameter in the
-function parameter pack `tpls`, where all indexing is zero-based.
-*Requires:* For all i, `Uᵢ` shall be the type cvᵢ `tuple<``Argsᵢ``...>`,
-where cvᵢ is the (possibly empty) iᵗʰ *cv-qualifier-seq* and `Argsᵢ` is
-the parameter pack representing the element types in `Uᵢ`. Let `A_ik` be
-the kᵗʰ type in `Argsᵢ`. For all `A_ik` the following requirements shall
-be satisfied:
-- If `Tᵢ` is deduced as an lvalue reference type, then
-  `is_constructible_v<``A_ik``, `cvᵢ `A_ik``&> == true`, otherwise
-- `is_constructible_v<``A_ik``, `cvᵢ `A_ik``&&> == true`.
-*Remarks:* The types in `CTypes` shall be equal to the ordered sequence
-of the extended types `Args₀``..., ``Args₁``..., `…`, ``Args_n-1``...`,
-where n is equal to `sizeof...(Tuples)`. Let `eᵢ``...` be the iᵗʰ
-ordered sequence of tuple elements of the resulting `tuple` object
-corresponding to the type sequence `Argsᵢ`.
-*Returns:* A `tuple` object constructed by initializing the kᵢᵗʰ type
-element `e_ik` in `eᵢ``...` with
-``` cpp
-get<kᵢ>(std::forward<$T_i$>($tp_i$))
-```
-for each valid kᵢ and each group `eᵢ` in order.
-[*Note 1*: An implementation may support additional types in the
-parameter pack `Tuples` that support the `tuple`-like protocol, such as
-`pair` and `array`. — *end note*]
-#### Calling a function with a `tuple` of arguments <a id="tuple.apply">[[tuple.apply]]</a>
-``` cpp
-template <class F, class Tuple>
-  constexpr decltype(auto) apply(F&& f, Tuple&& t);
-```
-*Effects:* Given the exposition-only function:
-``` cpp
-template <class F, class Tuple, size_t... I>
-constexpr decltype(auto)
-    apply_impl(F&& f, Tuple&& t, index_sequence<I...>) {                // exposition only
-  return INVOKE(std::forward<F>(f), std::get<I>(std::forward<Tuple>(t))...);
-}
-```
-Equivalent to:
-``` cpp
-return apply_impl(std::forward<F>(f), std::forward<Tuple>(t),
-                  make_index_sequence<tuple_size_v<decay_t<Tuple>>>{});
-```
-``` cpp
-template <class T, class Tuple>
-  constexpr T make_from_tuple(Tuple&& t);
-```
-*Effects:* Given the exposition-only function:
-``` cpp
-template <class T, class Tuple, size_t... I>
-constexpr T make_from_tuple_impl(Tuple&& t, index_sequence<I...>) {     // exposition only
-  return T(get<I>(std::forward<Tuple>(t))...);
-}
-```
-Equivalent to:
-``` cpp
-return make_from_tuple_impl<T>(forward<Tuple>(t),
-                               make_index_sequence<tuple_size_v<decay_t<Tuple>>>{});
-```
-[*Note 1*: The type of `T` must be supplied as an explicit template
-parameter, as it cannot be deduced from the argument
-list. — *end note*]
-#### Tuple helper classes <a id="tuple.helper">[[tuple.helper]]</a>
-``` cpp
-template <class T> struct tuple_size;
-```
-*Remarks:* All specializations of `tuple_size` shall meet the
-`UnaryTypeTrait` requirements ([[meta.rqmts]]) with a base
-characteristic of `integral_constant<size_t, N>` for some `N`.
-``` cpp
-template <class... Types>
-  class tuple_size<tuple<Types...>> : public integral_constant<size_t, sizeof...(Types)> { };
-```
-``` cpp
-template <size_t I, class... Types>
-  class tuple_element<I, tuple<Types...>> {
-  public:
-    using type = TI;
-  };
-```
-*Requires:* `I < sizeof...(Types)`. The program is ill-formed if `I` is
-out of bounds.
-*Type:* `TI` is the type of the `I`th element of `Types`, where indexing
-is zero-based.
-``` cpp
-template <class T> class tuple_size<const T>;
-template <class T> class tuple_size<volatile T>;
-template <class T> class tuple_size<const volatile T>;
-```
-Let *`TS`* denote `tuple_size<T>` of the cv-unqualified type `T`. If the
-expression *`TS`*`::value` is well-formed when treated as an unevaluated
-operand, then each of the three templates shall meet the
-`UnaryTypeTrait` requirements ([[meta.rqmts]]) with a base
-characteristic of
-``` cpp
-integral_constant<size_t, TS::value>
-```
-Otherwise, they shall have no member `value`.
-Access checking is performed as if in a context unrelated to *`TS`* and
-`T`. Only the validity of the immediate context of the expression is
-considered.
-[*Note 1*: The compilation of the expression can result in side effects
-such as the instantiation of class template specializations and function
-template specializations, the generation of implicitly-defined
-functions, and so on. Such side effects are not in the “immediate
-context” and can result in the program being ill-formed. — *end note*]
-In addition to being available via inclusion of the `<tuple>` header,
-the three templates are available when either of the headers `<array>`
-or `<utility>` are included.
-``` cpp
-template <size_t I, class T> class tuple_element<I, const T>;
-template <size_t I, class T> class tuple_element<I, volatile T>;
-template <size_t I, class T> class tuple_element<I, const volatile T>;
-```
-Let *`TE`* denote `tuple_element_t<I, T>` of the cv-unqualified type
-`T`. Then each of the three templates shall meet the
-`TransformationTrait` requirements ([[meta.rqmts]]) with a member
-typedef `type` that names the following type:
-- for the first specialization, `add_const_t<`*`TE`*`>`,
-- for the second specialization, `add_volatile_t<`*`TE`*`>`, and
-- for the third specialization, `add_cv_t<`*`TE`*`>`.
-In addition to being available via inclusion of the `<tuple>` header,
-the three templates are available when either of the headers `<array>`
-or `<utility>` are included.
-#### Element access <a id="tuple.elem">[[tuple.elem]]</a>
-``` cpp
-template <size_t I, class... Types>
-  constexpr tuple_element_t<I, tuple<Types...>>&
-    get(tuple<Types...>& t) noexcept;
-template <size_t I, class... Types>
-  constexpr tuple_element_t<I, tuple<Types...>>&&
-    get(tuple<Types...>&& t) noexcept;        // Note A
-template <size_t I, class... Types>
-  constexpr const tuple_element_t<I, tuple<Types...>>&
-    get(const tuple<Types...>& t) noexcept;   // Note B
-template <size_t I, class... Types>
-  constexpr const tuple_element_t<I, tuple<Types...>>&& get(const tuple<Types...>&& t) noexcept;
-```
-*Requires:* `I < sizeof...(Types)`. The program is ill-formed if `I` is
-out of bounds.
-*Returns:* A reference to the `I`th element of `t`, where indexing is
-zero-based.
-[*Note 1*: \[Note A\]If a `T` in `Types` is some reference type `X&`,
-the return type is `X&`, not `X&&`. However, if the element type is a
-non-reference type `T`, the return type is `T&&`. — *end note*]
-[*Note 2*: \[Note B\]Constness is shallow. If a `T` in `Types` is some
-reference type `X&`, the return type is `X&`, not `const X&`. However,
-if the element type is a non-reference type `T`, the return type is
-`const T&`. This is consistent with how constness is defined to work for
-member variables of reference type. — *end note*]
-``` cpp
-template <class T, class... Types>
-  constexpr T& get(tuple<Types...>& t) noexcept;
-template <class T, class... Types>
-  constexpr T&& get(tuple<Types...>&& t) noexcept;
-template <class T, class... Types>
-  constexpr const T& get(const tuple<Types...>& t) noexcept;
-template <class T, class... Types>
-  constexpr const T&& get(const tuple<Types...>&& t) noexcept;
-```
-*Requires:* The type `T` occurs exactly once in `Types...`. Otherwise,
-the program is ill-formed.
-*Returns:* A reference to the element of `t` corresponding to the type
-`T` in `Types...`.
-[*Example 1*:
-``` cpp
-const tuple<int, const int, double, double> t(1, 2, 3.4, 5.6);
-  const int& i1 = get<int>(t);        // OK. Not ambiguous. i1 == 1
-  const int& i2 = get<const int>(t);  // OK. Not ambiguous. i2 == 2
-  const double& d = get<double>(t);   // ERROR. ill-formed
-```
-— *end example*]
-[*Note 1*: The reason `get` is a non-member function is that if this
-functionality had been provided as a member function, code where the
-type depended on a template parameter would have required using the
-`template` keyword. — *end note*]
-#### Relational operators <a id="tuple.rel">[[tuple.rel]]</a>
-``` cpp
-template<class... TTypes, class... UTypes>
-  constexpr bool operator==(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
-```
-*Requires:* For all `i`, where `0 <= i` and `i < sizeof...(TTypes)`,
-`get<i>(t) == get<i>(u)` is a valid expression returning a type that is
-convertible to `bool`. `sizeof...(TTypes)` `==` `sizeof...(UTypes)`.
-*Returns:* `true` if `get<i>(t) == get<i>(u)` for all `i`, otherwise
-`false`. For any two zero-length tuples `e` and `f`, `e == f` returns
-`true`.
-*Effects:* The elementary comparisons are performed in order from the
-zeroth index upwards. No comparisons or element accesses are performed
-after the first equality comparison that evaluates to `false`.
-``` cpp
-template<class... TTypes, class... UTypes>
-  constexpr bool operator<(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
-```
-*Requires:* For all `i`, where `0 <= i` and `i < sizeof...(TTypes)`,
-both `get<i>(t) < get<i>(u)` and `get<i>(u) < get<i>(t)` are valid
-expressions returning types that are convertible to `bool`.
-`sizeof...(TTypes)` `==` `sizeof...(UTypes)`.
-*Returns:* The result of a lexicographical comparison between `t` and
-`u`. The result is defined as:
-`(bool)(get<0>(t) < get<0>(u)) || (!(bool)(get<0>(u) < get<0>(t)) && t`ₜₐᵢₗ` < u`ₜₐᵢₗ`)`,
-where `r`ₜₐᵢₗ for some tuple `r` is a tuple containing all but the first
-element of `r`. For any two zero-length tuples `e` and `f`, `e < f`
-returns `false`.
-``` cpp
-template<class... TTypes, class... UTypes>
-  constexpr bool operator!=(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
-```
-*Returns:* `!(t == u)`.
-``` cpp
-template<class... TTypes, class... UTypes>
-  constexpr bool operator>(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
-```
-*Returns:* `u < t`.
-``` cpp
-template<class... TTypes, class... UTypes>
-  constexpr bool operator<=(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
-```
-*Returns:* `!(u < t)`.
-``` cpp
-template<class... TTypes, class... UTypes>
-  constexpr bool operator>=(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
-```
-*Returns:* `!(t < u)`.
-[*Note 1*: The above definitions for comparison functions do not
-require `tₜₐᵢₗ` (or `uₜₐᵢₗ`) to be constructed. It may not even be
-possible, as `t` and `u` are not required to be copy constructible.
-Also, all comparison functions are short circuited; they do not perform
-element accesses beyond what is required to determine the result of the
-comparison. — *end note*]
-#### Tuple traits <a id="tuple.traits">[[tuple.traits]]</a>
-``` cpp
-template <class... Types, class Alloc>
-  struct uses_allocator<tuple<Types...>, Alloc> : true_type { };
-```
-*Requires:* `Alloc` shall be an
-`Allocator` ([[allocator.requirements]]).
-[*Note 1*: Specialization of this trait informs other library
-components that `tuple` can be constructed with an allocator, even
-though it does not have a nested `allocator_type`. — *end note*]
-#### Tuple specialized algorithms <a id="tuple.special">[[tuple.special]]</a>
-``` cpp
-template <class... Types>
-  void swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(see below);
-```
-*Remarks:* This function shall not participate in overload resolution
-unless `is_swappable_v<``Tᵢ``>` is `true` for all i, where
-0 ≤ i < `sizeof...(Types)`. The expression inside `noexcept` is
-equivalent to:
-``` cpp
-noexcept(x.swap(y))
-```
-*Effects:* As if by `x.swap(y)`.

 namespace std {
   template<class... Types>
   class tuple {
   public:
     // [tuple.cnstr], tuple construction
+ constexpr explicit(see below) tuple();
+ constexpr explicit(see below) tuple(const Types&...);         // only if sizeof...(Types) >= 1
     template<class... UTypes>
+ constexpr explicit(see below) tuple(UTypes&&...);           // only if sizeof...(Types) >= 1
     tuple(const tuple&) = default;
     tuple(tuple&&) = default;
     template<class... UTypes>
+ constexpr explicit(see below) tuple(const tuple<UTypes...>&);
     template<class... UTypes>
+ constexpr explicit(see below) tuple(tuple<UTypes...>&&);
     template<class U1, class U2>
+ constexpr explicit(see below) tuple(const pair<U1, U2>&);   // only if sizeof...(Types) == 2
     template<class U1, class U2>
+ constexpr explicit(see below) tuple(pair<U1, U2>&&);        // only if sizeof...(Types) == 2
     // allocator-extended constructors
     template<class Alloc>
+      constexpr explicit(see below)
         tuple(allocator_arg_t, const Alloc& a);
     template<class Alloc>
+      constexpr explicit(see below)
+        tuple(allocator_arg_t, const Alloc& a, const Types&...);
     template<class Alloc, class... UTypes>
+      constexpr explicit(see below)
+        tuple(allocator_arg_t, const Alloc& a, UTypes&&...);
     template<class Alloc>
+      constexpr tuple(allocator_arg_t, const Alloc& a, const tuple&);
     template<class Alloc>
+      constexpr tuple(allocator_arg_t, const Alloc& a, tuple&&);
     template<class Alloc, class... UTypes>
+      constexpr explicit(see below)
+        tuple(allocator_arg_t, const Alloc& a, const tuple<UTypes...>&);
     template<class Alloc, class... UTypes>
+      constexpr explicit(see below)
+        tuple(allocator_arg_t, const Alloc& a, tuple<UTypes...>&&);
     template<class Alloc, class U1, class U2>
+      constexpr explicit(see below)
+        tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&);
     template<class Alloc, class U1, class U2>
+      constexpr explicit(see below)
+        tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);
     // [tuple.assign], tuple assignment
+    constexpr tuple& operator=(const tuple&);
+    constexpr tuple& operator=(tuple&&) noexcept(see below);
     template<class... UTypes>
+      constexpr tuple& operator=(const tuple<UTypes...>&);
     template<class... UTypes>
+      constexpr tuple& operator=(tuple<UTypes...>&&);
     template<class U1, class U2>
+      constexpr tuple& operator=(const pair<U1, U2>&); // only if sizeof...(Types) == 2
     template<class U1, class U2>
+      constexpr tuple& operator=(pair<U1, U2>&&); // only if sizeof...(Types) == 2
     // [tuple.swap], tuple swap
+    constexpr void swap(tuple&) noexcept(see below);
   };
   template<class... UTypes>
     tuple(UTypes...) -> tuple<UTypes...>;
   template<class T1, class T2>
 }
 ```
 #### Construction <a id="tuple.cnstr">[[tuple.cnstr]]</a>
+In the descriptions that follow, let i be in the range \[`0`,
+`sizeof...(Types)`) in order, `Tᵢ` be the iᵗʰ type in `Types`, and `Uᵢ`
+be the iᵗʰ type in a template parameter pack named `UTypes`, where
+indexing is zero-based.
 For each `tuple` constructor, an exception is thrown only if the
 construction of one of the types in `Types` throws an exception.
+The defaulted move and copy constructor, respectively, of `tuple` is a
+constexpr function if and only if all required element-wise
+initializations for move and copy, respectively, would satisfy the
 requirements for a constexpr function. The defaulted move and copy
+constructor of `tuple<>` are constexpr functions.
+If `is_trivially_destructible_v<Tᵢ>` is `true` for all `Tᵢ`, then the
+destructor of `tuple` is trivial.
 ``` cpp
+constexpr explicit(see below) tuple();
 ```
+*Constraints:* `is_default_constructible_v<``Tᵢ``>` is `true` for all i.
 *Effects:* Value-initializes each element.
+*Remarks:* The expression inside `explicit` evaluates to `true` if and
+only if `Tᵢ` is not copy-list-initializable from an empty list for at
+least one i.
+[*Note 1*: This behavior can be implemented with a trait that checks
 whether a `const ``Tᵢ``&` can be initialized with `{}`. — *end note*]
 ``` cpp
+constexpr explicit(see below) tuple(const Types&...);
 ```
+*Constraints:* `sizeof...(Types)` ≥ 1 and
+`is_copy_constructible_v<``Tᵢ``>` is `true` for all i.
 *Effects:* Initializes each element with the value of the corresponding
 parameter.
+*Remarks:* The expression inside `explicit` is equivalent to:
 ``` cpp
+!conjunction_v<is_convertible<const Types&, Types>...>
 ```
+``` cpp
+template<class... UTypes> constexpr explicit(see below) tuple(UTypes&&... u);
+```
+*Constraints:* `sizeof...(Types)` equals `sizeof...(UTypes)` and
+`sizeof...(Types)` ≥ 1 and `is_constructible_v<``Tᵢ``, ``Uᵢ``>` is
+`true` for all i.
 *Effects:* Initializes the elements in the tuple with the corresponding
 value in `std::forward<UTypes>(u)`.
+*Remarks:* The expression inside `explicit` is equivalent to:
+``` cpp
+!conjunction_v<is_convertible<UTypes, Types>...>
+```
 ``` cpp
 tuple(const tuple& u) = default;
 ```
+*Mandates:* `is_copy_constructible_v<``Tᵢ``>` is `true` for all i.
 *Effects:* Initializes each element of `*this` with the corresponding
 element of `u`.
 ``` cpp
 tuple(tuple&& u) = default;
 ```
+*Constraints:* `is_move_constructible_v<``Tᵢ``>` is `true` for all i.
 *Effects:* For all i, initializes the iᵗʰ element of `*this` with
 `std::forward<``Tᵢ``>(get<`i`>(u))`.
 ``` cpp
+template<class... UTypes> constexpr explicit(see below) tuple(const tuple<UTypes...>& u);
 ```
+*Constraints:*
+- `sizeof...(Types)` equals `sizeof...(UTypes)` and
 - `is_constructible_v<``Tᵢ``, const ``Uᵢ``&>` is `true` for all i, and
+- either `sizeof...(Types)` is not 1, or (when `Types...` expands to `T`
+ and `UTypes...` expands to `U`)
+  `is_convertible_v<const tuple<U>&, T>`,
+ `is_constructible_v<T, const tuple<U>&>`, and `is_same_v<T, U>` are
+  all `false`.
+*Effects:* Initializes each element of `*this` with the corresponding
+element of `u`.
+*Remarks:* The expression inside `explicit` is equivalent to:
+``` cpp
+!conjunction_v<is_convertible<const UTypes&, Types>...>
+```
 ``` cpp
+template<class... UTypes> constexpr explicit(see below) tuple(tuple<UTypes...>&& u);
 ```
+*Constraints:*
+- `sizeof...(Types)` equals `sizeof...(UTypes)`, and
+- `is_constructible_v<``Tᵢ``, ``Uᵢ``>` is `true` for all i, and
+- either `sizeof...(Types)` is not 1, or (when `Types...` expands to `T`
+  and `UTypes...` expands to `U`) `is_convertible_v<tuple<U>, T>`,
+  `is_constructible_v<T, tuple<U>>`, and `is_same_v<T, U>` are all
+  `false`.
 *Effects:* For all i, initializes the iᵗʰ element of `*this` with
 `std::forward<``Uᵢ``>(get<`i`>(u))`.
+*Remarks:* The expression inside `explicit` is equivalent to:
+``` cpp
+!conjunction_v<is_convertible<UTypes, Types>...>
+```
 ``` cpp
+template<class U1, class U2> constexpr explicit(see below) tuple(const pair<U1, U2>& u);
 ```
+*Constraints:*
+- `sizeof...(Types)` is 2,
+- `is_constructible_v<``T₀``, const U1&>` is `true`, and
+- `is_constructible_v<``T₁``, const U2&>` is `true`.
 *Effects:* Initializes the first element with `u.first` and the second
 element with `u.second`.
+The expression inside `explicit` is equivalent to:
+``` cpp
+!is_convertible_v<const U1&, $T_0$> || !is_convertible_v<const U2&, $T_1$>
+```
 ``` cpp
+template<class U1, class U2> constexpr explicit(see below) tuple(pair<U1, U2>&& u);
 ```
+*Constraints:*
+- `sizeof...(Types)` is 2,
+- `is_constructible_v<``T₀``, U1>` is `true`, and
+- `is_constructible_v<``T₁``, U2>` is `true`.
 *Effects:* Initializes the first element with
 `std::forward<U1>(u.first)` and the second element with
 `std::forward<U2>(u.second)`.
+The expression inside `explicit` is equivalent to:
+``` cpp
+!is_convertible_v<U1, $T_0$> || !is_convertible_v<U2, $T_1$>
+```
 ``` cpp
 template<class Alloc>
+  constexpr explicit(see below)
     tuple(allocator_arg_t, const Alloc& a);
 template<class Alloc>
+ constexpr explicit(see below)
+    tuple(allocator_arg_t, const Alloc& a, const Types&...);
 template<class Alloc, class... UTypes>
+ constexpr explicit(see below)
+    tuple(allocator_arg_t, const Alloc& a, UTypes&&...);
 template<class Alloc>
+ constexpr tuple(allocator_arg_t, const Alloc& a, const tuple&);
 template<class Alloc>
+ constexpr tuple(allocator_arg_t, const Alloc& a, tuple&&);
 template<class Alloc, class... UTypes>
+ constexpr explicit(see below)
+    tuple(allocator_arg_t, const Alloc& a, const tuple<UTypes...>&);
 template<class Alloc, class... UTypes>
+ constexpr explicit(see below)
+    tuple(allocator_arg_t, const Alloc& a, tuple<UTypes...>&&);
 template<class Alloc, class U1, class U2>
+ constexpr explicit(see below)
+    tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&);
 template<class Alloc, class U1, class U2>
+ constexpr explicit(see below)
+    tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);
 ```
+*Preconditions:* `Alloc` meets the *Cpp17Allocator* requirements
+([[cpp17.allocator]]).
 *Effects:* Equivalent to the preceding constructors except that each
 element is constructed with uses-allocator
+construction [[allocator.uses.construction]].
 #### Assignment <a id="tuple.assign">[[tuple.assign]]</a>
 For each `tuple` assignment operator, an exception is thrown only if the
 assignment of one of the types in `Types` throws an exception. In the
 `sizeof...(Types)`) in order, `Tᵢ` be the iᵗʰ type in `Types`, and `Uᵢ`
 be the iᵗʰ type in a template parameter pack named `UTypes`, where
 indexing is zero-based.
 ``` cpp
+constexpr tuple& operator=(const tuple& u);
 ```
 *Effects:* Assigns each element of `u` to the corresponding element of
 `*this`.
+*Remarks:* This operator is defined as deleted unless
 `is_copy_assignable_v<``Tᵢ``>` is `true` for all i.
 *Returns:* `*this`.
 ``` cpp
+constexpr tuple& operator=(tuple&& u) noexcept(see below);
 ```
+*Constraints:* `is_move_assignable_v<``Tᵢ``>` is `true` for all i.
 *Effects:* For all i, assigns `std::forward<``Tᵢ``>(get<`i`>(u))` to
 `get<`i`>(*this)`.
 *Remarks:* The expression inside `noexcept` is equivalent to the logical
 <span class="smallcaps">and</span> of the following expressions:
 ``` cpp
 is_nothrow_move_assignable_v<Tᵢ>
 where Tᵢ is the iᵗʰ type in `Types`.
 *Returns:* `*this`.
 ``` cpp
+template<class... UTypes> constexpr tuple& operator=(const tuple<UTypes...>& u);
 ```
+*Constraints:*
+- `sizeof...(Types)` equals `sizeof...(UTypes)` and
+- `is_assignable_v<``Tᵢ``&, const ``Uᵢ``&>` is `true` for all i.
 *Effects:* Assigns each element of `u` to the corresponding element of
 `*this`.
 *Returns:* `*this`.
 ``` cpp
+template<class... UTypes> constexpr tuple& operator=(tuple<UTypes...>&& u);
 ```
+*Constraints:*
+- `sizeof...(Types)` equals `sizeof...(UTypes)` and
+- `is_assignable_v<``Tᵢ``&, ``Uᵢ``>` is `true` for all i.
 *Effects:* For all i, assigns `std::forward<``Uᵢ``>(get<`i`>(u))` to
 `get<`i`>(*this)`.
 *Returns:* `*this`.
 ``` cpp
+template<class U1, class U2> constexpr tuple& operator=(const pair<U1, U2>& u);
 ```
+*Constraints:*
+- `sizeof...(Types)` is 2 and
+- `is_assignable_v<``T₀``&, const U1&>` is `true`, and
+- `is_assignable_v<``T₁``&, const U2&>` is `true`.
 *Effects:* Assigns `u.first` to the first element of `*this` and
 `u.second` to the second element of `*this`.
 *Returns:* `*this`.
 ``` cpp
+template<class U1, class U2> constexpr tuple& operator=(pair<U1, U2>&& u);
 ```
+*Constraints:*
+- `sizeof...(Types)` is 2 and
+- `is_assignable_v<``T₀``&, U1>` is `true`, and
+- `is_assignable_v<``T₁``&, U2>` is `true`.
 *Effects:* Assigns `std::forward<U1>(u.first)` to the first element of
 `*this` and
 `std::forward<U2>(u.second)` to the second element of `*this`.
 *Returns:* `*this`.
 #### `swap` <a id="tuple.swap">[[tuple.swap]]</a>
 ``` cpp
+constexpr void swap(tuple& rhs) noexcept(see below);
 ```
+*Preconditions:* Each element in `*this` is swappable
+with [[swappable.requirements]] the corresponding element in `rhs`.
 *Effects:* Calls `swap` for each element in `*this` and its
 corresponding element in `rhs`.
 *Remarks:* The expression inside `noexcept` is equivalent to the logical
 where Tᵢ is the iᵗʰ type in `Types`.
 *Throws:* Nothing unless one of the element-wise `swap` calls throws an
 exception.

Diff to HTML by rtfpessoa