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

Files changed (1) hide show

tmp/tmpf7a48v0o/{from.md → to.md} +484 -147

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

@@ -11,17 +11,32 @@ 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&&...);
@@ -30,18 +45,18 @@ namespace std {
     constexpr tuple<TTypes&&...> forward_as_tuple(TTypes&&...) noexcept;
   template<class... TTypes>
     constexpr tuple<TTypes&...> tie(TTypes&...) noexcept;
-  template<class... Tuples>
     constexpr tuple<CTypes...> tuple_cat(Tuples&&...);
   // [tuple.apply], calling a function with a tuple of arguments
-  template<class F, class Tuple>
-    constexpr decltype(auto) apply(F&& f, Tuple&& t);
-  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>;
@@ -76,28 +91,45 @@ namespace std {
     constexpr const T&& get(const tuple<Types...>&& t) noexcept;
   // [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;
 }
 ```
 ### Class template `tuple` <a id="tuple.tuple">[[tuple.tuple]]</a>
 ``` cpp
 namespace std {
   template<class... Types>
@@ -110,19 +142,30 @@ namespace std {
       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);
@@ -134,39 +177,71 @@ namespace std {
         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>
@@ -190,17 +265,19 @@ 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.
@@ -232,23 +309,43 @@ parameter.
 ``` 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.
@@ -264,91 +361,108 @@ tuple(tuple&& u) = default;
 *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)
@@ -361,26 +475,41 @@ template<class Alloc, class... UTypes>
     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]].
@@ -398,13 +527,24 @@ 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);
 ```
@@ -412,19 +552,31 @@ 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);
 ```
@@ -437,10 +589,24 @@ template<class... UTypes> constexpr tuple& operator=(const tuple<UTypes...>& u);
 *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:*
@@ -451,10 +617,24 @@ template<class... UTypes> constexpr tuple& operator=(tuple<UTypes...>&& u);
 *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:*
@@ -466,10 +646,25 @@ template<class U1, class U2> constexpr 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`.
 *Returns:* `*this`.
 ``` cpp
 template<class U1, class U2> constexpr tuple& operator=(pair<U1, U2>&& u);
 ```
 *Constraints:*
@@ -482,40 +677,96 @@ template<class U1, class U2> constexpr tuple& operator=(pair<U1, U2>&& u);
 `*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
-<span class="smallcaps">and</span> of the following expressions:
-``` cpp
-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 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);
 ```
@@ -524,11 +775,11 @@ template<class... TTypes>
 [*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*]
@@ -568,90 +819,96 @@ tie(i, ignore, s) = make_tuple(42, 3.14, "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.
-*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
-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
-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
@@ -688,13 +945,13 @@ is zero-based.
 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>
 ```
@@ -754,11 +1011,11 @@ 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>
@@ -793,75 +1050,155 @@ type depended on a template parameter would have required using the
 ### 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`.
-*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 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))
-```
 *Effects:* As if by `x.swap(y)`.

 arguments. See  [[pairs]].
 ### Header `<tuple>` synopsis <a id="tuple.syn">[[tuple.syn]]</a>
 ``` cpp
