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

Files changed (1) hide show

tmp/tmpn_lpasmn/{from.md → to.md} +386 -252

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

@@ -8,65 +8,78 @@ 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]].
 ``` cpp
 namespace std {
-  // [tuple.tuple], class template tuple:
-  template <class... Types> class tuple;
-  // [tuple.creation], tuple creation functions:
- const unspecified ignore;
-  template <class... Types>
-    constexpr tuple<VTypes...> make_tuple(Types&&...);
-  template <class... Types>
-    constexpr tuple<Types&&...> forward_as_tuple(Types&&...) noexcept;
-  template<class... Types>
-    constexpr tuple<Types&...> tie(Types&...) noexcept;
   template <class... Tuples>
-    constexpr tuple<Ctypes...> tuple_cat(Tuples&&...);
-  // [tuple.helper], tuple helper classes:
-  template <class T> class tuple_size;  // undefined
   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; // undefined
   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:
   template <size_t I, class... Types>
-    constexpr tuple_element_t<I, tuple<Types...>>&
-      get(tuple<Types...>&) noexcept;
   template <size_t I, class... Types>
-    constexpr tuple_element_t<I, tuple<Types...>>&&
-      get(tuple<Types...>&&) noexcept;
   template <size_t I, class... Types>
-    constexpr const tuple_element_t<I, tuple<Types...>>&
-      get(const tuple<Types...>&) noexcept;
   template <class T, class... Types>
     constexpr T& get(tuple<Types...>& t) noexcept;
   template <class T, class... Types>
     constexpr T&& get(tuple<Types...>&& t) noexcept;
   template <class T, class... Types>
     constexpr const T& get(const tuple<Types...>& t) noexcept;
-  // [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>
@@ -80,62 +93,65 @@ namespace std {
   // [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);
 }
 ```
 ### Class template `tuple` <a id="tuple.tuple">[[tuple.tuple]]</a>
 ``` cpp
 namespace std {
   template <class... Types>
     class tuple  {
     public:
       // [tuple.cnstr], tuple construction
- constexpr tuple();
- constexpr explicit tuple(const Types&...);
       template <class... UTypes>
- constexpr explicit tuple(UTypes&&...);
       tuple(const tuple&) = default;
       tuple(tuple&&) = default;
       template <class... UTypes>
- constexpr tuple(const tuple<UTypes...>&);
       template <class... UTypes>
- constexpr tuple(tuple<UTypes...>&&);
       template <class U1, class U2>
- constexpr tuple(const pair<U1, U2>&); // only if sizeof...(Types) == 2
       template <class U1, class U2>
- 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>
- tuple(allocator_arg_t, const Alloc& a, const Types&...);
       template <class Alloc, class... UTypes>
- 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>
- tuple(allocator_arg_t, const Alloc& a, const tuple<UTypes...>&);
       template <class Alloc, class... UTypes>
- tuple(allocator_arg_t, const Alloc& a, tuple<UTypes...>&&);
       template <class Alloc, class U1, class U2>
- tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&);
       template <class Alloc, class U1, class U2>
- tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);
       // [tuple.assign], tuple assignment
       tuple& operator=(const tuple&);
       tuple& operator=(tuple&&) noexcept(see below);
@@ -150,158 +166,194 @@ namespace std {
         tuple& operator=(pair<U1, U2>&&);                   // only if sizeof...(Types) == 2
       // [tuple.swap], tuple swap
       void swap(tuple&) noexcept(see below);
     };
 }
 ```
 #### 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.
 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
-constexpr tuple();
 ```
-*Requires:* `is_default_constructible<`Tᵢ`>::value` is true for all i.
-*Effects:* Value initializes each element.
 ``` cpp
-constexpr explicit tuple(const Types&...);
 ```
-*Requires:* `is_copy_constructible<`Tᵢ`>::value` is true for all i.
 *Effects:* Initializes each element with the value of the corresponding
 parameter.
 ``` cpp
