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

Files changed (1) hide show

tmp/tmpqrjmbwc9/{from.md → to.md} +283 -302

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

@@ -1,30 +1,32 @@
 ## Tuples <a id="tuple">[[tuple]]</a>
 ### In general <a id="tuple.general">[[tuple.general]]</a>
-This subclause describes the tuple library that provides a tuple type as
-the class template `tuple` that can be instantiated with any number of
-arguments. Each template argument specifies the type of an element in
-the `tuple`. Consequently, tuples are heterogeneous, fixed-size
-collections of values. An instantiation of `tuple` with two arguments is
-similar to an instantiation of `pair` with the same two arguments. See
-[[pairs]].
 ### Header `<tuple>` synopsis <a id="tuple.syn">[[tuple.syn]]</a>
 ``` cpp
 namespace std {
   // [tuple.tuple], class template tuple
   template<class... Types>
     class tuple;
   // [tuple.creation], tuple creation functions
   inline constexpr unspecified ignore;
   template<class... TTypes>
-    constexpr tuple<VTypes...> make_tuple(TTypes&&...);
   template<class... TTypes>
     constexpr tuple<TTypes&&...> forward_as_tuple(TTypes&&...) noexcept;
   template<class... TTypes>
@@ -39,24 +41,20 @@ namespace std {
   template<class T, class Tuple>
     constexpr T make_from_tuple(Tuple&& t);
   // [tuple.helper], tuple helper classes
-  template <class T> class tuple_size;                  // not defined
-  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>;
-  template <class... Types> class tuple_size<tuple<Types...>>;
-  template <size_t I, class T> class tuple_element;     // not defined
-  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>;
   template<size_t I, class... Types>
- class tuple_element<I, tuple<Types...>>;
   template<size_t I, class T>
     using tuple_element_t = typename tuple_element<I, T>::type;
   // [tuple.elem], element access
@@ -79,27 +77,20 @@ namespace std {
   // [tuple.rel], relational operators
   template<class... TTypes, class... UTypes>
     constexpr bool operator==(const tuple<TTypes...>&, const tuple<UTypes...>&);
   template<class... TTypes, class... UTypes>
-    constexpr bool operator<(const tuple<TTypes...>&, const tuple<UTypes...>&);
-  template<class... TTypes, class... UTypes>
-    constexpr bool operator!=(const tuple<TTypes...>&, const tuple<UTypes...>&);
-  template<class... TTypes, class... UTypes>
-    constexpr bool operator>(const tuple<TTypes...>&, const tuple<UTypes...>&);
-  template<class... TTypes, class... UTypes>
-    constexpr bool operator<=(const tuple<TTypes...>&, const tuple<UTypes...>&);
-  template<class... TTypes, class... UTypes>
-    constexpr bool operator>=(const tuple<TTypes...>&, const tuple<UTypes...>&);
   // [tuple.traits], allocator-related traits
   template<class... Types, class Alloc>
     struct uses_allocator<tuple<Types...>, Alloc>;
   // [tuple.special], specialized algorithms
   template<class... Types>
-    void swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(see below);
   // [tuple.helper], tuple helper classes
   template<class T>
     inline constexpr size_t tuple_size_v = tuple_size<T>::value;
 }
@@ -111,64 +102,71 @@ namespace std {
 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>
@@ -182,186 +180,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
@@ -369,31 +392,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ᵢ>
@@ -402,74 +424,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
@@ -482,27 +506,23 @@ 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;
@@ -518,14 +538,14 @@ 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>
@@ -556,22 +576,22 @@ template <class... Tuples>
 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
@@ -582,35 +602,35 @@ 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);
@@ -618,107 +638,98 @@ template <class T, class Tuple>
 *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;
@@ -730,25 +741,24 @@ template <size_t I, class... 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>
@@ -757,42 +767,41 @@ 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`.
@@ -800,85 +809,57 @@ convertible to `bool`. `sizeof...(TTypes)` `==` `sizeof...(UTypes)`.
 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))
 ```

 ## Tuples <a id="tuple">[[tuple]]</a>
 ### In general <a id="tuple.general">[[tuple.general]]</a>
+Subclause  [[tuple]] describes the tuple library that provides a tuple
+type as the class template `tuple` that can be instantiated with any
+number of arguments. Each template argument specifies the type of an
+element in the `tuple`. Consequently, tuples are heterogeneous,
+fixed-size collections of values. An instantiation of `tuple` with two
+arguments is similar to an instantiation of `pair` with the same two
+arguments. See  [[pairs]].
 ### Header `<tuple>` synopsis <a id="tuple.syn">[[tuple.syn]]</a>
 ``` cpp