+// all freestanding
 #include <compare>              // see [compare.syn]
 namespace std {
   // [tuple.tuple], class template tuple
   template<class... Types>
     class tuple;
+  // [tuple.like], concept tuple-like
+  template<class T>
+    concept tuple-like = see belownc;         // exposition only
+  template<class T>
+    concept pair-like =                     // exposition only
+      tuple-like<T> && tuple_size_v<remove_cvref_t<T>> == 2;
+  // [tuple.common.ref], common_reference related specializations
+  template<exposition onlyconceptnc{tuple-like} TTuple, exposition onlyconceptnc{tuple-like} UTuple,
+           template<class> class TQual, template<class> class UQual>
+    struct basic_common_reference<TTuple, UTuple, TQual, UQual>;
+  template<exposition onlyconceptnc{tuple-like} TTuple, exposition onlyconceptnc{tuple-like} UTuple>
+    struct common_type<TTuple, UTuple>;
   // [tuple.creation], tuple creation functions
   inline constexpr unspecified ignore;
   template<class... TTypes>
     constexpr tuple<unwrap_ref_decay_t<TTypes>...> make_tuple(TTypes&&...);
     constexpr tuple<TTypes&&...> forward_as_tuple(TTypes&&...) noexcept;
   template<class... TTypes>
     constexpr tuple<TTypes&...> tie(TTypes&...) noexcept;
+  template<exposition onlyconceptnc{tuple-like}... Tuples>
     constexpr tuple<CTypes...> tuple_cat(Tuples&&...);
   // [tuple.apply], calling a function with a tuple of arguments
+  template<class F, exposition onlyconceptnc{tuple-like} Tuple>
+    constexpr decltype(auto) apply(F&& f, Tuple&& t) noexcept(see below);
+  template<class T, exposition onlyconceptnc{tuple-like} 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>;
     constexpr const T&& get(const tuple<Types...>&& t) noexcept;
   // [tuple.rel], relational operators
   template<class... TTypes, class... UTypes>
     constexpr bool operator==(const tuple<TTypes...>&, const tuple<UTypes...>&);
+  template<class... TTypes, exposition onlyconceptnc{tuple-like} UTuple>
+    constexpr bool operator==(const tuple<TTypes...>&, const UTuple&);
   template<class... TTypes, class... UTypes>
     constexpr common_comparison_category_t<synth-three-way-result<TTypes, UTypes>...>
       operator<=>(const tuple<TTypes...>&, const tuple<UTypes...>&);
+  template<class... TTypes, exposition onlyconceptnc{tuple-like} UTuple>
+    constexpr see belownc operator<=>(const tuple<TTypes...>&, const UTuple&);
   // [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);
+  template<class... Types>
+    constexpr void swap(const tuple<Types...>& x, const tuple<Types...>& y) noexcept(see below);
   // [tuple.helper], tuple helper classes
   template<class T>
+    constexpr size_t tuple_size_v@ = tuple_size<T>::value;
 }
 ```
+### Concept  <a id="tuple.like">[[tuple.like]]</a>
+``` cpp
+template<class T>
+  concept tuple-like = see belownc;           // exposition only
+```
+A type `T` models and satisfies the exposition-only concept `tuple-like`
+if `remove_cvref_t<T>` is a specialization of `array`, `pair`, `tuple`,
+or `ranges::subrange`.
 ### Class template `tuple` <a id="tuple.tuple">[[tuple.tuple]]</a>
 ``` cpp
 namespace std {
   template<class... Types>
       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(tuple<UTypes...>&);
     template<class... UTypes>
       constexpr explicit(see below) tuple(const tuple<UTypes...>&);
     template<class... UTypes>
       constexpr explicit(see below) tuple(tuple<UTypes...>&&);
+    template<class... UTypes>
+      constexpr explicit(see below) tuple(const tuple<UTypes...>&&);
+    template<class U1, class U2>
+      constexpr explicit(see below) tuple(pair<U1, U2>&);         // only if sizeof...(Types) == 2
     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
+    template<class U1, class U2>
+      constexpr explicit(see below) tuple(const pair<U1, U2>&&);  // only if sizeof...(Types) == 2
+    template<tuple-like UTuple>
+      constexpr explicit(see below) tuple(UTuple&&);
     // allocator-extended constructors
     template<class Alloc>
       constexpr explicit(see below)
         tuple(allocator_arg_t, const Alloc& a);
         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, tuple<UTypes...>&);
     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... UTypes>
+      constexpr explicit(see below)
+        tuple(allocator_arg_t, const Alloc& a, const tuple<UTypes...>&&);
+    template<class Alloc, class U1, class U2>
+      constexpr explicit(see below)
+        tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&);
     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>&&);
+    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, exposition onlyconceptnc{tuple-like} UTuple>
+      constexpr explicit(see below) tuple(allocator_arg_t, const Alloc& a, UTuple&&);
     // [tuple.assign], tuple assignment
     constexpr tuple& operator=(const tuple&);
+    constexpr const tuple& operator=(const tuple&) const;
     constexpr tuple& operator=(tuple&&) noexcept(see below);
+    constexpr const tuple& operator=(tuple&&) const;
     template<class... UTypes>
       constexpr tuple& operator=(const tuple<UTypes...>&);
+    template<class... UTypes>
+      constexpr const tuple& operator=(const tuple<UTypes...>&) const;
     template<class... UTypes>
       constexpr tuple& operator=(tuple<UTypes...>&&);
+    template<class... UTypes>
+      constexpr const tuple& operator=(tuple<UTypes...>&&) const;
     template<class U1, class U2>
       constexpr tuple& operator=(const pair<U1, U2>&);          // only if sizeof...(Types) == 2