-template <class... UTypes>
-  constexpr explicit tuple(UTypes&&... u);
 ```
-*Requires:* `sizeof...(Types)` `==` `sizeof...(UTypes)`.
-`is_constructible<`Tᵢ`, `Uᵢ`&&>::value` is `true` for all i.
 *Effects:* Initializes the elements in the tuple with the corresponding
 value in `std::forward<UTypes>(u)`.
-This constructor shall not participate in overload resolution unless
-each type in `UTypes` is implicitly convertible to its corresponding
-type in `Types`.
 ``` cpp
 tuple(const tuple& u) = default;
 ```
-*Requires:* `is_copy_constructible<`Tᵢ`>::value` 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<`Tᵢ`>::value` 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 tuple(const tuple<UTypes...>& u);
 ```
-*Requires:* `sizeof...(Types)` `==` `sizeof...(UTypes)`.
-`is_constructible<`Tᵢ`, const `Uᵢ`&>::value` is `true` for all i.
-*Effects:* Constructs each element of `*this` with the corresponding
 element of `u`.
-This constructor shall not participate in overload resolution unless
-`const `Uᵢ`&` is implicitly convertible to Tᵢ for all i.
 ``` cpp
-template <class... UTypes> constexpr tuple(tuple<UTypes...>&& u);
 ```
-*Requires:* `sizeof...(Types)` `==` `sizeof...(UTypes)`.
-`is_constructible<`Tᵢ`, `Uᵢ`&&>::value` is `true` for all i.
 *Effects:* For all i, initializes the iᵗʰ element of `*this` with
-`std::forward<`Uᵢ`>(get<`i`>(u))`.
-This constructor shall not participate in overload resolution unless
-each type in `UTypes` is implicitly convertible to its corresponding
-type in `Types`.
 ``` cpp
-template <class U1, class U2> constexpr tuple(const pair<U1, U2>& u);
 ```
-*Requires:* `sizeof...(Types) == 2`.
-`is_constructible<`T₀`, const U1&>::value` is `true` for the first type
-T₀ in `Types` and `is_constructible<`T₁`, const U2&>::value` is `true`
-for the second type T₁ in `Types`.
-*Effects:* Constructs the first element with `u.first` and the second
 element with `u.second`.
-This constructor shall not participate in overload resolution unless
-`const U1&` is implicitly convertible to T₀ and `const U2&` is
-implicitly convertible to T₁.
 ``` cpp
-template <class U1, class U2> constexpr tuple(pair<U1, U2>&& u);
 ```
-*Requires:* `sizeof...(Types) == 2`.
-`is_constructible<`T₀`, U1&&>::value` is `true` for the first type T₀ in
-`Types` and `is_constructible<`T₁`, U2&&>::value` is `true` for the
-second type T₁ in `Types`.
 *Effects:* Initializes the first element with
 `std::forward<U1>(u.first)` and the second element with
 `std::forward<U2>(u.second)`.
-This constructor shall not participate in overload resolution unless
-`U1` is implicitly convertible to T₀ and `U2` is implicitly convertible
-to T₁.
 ``` cpp
 template <class Alloc>
   tuple(allocator_arg_t, const Alloc& a);
 template <class Alloc>
-  tuple(allocator_arg_t, const Alloc& a, const Types&...);
 template <class Alloc, class... UTypes>
-  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>
-  tuple(allocator_arg_t, const Alloc& a, const tuple<UTypes...>&);
 template <class Alloc, class... UTypes>
-  tuple(allocator_arg_t, const Alloc& a, tuple<UTypes...>&&);
 template <class Alloc, class U1, class U2>
-  tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&);
 template <class Alloc, class U1, class U2>
-  tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);
 ```
 *Requires:* `Alloc` shall meet the requirements for an
 `Allocator` ([[allocator.requirements]]).
@@ -312,240 +364,300 @@ 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
 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);
 ```
-*Requires:* `is_copy_assignable<`Tᵢ`>::value` is `true` for all i.
 *Effects:* Assigns each element of `u` to the corresponding element of
 `*this`.
-*Returns:* `*this`
 ``` cpp
 tuple& operator=(tuple&& u) noexcept(see below);
 ```
-The expression inside `noexcept` is equivalent to the logical
 <span class="smallcaps">and</span> of the following expressions:
 ``` cpp
-is_nothrow_move_assignable<Tᵢ>::value
 ```
 where Tᵢ is the iᵗʰ type in `Types`.
-*Requires:* `is_move_assignable<`Tᵢ`>::value` is `true` for all i.
-*Effects:* For all i, assigns `std::forward<`Tᵢ`>(get<`i`>(u))` to
-`get<`i`>(*this)`.
 *Returns:* `*this`.
 ``` cpp
-template <class... UTypes>
-  tuple& operator=(const tuple<UTypes...>& u);
 ```