+#include <compare>              // see [compare.syn]
 namespace std {
   // [tuple.tuple], class template tuple
   template<class... Types>
     class tuple;
   // [tuple.creation], tuple creation functions
   inline constexpr unspecified ignore;
   template<class... TTypes>
+    constexpr tuple<unwrap_ref_decay_t<TTypes>...> make_tuple(TTypes&&...);
   template<class... TTypes>
     constexpr tuple<TTypes&&...> forward_as_tuple(TTypes&&...) noexcept;
   template<class... TTypes>
   template<class T, class Tuple>
     constexpr T make_from_tuple(Tuple&& t);
   // [tuple.helper], tuple helper classes
+  template<class T> struct tuple_size;                  // not defined
+  template<class T> struct tuple_size<const T>;
+  template<class... Types> struct tuple_size<tuple<Types...>>;
+  template<size_t I, class T> struct tuple_element;     // not defined
+  template<size_t I, class T> struct tuple_element<I, const T>;
   template<size_t I, class... Types>
+ struct tuple_element<I, tuple<Types...>>;
   template<size_t I, class T>
     using tuple_element_t = typename tuple_element<I, T>::type;
   // [tuple.elem], element access
   // [tuple.rel], relational operators
   template<class... TTypes, class... UTypes>
     constexpr bool operator==(const tuple<TTypes...>&, const tuple<UTypes...>&);
   template<class... TTypes, class... UTypes>
+    constexpr common_comparison_category_t<synth-three-way-result<TTypes, UTypes>...>
+      operator<=>(const tuple<TTypes...>&, const tuple<UTypes...>&);
   // [tuple.traits], allocator-related traits
   template<class... Types, class Alloc>
     struct uses_allocator<tuple<Types...>, Alloc>;
   // [tuple.special], specialized algorithms
   template<class... Types>
+ constexpr void swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(see below);
   // [tuple.helper], tuple helper classes
   template<class T>
     inline constexpr size_t tuple_size_v = tuple_size<T>::value;
 }
 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.
+### Tuple creation functions <a id="tuple.creation">[[tuple.creation]]</a>
+In the function descriptions that follow, the members of a template
+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<unwrap_ref_decay_t<TTypes>...> make_tuple(TTypes&&... t);
 ```
+*Returns:*
+`tuple<unwrap_ref_decay_t<TTypes>...>(std::forward<TTypes>(t)...)`.
 [*Example 1*:
 ``` cpp
 int i; float j;
   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 objects, 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>
 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.
+*Preconditions:* For all i, `Uᵢ` is the type cvᵢ `tuple<``Argsᵢ``...>`,
 where cvᵢ is the (possibly empty) iᵗʰ *cv-qualifier-seq* and `Argsᵢ` is
+the template parameter pack representing the element types in `Uᵢ`. Let
+`A_ik` be the kᵗʰ type in `Argsᵢ`. For all `A_ik` the following
+requirements are met:
 - 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` are 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
 ```
 for each valid kᵢ and each group `eᵢ` in order.
 [*Note 1*: An implementation may support additional types in the
+template 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))...);  // see [func.require]
 }
 ```
 Equivalent to:
 ``` cpp