+    template<class U1, class U2>
+      constexpr const tuple& operator=(const pair<U1, U2>&) const;
+                                                                // only if sizeof...(Types) == 2
     template<class U1, class U2>
       constexpr tuple& operator=(pair<U1, U2>&&);               // only if sizeof...(Types) == 2
+    template<class U1, class U2>
+      constexpr const tuple& operator=(pair<U1, U2>&&) const;   // only if sizeof...(Types) == 2
+    template<exposition onlyconceptnc{tuple-like} UTuple>
+      constexpr tuple& operator=(UTuple&&);
+    template<exposition onlyconceptnc{tuple-like}@ UTuple>
+      constexpr const tuple& operator=(UTuple&&) const;
     // [tuple.swap], tuple swap
     constexpr void swap(tuple&) noexcept(see below);
+    constexpr void swap(const tuple&) const noexcept(see below);
   };
   template<class... UTypes>
     tuple(UTypes...) -> tuple<UTypes...>;
   template<class T1, class T2>
 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 be
+constexpr-suitable [[dcl.constexpr]]. 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.
+The default constructor of `tuple<>` is trivial.
 ``` cpp
 constexpr explicit(see below) tuple();
 ```
 *Constraints:* `is_default_constructible_v<``Tᵢ``>` is `true` for all i.
 ``` cpp
 template<class... UTypes> constexpr explicit(see below) tuple(UTypes&&... u);
 ```
+Let *disambiguating-constraint* be:
+- `negation<is_same<remove_cvref_t<``U₀``>, tuple>>` if
+  `sizeof...(Types)` is 1;
+- otherwise,
+  `bool_constant<!is_same_v<remove_cvref_t<``U₀``>, allocator_arg_t> || is_- same_v<remove_cvref_t<``T₀``>, allocator_arg_t>>`
+  if `sizeof...(Types)` is 2 or 3;
+- otherwise, `true_type`.
+*Constraints:*
+- `sizeof...(Types)` equals `sizeof...(UTypes)`,
+- `sizeof...(Types)` ≥ 1, and
+- `conjunction_v<`*`disambiguating-constraint`*`, is_constructible<Types, UTypes>...>`
+  is `true`.
 *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>...>
 ```
+This constructor is defined as deleted if
+``` cpp
+(reference_constructs_from_temporary_v<Types, UTypes&&> || ...)
+```
+is `true`.
 ``` cpp
 tuple(const tuple& u) = default;
 ```
 *Mandates:* `is_copy_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(tuple<UTypes...>& u);
 template<class... UTypes> constexpr explicit(see below) tuple(const tuple<UTypes...>& u);
 template<class... UTypes> constexpr explicit(see below) tuple(tuple<UTypes...>&& u);
+template<class... UTypes> constexpr explicit(see below) tuple(const tuple<UTypes...>&& u);
 ```
+Let `I` be the pack `0, 1, ..., (sizeof...(Types) - 1)`. Let
+*`FWD`*`(u)` be `static_cast<decltype(u)>(u)`.
 *Constraints:*
 - `sizeof...(Types)` equals `sizeof...(UTypes)`, and
+- `(is_constructible_v<Types, decltype(get<I>(`*`FWD`*`(u)))> && ...)`
+  is `true`, and
 - either `sizeof...(Types)` is not 1, or (when `Types...` expands to `T`
+  and `UTypes...` expands to `U`) `is_convertible_v<decltype(u), T>`,
+  `is_constructible_v<T, decltype(u)>`, and `is_same_v<T, U>` are all
   `false`.
+*Effects:* For all i, initializes the $i^\textrm{th}$ element of `*this`
+with `get<`i`>(`*`FWD`*`(u))`.
 *Remarks:* The expression inside `explicit` is equivalent to:
 ``` cpp
+!(is_convertible_v<decltype(get<I>(FWD(u))), Types> && ...)
 ```
+The constructor is defined as deleted if
+``` cpp
+(reference_constructs_from_temporary_v<Types, decltype(get<I>(FWD(u)))> || ...)
+```
+is `true`.
 ``` cpp
+template<class U1, class U2> constexpr explicit(see below) tuple(pair<U1, U2>& u);
 template<class U1, class U2> constexpr explicit(see below) tuple(const pair<U1, U2>& u);
 template<class U1, class U2> constexpr explicit(see below) tuple(pair<U1, U2>&& u);