-*Requires:* `sizeof...(Types) == sizeof...(UTypes)` and
-`is_assignable<`Tᵢ`&, const `Uᵢ`&>::value` is `true` for all i.
 *Effects:* Assigns each element of `u` to the corresponding element of
 `*this`.
-*Returns:* `*this`
 ``` cpp
-template <class... UTypes>
-  tuple& operator=(tuple<UTypes...>&& u);
 ```
-*Requires:* `is_assignable<Ti&, Ui&&>::value == true` for all `i`.
-`sizeof...(Types)` `==`
-`sizeof...(UTypes)`.
-*Effects:* For all i, assigns `std::forward<`Uᵢ`>(get<`i`)>(u))` to
 `get<`i`>(*this)`.
 *Returns:* `*this`.
 ``` cpp
 template <class U1, class U2> tuple& operator=(const pair<U1, U2>& u);
 ```
-*Requires:* `sizeof...(Types) == 2`.
-`is_assignable<`T₀`&, const U1&>::value` is `true` for the first type T₀
-in `Types` and `is_assignable<`T₁`&, const U2&>::value` is `true` for
-the second type T₁ in `Types`.
 *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> tuple& operator=(pair<U1, U2>&& u);
 ```
-*Requires:* `sizeof...(Types) == 2`. `is_assignable<`T₀`&, U1&&>::value`
-is `true` for the first type T₀ in `Types` and
-`is_assignable<`T₁`&, U2&&>::value` is `true` for the second type T₁ in
-`Types`.
 *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
 void swap(tuple& rhs) noexcept(see below);
 ```
-The expression inside `noexcept` is equivalent to the logical
-<span class="smallcaps">and</span> of the following expressions:
-``` cpp
-noexcept(swap(declval<Tᵢ&>>(), declval<Tᵢ&>()))
-```
-where Tᵢ is the iᵗʰ type in `Types`.
 *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`.
 *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, let i be in the range \[`0`,
-`sizeof...(TTypes)`) in order and let Tᵢ be the iᵗʰ type in a template
-parameter pack named `TTypes`; let j be in the range \[`0`,
-`sizeof...(UTypes)`) in order and Uⱼ be the jᵗʰ type in a template
-parameter pack named `UTypes`, where indexing is zero-based.
 ``` cpp
-template<class... Types>
-  constexpr tuple<VTypes...> make_tuple(Types&&... t);
 ```
-Let Uᵢ be `decay_t<`Tᵢ`>` for each Tᵢ in `Types`. Then each Vᵢ in
-`VTypes` is `X&` if Uᵢ equals `reference_wrapper<X>`, otherwise Vᵢ is
-Uᵢ.
-*Returns:* `tuple<VTypes...>(std::forward<Types>(t)...)`.
 ``` cpp
 int i; float j;
 make_tuple(1, ref(i), cref(j))
 ```
-creates a tuple of type
-``` cpp
-tuple<int, int&, const float&>
-```
 ``` cpp