+return apply-impl(std::forward<F>(f), std::forward<Tuple>(t),
+                  make_index_sequence<tuple_size_v<remove_reference_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<remove_reference_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;
 ```
+All specializations of `tuple_size` meet the *Cpp17UnaryTypeTrait*
+requirements [[meta.rqmts]] with a base characteristic of
+`integral_constant<size_t, N>` for some `N`.
 ``` cpp
 template<class... Types>
+ struct tuple_size<tuple<Types...>> : public integral_constant<size_t, sizeof...(Types)> { };
 ```
 ``` cpp
 template<size_t I, class... Types>
+ struct tuple_element<I, tuple<Types...>> {
     using type = TI;
   };
 ```
+*Mandates:* `I` < `sizeof...(Types)`.
+*Type:* `TI` is the type of the `I`ᵗʰ element of `Types`, where indexing
 is zero-based.
 ``` cpp
+template<class T> struct tuple_size<const 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 specialization of the template meets the
+*Cpp17UnaryTypeTrait* requirements [[meta.rqmts]] with a base
 characteristic of
 ``` cpp
 integral_constant<size_t, TS::value>
 ```
+Otherwise, it has 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 template is available when any of the headers `<array>`, `<ranges>`,
 or `<utility>` are included.
 ``` cpp
+template<size_t I, class T> struct tuple_element<I, const T>;
 ```
+Let `TE` denote `tuple_element_t<I, T>` of the cv-unqualified type `T`.
+Then each specialization of the template meets the
+*Cpp17TransformationTrait* requirements [[meta.rqmts]] with a member
+typedef `type` that names the type `add_const_t<TE>`.
 In addition to being available via inclusion of the `<tuple>` header,
+the template is available when any of the headers `<array>`, `<ranges>`,
 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;
     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;
 ```
+*Mandates:* `I` < `sizeof...(Types)`.
+*Returns:* A reference to the `I`ᵗʰ element of `t`, where indexing is
 zero-based.
+[*Note 1*: \[Note A\]If a type `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 type `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 const T& get(const tuple<Types...>& t) noexcept;
 template<class T, class... Types>
   constexpr const T&& get(const tuple<Types...>&& t) noexcept;
 ```
+*Mandates:* The type `T` occurs exactly once in `Types`.
 *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, i1 has value 1
+const int& i2 = get<const int>(t); // OK, i2 has value 2
+const double& d = get<double>(t); // error: type double is not unique within t
 ```
 — *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);
 ```
+*Mandates:* For all `i`, where 0 ≤ `i` < `sizeof...(TTypes)`,
 `get<i>(t) == get<i>(u)` is a valid expression returning a type that is
+convertible to `bool`. `sizeof...(TTypes)` equals `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`.
 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 common_comparison_category_t<synth-three-way-result<TTypes, UTypes>...>
+    operator<=>(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
 ```
+*Effects:* Performs a lexicographical comparison between `t` and `u`.
+For any two zero-length tuples `t` and `u`, `t <=> u` returns
+`strong_ordering::equal`. Otherwise, equivalent to:
 ``` cpp
+if (auto c = synth-three-way(get<0>(t), get<0>(u)); c != 0) return c;
+return $t_tail$ <=> $u_tail$;
 ```
+where `r_tail` for some tuple `r` is a tuple containing all but the
+first element of `r`.
+[*Note 1*: The above definition does 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 { };
 ```
+*Preconditions:* `Alloc` meets the *Cpp17Allocator* requirements
+([[cpp17.allocator]]).
 [*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>
+ constexpr void swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(see below);
 ```
+*Constraints:* `is_swappable_v<T>` is `true` for every type `T` in
+`Types`.
+*Remarks:* The expression inside `noexcept` is equivalent to:
 ``` cpp
 noexcept(x.swap(y))
 ```

Diff to HTML by rtfpessoa