+template<class U1, class U2> constexpr explicit(see below) tuple(const pair<U1, U2>&& u);
 ```
+Let *`FWD`*`(u)` be `static_cast<decltype(u)>(u)`.
 *Constraints:*
 - `sizeof...(Types)` is 2,
+- `is_constructible_v<``T₀``, decltype(get<0>(`*`FWD`*`(u)))>` is
+ `true`, and
+- `is_constructible_v<``T₁``, decltype(get<1>(`*`FWD`*`(u)))>` is
+  `true`.
+*Effects:* Initializes the first element with `get<0>(`*`FWD`*`(u))` and
+the second element with `get<1>(`*`FWD`*`(u))`.
+*Remarks:* The expression inside `explicit` is equivalent to:
 ``` cpp
+!is_convertible_v<decltype(get<0>(FWD(u))), $T_0$> ||
+!is_convertible_v<decltype(get<1>(FWD(u))), $T_1$>
+```
+The constructor is defined as deleted if
+``` cpp
+reference_constructs_from_temporary_v<$T_0$, decltype(get<0>(FWD(u)))> ||
+reference_constructs_from_temporary_v<$T_1$, decltype(get<1>(FWD(u)))>
+```
+is `true`.
+``` cpp
+template<tuple-like UTuple>
+  constexpr explicit(see below) tuple(UTuple&& u);
+```
+Let `I` be the pack `0, 1, …, (sizeof...(Types) - 1)`.
+*Constraints:*
+- `different-from<UTuple, tuple>` [[range.utility.helpers]] is `true`,
+- `remove_cvref_t<UTuple>` is not a specialization of
+  `ranges::subrange`,
+- `sizeof...(Types)` equals `tuple_size_v<remove_cvref_t<UTuple>>`,
+- `(is_constructible_v<Types, decltype(get<I>(std::forward<UTuple>(u)))> && ...)`
+  is `true`, and
+- either `sizeof...(Types)` is not `1`, or (when `Types...` expands to
+  `T`) `is_convertible_v<UTuple, T>` and `is_constructible_v<T, UTuple>`
+  are both `false`.
+*Effects:* For all i, initializes the iᵗʰ element of `*this` with
+`get<`i`>(std::forward<UTuple>(u))`.
+*Remarks:* The expression inside `explicit` is equivalent to:
+``` cpp
+!(is_convertible_v<decltype(get<I>(std::forward<UTuple>(u))), Types> && ...)
 ```
 ``` cpp
 template<class Alloc>
   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, tuple<UTypes...>&);
 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... UTypes>
+  constexpr explicit(see below)
+    tuple(allocator_arg_t, const Alloc& a, const tuple<UTypes...>&&);
+template<class Alloc, class U1, class U2>
+  constexpr explicit(see below)
+    tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&);
 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>&&);
+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, tuple-like UTuple>
+  constexpr explicit(see below)
+    tuple(allocator_arg_t, const Alloc& a, UTuple&&);
 ```
+*Preconditions:* `Alloc` meets the *Cpp17Allocator*
+requirements [[allocator.requirements.general]].
 *Effects:* Equivalent to the preceding constructors except that each
 element is constructed with uses-allocator
 construction [[allocator.uses.construction]].
 ```
 *Effects:* Assigns each element of `u` to the corresponding element of
 `*this`.
+*Returns:* `*this`.
 *Remarks:* This operator is defined as deleted unless
 `is_copy_assignable_v<``Tᵢ``>` is `true` for all i.