-template<class... Types>
-  constexpr tuple<Types&&...> forward_as_tuple(Types&&... 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<Types&&...>(std::forward<Types>(t)...)`
 ``` cpp
-template<class... Types>
-  constexpr tuple<Types&...> tie(Types&... t) noexcept;
 ```
-*Returns:* `tuple<Types&...>(t...)`. When an argument in `t` is
 `ignore`, assigning any value to the corresponding tuple element has no
 effect.
 `tie` functions allow one to create tuples that unpack tuples into
 variables. `ignore` can be used for elements that are not needed:
 ``` cpp
 int i; std::string s;
 tie(i, ignore, s) = make_tuple(42, 3.14, "C++");
 // i == 42, s == "C++"
 ```
 ``` 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<Ti>`, 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ᵢₖ} be the
-kᵢᵗʰ type in Argsᵢ. For all Aᵢₖ the following requirements shall be
-satisfied: If Tᵢ is deduced as an lvalue reference type, then
-`is_constructible<`Aᵢₖ`, `cvᵢ` `Aᵢₖ`&>::value == true`, otherwise
-`is_constructible<`Aᵢₖ`, `cvᵢ Aᵢₖ`&&>::value == true`.
-*Remarks:* The types in *`Ctypes`* shall be equal to the ordered
-sequence of the extended types Args₀`..., `Args₁`...,` ... Argsₙ₋₁`...`,
-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ᵢₖ in eᵢ`...` with
-`get<`kᵢ`>(std::forward<`Tᵢ`>(`tpᵢ`))` for each valid kᵢ and each group
-eᵢ in order.
-*Note:* An implementation may support additional types in the parameter
-pack `Tuples` that support the `tuple`-like protocol, such as `pair` and
-`array`.
 #### Tuple helper classes <a id="tuple.helper">[[tuple.helper]]</a>
 ``` cpp
 template <class T> struct tuple_size;
 ```
-*Remarks:* All specializations of `tuple_size<T>` shall meet the
-`UnaryTypeTrait` requirements ([[meta.rqmts]]) with a
-`BaseCharacteristic` 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:
-  typedef TI type;
   };
 ```
 *Requires:* `I < sizeof...(Types)`. The program is ill-formed if `I` is
 out of bounds.
@@ -557,101 +669,119 @@ is zero-based.
 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`. Then
-each of the three templates shall meet the `UnaryTypeTrait`
-requirements ([[meta.rqmts]]) with a `BaseCharacteristic` of
 ``` cpp
 integral_constant<size_t, TS::value>
 ```
 ``` 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<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`*`::type>`,
-- for the second specialization, `add_volatile_t<`*`TE`*`::type>`, and
-- for the third specialization, `add_cv_t<`*`TE`*`::type>`.
 #### 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;
 ```
 *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.
-``` cpp
-template <size_t I, class... Types>
-  constexpr tuple_element_t<I, tuple<Types...> >&& get(tuple<Types...>&& t) noexcept;
-```
-*Effects:* Equivalent to
-`return std::forward<typename tuple_element<I, tuple<Types...> >`
-`::type&&>(get<I>(t));`
-*Note:* 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&&`.
-``` cpp
-template <size_t I, class... Types>
-  constexpr tuple_element_t<I, tuple<Types...> > const& get(const tuple<Types...>& t) noexcept;
-```
-*Requires:* `I < sizeof...(Types)`. The program is ill-formed if `I` is
-out of bounds.
-*Returns:* A const reference to the `I`th element of `t`, where indexing
-is zero-based.
-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
-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.
 ``` cpp
 template <class T, class... Types>
   constexpr T& get(tuple<Types...>& t) noexcept;
 template <class T, class... Types>
   constexpr T&& get(tuple<Types...>&& t) noexcept;
 template <class T, class... Types>
   constexpr const T& get(const tuple<Types...>& t) noexcept;
 ```
 *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...`.
 ``` 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
 ```
-The reason `get` is a nonmember 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.
 #### Relational operators <a id="tuple.rel">[[tuple.rel]]</a>
 ``` cpp
 template<class... TTypes, class... UTypes>
@@ -674,11 +804,11 @@ after the first equality comparison that evaluates to `false`.
 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)` 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:
@@ -704,24 +834,25 @@ template<class... TTypes, class... UTypes>
 ``` 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)`
-The above definitions for comparison operators 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
-operators are short circuited; they do not perform element accesses
-beyond what is required to determine the result of the comparison.
 #### Tuple traits <a id="tuple.traits">[[tuple.traits]]</a>
 ``` cpp
 template <class... Types, class Alloc>
@@ -729,24 +860,27 @@ template <class... Types, class Alloc>
 ```
 *Requires:* `Alloc` shall be an
 `Allocator` ([[allocator.requirements]]).
-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`.
 #### 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);
 ```
-The expression inside `noexcept` is equivalent to:
 ``` cpp
 noexcept(x.swap(y))
 ```
-*Effects:* `x.swap(y)`

 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>
+    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> 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
   template <size_t I, class... Types>
+    constexpr tuple_element_t<I, tuple<Types...>>& get(tuple<Types...>&) noexcept;
   template <size_t I, class... Types>
+    constexpr tuple_element_t<I, tuple<Types...>>&& get(tuple<Types...>&&) noexcept;
   template <size_t I, class... Types>
+    constexpr const tuple_element_t<I, tuple<Types...>>& get(const tuple<Types...>&) noexcept;
+  template <size_t I, class... Types>
+    constexpr const tuple_element_t<I, tuple<Types...>>&& get(const tuple<Types...>&&) noexcept;
   template <class T, class... Types>
     constexpr T& get(tuple<Types...>& t) noexcept;
   template <class T, class... Types>
     constexpr T&& get(tuple<Types...>&& t) noexcept;
   template <class T, class... Types>
     constexpr const T& get(const tuple<Types...>& t) noexcept;
+  template <class T, class... Types>
+    constexpr const T&& get(const tuple<Types...>&& t) noexcept;
+  // [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>
   // [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;
 }
 ```
 ### Class template `tuple` <a id="tuple.tuple">[[tuple.tuple]]</a>
 ``` cpp
 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);
         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>
+    tuple(pair<T1, T2>) -> tuple<T1, T2>;
+  template<class Alloc, class... UTypes>
+    tuple(allocator_arg_t, Alloc, UTypes...) -> tuple<UTypes...>;
+  template<class Alloc, class T1, class T2>
+    tuple(allocator_arg_t, Alloc, pair<T1, T2>) -> tuple<T1, T2>;
+  template<class Alloc, class... UTypes>
+    tuple(allocator_arg_t, Alloc, tuple<UTypes...>) -> tuple<UTypes...>;
 }
 ```
 #### 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]]).
 #### 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
 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ᵢ>
 ```
 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
+<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 parameter
+pack `XTypes` are denoted by `X`ᵢ for i in \[`0`,
+`sizeof...(`*X*`Types)`) in order, where indexing is zero-based.
 ``` cpp
+template<class... TTypes>
+  constexpr tuple<VTypes...> make_tuple(TTypes&&... t);
 ```
+The pack `VTypes` is defined as follows. Let `U`ᵢ be `decay_t<T`ᵢ`>` for
+each `T`ᵢ in `TTypes`. If `U`ᵢ is a specialization of
+`reference_wrapper`, then `V`ᵢ in `VTypes` is `U`ᵢ`::type&`, otherwise
+`V`ᵢ is `U`ᵢ.
+*Returns:* `tuple<VTypes...>(std::forward<TTypes>(t)...)`.
+[*Example 1*:
 ``` cpp
 int i; float j;
 make_tuple(1, ref(i), cref(j))
 ```
+creates a tuple of type `tuple<int, int&, const float&>`.
+— *end example*]
 ``` cpp
+template<class... TTypes>
+  constexpr tuple<TTypes&&...> forward_as_tuple(TTypes&&... t) noexcept;
 ```
 *Effects:* Constructs a tuple of references to the arguments in `t`
 suitable for forwarding as arguments to a function. Because the result
 may contain references to temporary variables, a program shall ensure
 that the return value of this function does not outlive any of its
+arguments (e.g., the program should typically not store the result in a
 named variable).
+*Returns:* `tuple<TTypes&&...>(std::forward<TTypes>(t)...)`.
 ``` cpp
+template<class... TTypes>
+  constexpr tuple<TTypes&...> tie(TTypes&... t) noexcept;
 ```
+*Returns:* `tuple<TTypes&...>(t...)`. When an argument in `t` is
 `ignore`, assigning any value to the corresponding tuple element has no
 effect.
+[*Example 2*:
 `tie` functions allow one to create tuples that unpack tuples into
 variables. `ignore` can be used for elements that are not needed:
 ``` cpp
 int i; std::string s;
 tie(i, ignore, s) = make_tuple(42, 3.14, "C++");
 // i == 42, s == "C++"
 ```
+— *end example*]
 ``` cpp
 template <class... Tuples>
   constexpr tuple<CTypes...> tuple_cat(Tuples&&... tpls);
 ```
+In the following paragraphs, let `Tᵢ` be the iᵗʰ type in `Tuples`, `Uᵢ`
+be `remove_reference_t<T`ᵢ`>`, and `tpᵢ` be the iᵗʰ parameter in the
+function parameter pack `tpls`, where all indexing is zero-based.
+*Requires:* For all i, `Uᵢ` shall be the type cvᵢ `tuple<``Argsᵢ``...>`,
+where cvᵢ is the (possibly empty) iᵗʰ *cv-qualifier-seq* and `Argsᵢ` is
+the parameter pack representing the element types in `Uᵢ`. Let `A_ik` be
+the kᵗʰ type in `Argsᵢ`. For all `A_ik` the following requirements shall
+be satisfied:
+- If `Tᵢ` is deduced as an lvalue reference type, then
+ `is_constructible_v<``A_ik``, `cvᵢ `A_ik``&> == true`, otherwise
+- `is_constructible_v<``A_ik``, `cvᵢ `A_ik``&&> == true`.
+*Remarks:* The types in `CTypes` shall be equal to the ordered sequence
+of the extended types `Args₀``..., ``Args₁``..., `…`, ``Args_n-1``...`,
+where n is equal to `sizeof...(Tuples)`. Let `eᵢ``...` be the iᵗʰ
+ordered sequence of tuple elements of the resulting `tuple` object
+corresponding to the type sequence `Argsᵢ`.
 *Returns:* A `tuple` object constructed by initializing the kᵢᵗʰ type