+``` cpp
+constexpr const tuple& operator=(const tuple& u) const;
+```
+*Constraints:* `(is_copy_assignable_v<const Types> && ...)` is `true`.
+*Effects:* Assigns each element of `u` to the corresponding element of
+`*this`.
 *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)`.
+*Returns:* `*this`.
+*Remarks:* The exception specification is equivalent to the logical of
+the following expressions:
 ``` cpp
 is_nothrow_move_assignable_v<Tᵢ>
 ```
 where Tᵢ is the iᵗʰ type in `Types`.
+``` cpp
+constexpr const tuple& operator=(tuple&& u) const;
+```
+*Constraints:* `(is_assignable_v<const Types&, Types> && ...)` is
+`true`.
+*Effects:* For all i, assigns `std::forward<T`ᵢ`>(get<`i`>(u))` to
+`get<`i`>(*this)`.
 *Returns:* `*this`.
 ``` cpp
 template<class... UTypes> constexpr tuple& operator=(const tuple<UTypes...>& u);
 ```
 *Effects:* Assigns each element of `u` to the corresponding element of
 `*this`.
 *Returns:* `*this`.
+``` cpp
+template<class... UTypes> constexpr const tuple& operator=(const tuple<UTypes...>& u) const;
+```
+*Constraints:*
+- `sizeof...(Types)` equals `sizeof...(UTypes)` and
+- `(is_assignable_v<const Types&, const UTypes&> && ...)` is `true`.
+*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:*
 *Effects:* For all i, assigns `std::forward<``Uᵢ``>(get<`i`>(u))` to
 `get<`i`>(*this)`.
 *Returns:* `*this`.
+``` cpp
+template<class... UTypes> constexpr const tuple& operator=(tuple<UTypes...>&& u) const;
+```
+*Constraints:*
+- `sizeof...(Types)` equals `sizeof...(UTypes)` and
+- `(is_assignable_v<const Types&, UTypes> && ...)` is `true`.
+*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:*
 *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 const tuple& operator=(const pair<U1, U2>& u) const;
+```
+*Constraints:*
+- `sizeof...(Types)` is 2,
+- `is_assignable_v<const ``T₀``&, const U1&>` is `true`, and
+- `is_assignable_v<const ``T₁``&, const U2&>` is `true`.
+*Effects:* Assigns `u.first` to the first element and `u.second` to the
+second element.
+*Returns:* `*this`.
 ``` cpp
 template<class U1, class U2> constexpr tuple& operator=(pair<U1, U2>&& u);
 ```
 *Constraints:*
 `*this` and
 `std::forward<U2>(u.second)` to the second element of `*this`.
 *Returns:* `*this`.
+``` cpp
+template<class U1, class U2> constexpr const tuple& operator=(pair<U1, U2>&& u) const;
+```
+*Constraints:*
+- `sizeof...(Types)` is 2,
+- `is_assignable_v<const ``T₀``&, U1>` is `true`, and
+- `is_assignable_v<const ``T₁``&, U2>` is `true`.
+*Effects:* Assigns `std::forward<U1>(u.first)` to the first element
+and
+`std::forward<U2>(u.second)` to the second element.
+*Returns:* `*this`.
+``` cpp
+template<tuple-like UTuple>
+  constexpr tuple& operator=(UTuple&& u);
+```
+*Constraints:*
+- `different-from<UTuple, tuple>` [[range.utility.helpers]] is `true`,
+- `remove_cvref_t<UTuple>` is not a specialization of
+  `ranges::subrange`,
+- `sizeof...(Types)` equals `tuple_size_v<remove_cvref_t<UTuple>>`, and,
+- `is_assignable_v<``Tᵢ``&, decltype(get<`i`>(std::forward<UTuple>(u)))>`
+  is `true` for all i.
+*Effects:* For all i, assigns `get<`i`>(std::forward<UTuple>(u))` to
+`get<`i`>(*this)`.
+*Returns:* `*this`.
+``` cpp
+template<tuple-like UTuple>
+  constexpr const tuple& operator=(UTuple&& u) const;
+```
+*Constraints:*
+- `different-from<UTuple, tuple>` [[range.utility.helpers]] is `true`,
+- `remove_cvref_t<UTuple>` is not a specialization of
+  `ranges::subrange`,
+- `sizeof...(Types)` equals `tuple_size_v<remove_cvref_t<UTuple>>`, and,
+- `is_assignable_v<const ``Tᵢ``&, decltype(get<`i`>(std::forward<UTuple>(u)))>`
+  is `true` for all i.
+*Effects:* For all i, assigns `get<`i`>(std::forward<UTuple>(u))` to
+`get<`i`>(*this)`.
+*Returns:* `*this`.
 #### `swap` <a id="tuple.swap">[[tuple.swap]]</a>
 ``` cpp
 constexpr void swap(tuple& rhs) noexcept(see below);
+constexpr void swap(const tuple& rhs) const noexcept(see below);
 ```
+Let i be in the range \[`0`, `sizeof...(Types)`) in order.
+*Mandates:*
+- For the first overload, `(is_swappable_v<Types> && ...)` is `true`.
+- For the second overload, `(is_swappable_v<const Types> && ...)` is
+  `true`.
+*Preconditions:* For all i, `get<`i`>(*this)` is swappable
+with [[swappable.requirements]] `get<`i`>(rhs)`.
+*Effects:* For each i, calls `swap` for `get<`i`>(*this)` with
+`get<`i`>(rhs)`.
 *Throws:* Nothing unless one of the element-wise `swap` calls throws an
 exception.