+element `e_ik` in `eᵢ``...` with
+``` cpp
+get<kᵢ>(std::forward<$T_i$>($tp_i$))
+```
+for each valid kᵢ and each group `eᵢ` in order.
+[*Note 1*: An implementation may support additional types in the
+parameter pack `Tuples` that support the `tuple`-like protocol, such as
+`pair` and `array`. — *end note*]
+#### Calling a function with a `tuple` of arguments <a id="tuple.apply">[[tuple.apply]]</a>
+``` cpp
+template <class F, class Tuple>
+  constexpr decltype(auto) apply(F&& f, Tuple&& t);
+```
+*Effects:* Given the exposition-only function:
+``` cpp
+template <class F, class Tuple, size_t... I>
+constexpr decltype(auto)
+    apply_impl(F&& f, Tuple&& t, index_sequence<I...>) {                // exposition only
+  return INVOKE(std::forward<F>(f), std::get<I>(std::forward<Tuple>(t))...);
+}
+```
+Equivalent to:
+``` cpp
+return apply_impl(std::forward<F>(f), std::forward<Tuple>(t),
+                  make_index_sequence<tuple_size_v<decay_t<Tuple>>>{});
+```
+``` cpp
+template <class T, class Tuple>
+  constexpr T make_from_tuple(Tuple&& t);
+```
+*Effects:* Given the exposition-only function:
+``` cpp
+template <class T, class Tuple, size_t... I>
+constexpr T make_from_tuple_impl(Tuple&& t, index_sequence<I...>) {     // exposition only
+  return T(get<I>(std::forward<Tuple>(t))...);
+}
+```
+Equivalent to:
+``` cpp
+return make_from_tuple_impl<T>(forward<Tuple>(t),
+                               make_index_sequence<tuple_size_v<decay_t<Tuple>>>{});
+```
+[*Note 1*: The type of `T` must be supplied as an explicit template
+parameter, as it cannot be deduced from the argument
+list. — *end note*]
 #### Tuple helper classes <a id="tuple.helper">[[tuple.helper]]</a>
 ``` cpp
 template <class T> struct tuple_size;
 ```
+*Remarks:* All specializations of `tuple_size` shall meet the
+`UnaryTypeTrait` requirements ([[meta.rqmts]]) with a base
+characteristic of `integral_constant<size_t, N>` for some `N`.
 ``` cpp
 template <class... Types>
+ class tuple_size<tuple<Types...>> : public integral_constant<size_t, sizeof...(Types)> { };
 ```
 ``` cpp
 template <size_t I, class... Types>
   class tuple_element<I, tuple<Types...>> {
   public:
+    using type = TI;
   };
 ```
 *Requires:* `I < sizeof...(Types)`. The program is ill-formed if `I` is
 out of bounds.
 template <class T> class tuple_size<const T>;
 template <class T> class tuple_size<volatile T>;
 template <class T> class tuple_size<const volatile T>;
 ```
+Let *`TS`* denote `tuple_size<T>` of the cv-unqualified type `T`. If the
+expression *`TS`*`::value` is well-formed when treated as an unevaluated
+operand, then each of the three templates shall meet the
+`UnaryTypeTrait` requirements ([[meta.rqmts]]) with a base
+characteristic of
 ``` cpp
 integral_constant<size_t, TS::value>
 ```
+Otherwise, they shall have no member `value`.
+Access checking is performed as if in a context unrelated to *`TS`* and
+`T`. Only the validity of the immediate context of the expression is
+considered.
+[*Note 1*: The compilation of the expression can result in side effects
+such as the instantiation of class template specializations and function
+template specializations, the generation of implicitly-defined
+functions, and so on. Such side effects are not in the “immediate
+context” and can result in the program being ill-formed. — *end note*]
+In addition to being available via inclusion of the `<tuple>` header,
+the three templates are available when either of the headers `<array>`
+or `<utility>` are included.
 ``` cpp
 template <size_t I, class T> class tuple_element<I, const T>;
 template <size_t I, class T> class tuple_element<I, volatile T>;
 template <size_t I, class T> class tuple_element<I, const volatile T>;
 ```
+Let *`TE`* denote `tuple_element_t<I, T>` of the cv-unqualified type
+`T`. Then each of the three templates shall meet the
+`TransformationTrait` requirements ([[meta.rqmts]]) with a member
+typedef `type` that names the following type:
+- for the first specialization, `add_const_t<`*`TE`*`>`,
+- for the second specialization, `add_volatile_t<`*`TE`*`>`, and
+- for the third specialization, `add_cv_t<`*`TE`*`>`.
+In addition to being available via inclusion of the `<tuple>` header,
+the three templates are available when either of the headers `<array>`
+or `<utility>` are included.
 #### Element access <a id="tuple.elem">[[tuple.elem]]</a>
 ``` cpp
 template <size_t I, class... Types>