+*Remarks:* The exception specification is equivalent to
+- `(is_nothrow_swappable_v<Types> && ...)` for the first overload and
+- `(is_nothrow_swappable_v<const Types> && ...)` for the second
+  overload.
 ### Tuple creation functions <a id="tuple.creation">[[tuple.creation]]</a>
 ``` cpp
 template<class... TTypes>
   constexpr tuple<unwrap_ref_decay_t<TTypes>...> make_tuple(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*]
 ```
 — *end example*]
 ``` cpp
+template<tuple-like... Tuples>
   constexpr tuple<CTypes...> tuple_cat(Tuples&&... tpls);
 ```
+Let n be `sizeof...(Tuples)`. For every integer 0 ≤ i < n:
+- Let `Tᵢ` be the iᵗʰ type in `Tuples`.
+- Let `Uᵢ` be `remove_cvref_t<``Tᵢ``>`.
+- Let `tpᵢ` be the iᵗʰ element in the function parameter pack `tpls`.
+- Let Sᵢ be `tuple_size_v<``Uᵢ``>`.
+- Let Eᵢᵏ be `tuple_element_t<`k`, ``Uᵢ``>`.
+- Let eᵢᵏ be `get<`k`>(std::forward<``Tᵢ``>(``tpᵢ``))`.
+- Let Elemsᵢ be a pack of the types $E_i^0, \dotsc, E_i^{S_{i-1}}$.
+- Let elemsᵢ be a pack of the expressions
+  $e_i^0, \dotsc, e_i^{S_{i-1}}$.
+The types in `CTypes` are equal to the ordered sequence of the expanded
+packs of types Elems₀`...`, Elems₁`...`, …, Elemsₙ₋₁`...`. Let `celems`
+be the ordered sequence of the expanded packs of expressions
+elems₀`...`, …, elemsₙ₋₁`...`.
+*Mandates:* `(is_constructible_v<CTypes, decltype(celems)> && ...)` is
+`true`.
+*Returns:* `tuple<CTypes...>(celems...)`.
 ### Calling a function with a `tuple` of arguments <a id="tuple.apply">[[tuple.apply]]</a>
 ``` cpp
+template<class F, tuple-like Tuple>
+  constexpr decltype(auto) apply(F&& f, Tuple&& t) noexcept(see below);
 ```
 *Effects:* Given the exposition-only function:
 ``` cpp
+namespace std {
+  template<class F, tuple-like Tuple, size_t... I>
   constexpr decltype(auto) apply-impl(F&& f, Tuple&& t, index_sequence<I...>) {
                                                                         // exposition only
+ return INVOKE(std::forward<F>(f), 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>>>{});
 ```
+*Remarks:* Let `I` be the pack
+`0, 1, ..., (tuple_size_v<remove_reference_t<Tuple>> - 1)`. The
+exception specification is equivalent to:
 ``` cpp
+noexcept(invoke(std::forward<F>(f), get<I>(std::forward<Tuple>(t))...))
+```
+``` cpp
+template<class T, tuple-like Tuple>
   constexpr T make_from_tuple(Tuple&& t);
 ```
+*Mandates:* If `tuple_size_v<remove_reference_t<Tuple>>` is 1, then
+`reference_constructs_from_temporary_v<T, decltype(get<0>(declval<Tuple>()))>`
+is `false`.
 *Effects:* Given the exposition-only function:
 ``` cpp
+namespace std {
+  template<class T, tuple-like Tuple, size_t... I>
+    requires is_constructible_v<T, decltype(get<I>(declval<Tuple>()))...>
   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>(
+ std::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
 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 [[term.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>
 ```
 [*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 non-static data members of reference type. — *end note*]
 ``` cpp
 template<class T, class... Types>
   constexpr T& get(tuple<Types...>& t) noexcept;
 template<class T, class... Types>
 ### 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);
+template<class... TTypes, tuple-like UTuple>
+  constexpr bool operator==(const tuple<TTypes...>& t, const UTuple& u);
 ```
+For the first overload let `UTuple` be `tuple<UTypes...>`.
 *Mandates:* For all `i`, where 0 ≤ `i` < `sizeof...(TTypes)`,
+`get<i>(t) == get<i>(u)` is a valid expression. `sizeof...(TTypes)`
+equals `tuple_size_v<UTuple>`.
+*Preconditions:* For all `i`, `decltype(get<i>(t) == get<i>(u))` models
+`boolean-testable`.
 *Returns:* `true` if `get<i>(t) == get<i>(u)` for all `i`, otherwise
+`false`.
+[*Note 1*: If `sizeof...(TTypes)` equals zero, returns
+`true`. — *end note*]
+*Remarks:*
+- 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`.
+- The second overload is to be found via argument-dependent
+  lookup [[basic.lookup.argdep]] only.
 ``` 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);
+template<class... TTypes, tuple-like UTuple>
+  constexpr common_comparison_category_t<synth-three-way-result<TTypes, Elems>...>
+    operator<=>(const tuple<TTypes...>& t, const UTuple& u);
 ```
+For the second overload, `Elems` denotes the pack of types
+`tuple_element_t<0, UTuple>`, `tuple_element_t<1, UTuple>`, …,
+`tuple_element_t<tuple_size_v<UTuple> - 1, UTuple>`.
+*Effects:* Performs a lexicographical comparison between `t` and `u`. If
+`sizeof...(TTypes)` equals zero, 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 `r` is a tuple containing all but the first
+element of `r`.
+*Remarks:* The second overload is to be found via argument-dependent
+lookup [[basic.lookup.argdep]] only.
 [*Note 1*: The above definition does not require `tₜₐᵢₗ` (or `uₜₐᵢₗ`)
+to be constructed. It might not even be possible, as `t` and `u` are not
+required to be copy constructible. Also, all comparison operator
+functions are short circuited; they do not perform element accesses
+beyond what is required to determine the result of the
+comparison. — *end note*]
+### `common_reference` related specializations <a id="tuple.common.ref">[[tuple.common.ref]]</a>
+In the descriptions that follow:
+- Let `TTypes` be a pack formed by the sequence of
+  `tuple_element_t<i, TTuple>` for every integer
+  0 ≤ i < `tuple_size_v<TTuple>`.
+- Let `UTypes` be a pack formed by the sequence of
+  `tuple_element_t<i, UTuple>` for every integer
+  0 ≤ i < `tuple_size_v<UTuple>`.
+``` cpp
+template<tuple-like TTuple, tuple-like UTuple,
+         template<class> class TQual, template<class> class UQual>
+struct basic_common_reference<TTuple, UTuple, TQual, UQual> {
+  using type = see below;
+};
+```
+*Constraints:*
+- `TTuple` is a specialization of `tuple` or `UTuple` is a
+  specialization of `tuple`.
+- `is_same_v<TTuple, decay_t<TTuple>>` is `true`.
+- `is_same_v<UTuple, decay_t<UTuple>>` is `true`.
+- `tuple_size_v<TTuple>` equals `tuple_size_v<UTuple>`.
+- `tuple<common_reference_t<TQual<TTypes>, UQual<UTypes>>...>` denotes a
+  type.
+The member *typedef-name* `type` denotes the type
+`tuple<common_reference_t<TQual<TTypes>, UQual<UTypes>>...>`.
+``` cpp
+template<tuple-like TTuple, tuple-like UTuple>
+struct common_type<TTuple, UTuple> {
+  using type = see below;
+};
+```
+*Constraints:*
+- `TTuple` is a specialization of `tuple` or `UTuple` is a
+  specialization of `tuple`.
+- `is_same_v<TTuple, decay_t<TTuple>>` is `true`.
+- `is_same_v<UTuple, decay_t<UTuple>>` is `true`.
+- `tuple_size_v<TTuple>` equals `tuple_size_v<UTuple>`.
+- `tuple<common_type_t<TTypes, UTypes>...>` denotes a type.
+The member *typedef-name* `type` denotes the type
+`tuple<common_type_t<TTypes, UTypes>...>`.
 ### 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 [[allocator.requirements.general]].
 [*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);
+template<class... Types>
+  constexpr void swap(const tuple<Types...>& x, const tuple<Types...>& y) noexcept(see below);
 ```
+*Constraints:*
+- For the first overload, `(is_swappable_v<Types> && ...)` is `true`.
+- For the second overload, `(is_swappable_v<const Types> && ...)` is
+ `true`.
 *Effects:* As if by `x.swap(y)`.
+*Remarks:* The exception specification is equivalent to:
+``` cpp
+noexcept(x.swap(y))
+```

Diff to HTML by rtfpessoa