+  constexpr tuple_element_t<I, tuple<Types...>>&
+    get(tuple<Types...>& t) noexcept;
+template <size_t I, class... Types>
+  constexpr tuple_element_t<I, tuple<Types...>>&&
+    get(tuple<Types...>&& t) noexcept;        // Note A
+template <size_t I, class... Types>
+  constexpr const tuple_element_t<I, tuple<Types...>>&
+    get(const tuple<Types...>& t) noexcept;   // Note B
+template <size_t I, class... Types>
+  constexpr const tuple_element_t<I, tuple<Types...>>&& get(const tuple<Types...>&& t) noexcept;
 ```
 *Requires:* `I < sizeof...(Types)`. The program is ill-formed if `I` is
 out of bounds.
 *Returns:* A reference to the `I`th element of `t`, where indexing is
 zero-based.
+[*Note 1*: \[Note A\]If a `T` in `Types` is some reference type `X&`,
+the return type is `X&`, not `X&&`. However, if the element type is a
+non-reference type `T`, the return type is `T&&`. — *end note*]
+[*Note 2*: \[Note B\]Constness is shallow. If a `T` in `Types` is some
+reference type `X&`, the return type is `X&`, not `const X&`. However,
+if the element type is a non-reference type `T`, the return type is
+`const T&`. This is consistent with how constness is defined to work for
+member variables of reference type. — *end note*]
 ``` cpp
 template <class T, class... Types>
   constexpr T& get(tuple<Types...>& t) noexcept;
 template <class T, class... Types>
   constexpr T&& get(tuple<Types...>&& t) noexcept;
 template <class T, class... Types>
   constexpr const T& get(const tuple<Types...>& t) noexcept;
+template <class T, class... Types>
+  constexpr const T&& get(const tuple<Types...>&& t) noexcept;
 ```
 *Requires:* The type `T` occurs exactly once in `Types...`. Otherwise,
 the program is ill-formed.
 *Returns:* A reference to the element of `t` corresponding to the type
 `T` in `Types...`.
+[*Example 1*:
 ``` cpp
 const tuple<int, const int, double, double> t(1, 2, 3.4, 5.6);
   const int& i1 = get<int>(t);        // OK. Not ambiguous. i1 == 1
   const int& i2 = get<const int>(t);  // OK. Not ambiguous. i2 == 2
   const double& d = get<double>(t);   // ERROR. ill-formed
 ```
+— *end example*]
+[*Note 1*: The reason `get` is a non-member function is that if this
+functionality had been provided as a member function, code where the
+type depended on a template parameter would have required using the
+`template` keyword. — *end note*]
 #### Relational operators <a id="tuple.rel">[[tuple.rel]]</a>
 ``` cpp
 template<class... TTypes, class... UTypes>
 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:
 ``` 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>
 ```
 *Requires:* `Alloc` shall be an
 `Allocator` ([[allocator.requirements]]).
+[*Note 1*: Specialization of this trait informs other library
+components that `tuple` can be constructed with an allocator, even
+though it does not have a nested `allocator_type`. — *end note*]
 #### Tuple specialized algorithms <a id="tuple.special">[[tuple.special]]</a>
 ``` cpp
 template <class... Types>
   void swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(see below);
 ```
+*Remarks:* This function shall not participate in overload resolution
+unless `is_swappable_v<``Tᵢ``>` is `true` for all i, where
+0 ≤ i < `sizeof...(Types)`. The expression inside `noexcept` is
+equivalent to:
 ``` cpp
 noexcept(x.swap(y))
 ```
+*Effects:* As if by `x.swap(y)`.

Diff to HTML by rtfpessoa